RTEMS 4.11Annotated Report
Thu Dec 20 14:12:14 2012
0200b5f0 <IMFS_chown>:
int IMFS_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
200b5f0: 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();
200b5f4: 40 00 02 4a call 200bf1c <geteuid>
200b5f8: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
200b5fc: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
200b600: 91 2a 20 10 sll %o0, 0x10, %o0
200b604: 91 32 20 10 srl %o0, 0x10, %o0
200b608: 80 a2 00 01 cmp %o0, %g1
200b60c: 02 80 00 0a be 200b634 <IMFS_chown+0x44>
200b610: 80 a2 20 00 cmp %o0, 0
200b614: 22 80 00 09 be,a 200b638 <IMFS_chown+0x48> <== NEVER TAKEN
200b618: f2 37 60 3c sth %i1, [ %i5 + 0x3c ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
200b61c: 40 00 10 14 call 200f66c <__errno>
200b620: b0 10 3f ff mov -1, %i0
200b624: 82 10 20 01 mov 1, %g1
200b628: c2 22 00 00 st %g1, [ %o0 ]
200b62c: 81 c7 e0 08 ret
200b630: 81 e8 00 00 restore
#endif
jnode->st_uid = owner;
200b634: f2 37 60 3c sth %i1, [ %i5 + 0x3c ]
jnode->st_gid = group;
200b638: f4 37 60 3e sth %i2, [ %i5 + 0x3e ]
IMFS_update_ctime( jnode );
200b63c: 90 07 bf f8 add %fp, -8, %o0
200b640: 7f ff e0 06 call 2003658 <gettimeofday>
200b644: 92 10 20 00 clr %o1
200b648: c2 07 bf f8 ld [ %fp + -8 ], %g1
200b64c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
200b650: 81 c7 e0 08 ret
200b654: 91 e8 20 00 restore %g0, 0, %o0
02005690 <IMFS_dump_directory>:
*/
static void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
2005690: 9d e3 bf a0 save %sp, -96, %sp
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
2005694: 35 00 80 87 sethi %hi(0x2021c00), %i2
2005698: 39 00 80 8f sethi %hi(0x2023c00), %i4
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
200569c: 21 00 80 87 sethi %hi(0x2021c00), %l0
return;
}
puts("");
20056a0: 23 00 80 87 sethi %hi(0x2021c00), %l1
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
20056a4: 25 00 80 87 sethi %hi(0x2021c00), %l2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
20056a8: fa 06 20 50 ld [ %i0 + 0x50 ], %i5
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
20056ac: b4 16 a2 a0 or %i2, 0x2a0, %i2
20056b0: b8 17 23 d0 or %i4, 0x3d0, %i4
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
20056b4: a0 14 23 10 or %l0, 0x310, %l0
return;
}
puts("");
20056b8: a2 14 62 38 or %l1, 0x238, %l1
IMFS_assert( level >= 0 );
IMFS_assert( IMFS_is_directory( the_directory ) );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
20056bc: 10 80 00 4d b 20057f0 <IMFS_dump_directory+0x160>
20056c0: a4 14 a2 f8 or %l2, 0x2f8, %l2
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
20056c4: 90 10 00 1a mov %i2, %o0
20056c8: 40 00 38 f0 call 2013a88 <fputs>
20056cc: b6 06 e0 01 inc %i3
20056d0: 10 80 00 03 b 20056dc <IMFS_dump_directory+0x4c>
20056d4: c2 07 00 00 ld [ %i4 ], %g1
20056d8: c2 07 00 00 ld [ %i4 ], %g1
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
20056dc: 80 a6 c0 19 cmp %i3, %i1
20056e0: 04 bf ff f9 ble 20056c4 <IMFS_dump_directory+0x34>
20056e4: d2 00 60 08 ld [ %g1 + 8 ], %o1
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
20056e8: 40 00 38 e8 call 2013a88 <fputs>
20056ec: 90 07 60 0c add %i5, 0xc, %o0
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
20056f0: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
20056f4: d4 00 40 00 ld [ %g1 ], %o2
switch( IMFS_type( the_jnode ) ) {
20056f8: 80 a2 a0 06 cmp %o2, 6
20056fc: 38 80 00 2d bgu,a 20057b0 <IMFS_dump_directory+0x120> <== NEVER TAKEN
2005700: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
2005704: 95 2a a0 02 sll %o2, 2, %o2
2005708: 03 00 80 15 sethi %hi(0x2005400), %g1
200570c: 82 10 62 74 or %g1, 0x274, %g1 ! 2005674 <bsp_interrupt_handler_default+0x18>
2005710: c2 00 40 0a ld [ %g1 + %o2 ], %g1
2005714: 81 c0 40 00 jmp %g1
2005718: 01 00 00 00 nop
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
200571c: c2 07 00 00 ld [ %i4 ], %g1
2005720: 90 10 20 2f mov 0x2f, %o0
2005724: 40 00 38 a5 call 20139b8 <fputc>
2005728: d2 00 60 08 ld [ %g1 + 8 ], %o1
200572c: 30 80 00 26 b,a 20057c4 <IMFS_dump_directory+0x134>
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
2005730: c2 07 00 00 ld [ %i4 ], %g1
2005734: 13 00 80 87 sethi %hi(0x2021c00), %o1
2005738: d0 00 60 08 ld [ %g1 + 8 ], %o0
200573c: 92 12 62 a8 or %o1, 0x2a8, %o1
2005740: 10 80 00 08 b 2005760 <IMFS_dump_directory+0xd0>
2005744: d4 1f 60 50 ldd [ %i5 + 0x50 ], %o2
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
2005748: c2 07 00 00 ld [ %i4 ], %g1
200574c: d4 07 60 54 ld [ %i5 + 0x54 ], %o2
2005750: d0 00 60 08 ld [ %g1 + 8 ], %o0
2005754: d6 07 60 58 ld [ %i5 + 0x58 ], %o3
2005758: 13 00 80 87 sethi %hi(0x2021c00), %o1
200575c: 92 12 62 c0 or %o1, 0x2c0, %o1 ! 2021ec0 <Configuration_Initial_Extensions+0x16a0>
2005760: 40 00 38 7a call 2013948 <fprintf>
2005764: 01 00 00 00 nop
2005768: 30 80 00 17 b,a 20057c4 <IMFS_dump_directory+0x134>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
200576c: c2 07 00 00 ld [ %i4 ], %g1
2005770: d4 07 60 54 ld [ %i5 + 0x54 ], %o2
2005774: d0 00 60 08 ld [ %g1 + 8 ], %o0
2005778: 13 00 80 87 sethi %hi(0x2021c00), %o1
200577c: 40 00 38 73 call 2013948 <fprintf>
2005780: 92 12 62 d0 or %o1, 0x2d0, %o1 ! 2021ed0 <Configuration_Initial_Extensions+0x16b0>
2005784: 30 80 00 10 b,a 20057c4 <IMFS_dump_directory+0x134>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
2005788: 11 00 80 87 sethi %hi(0x2021c00), %o0
200578c: c2 07 00 00 ld [ %i4 ], %g1
2005790: 10 80 00 04 b 20057a0 <IMFS_dump_directory+0x110>
2005794: 90 12 22 e0 or %o0, 0x2e0, %o0
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
2005798: c2 07 00 00 ld [ %i4 ], %g1
200579c: 90 10 00 12 mov %l2, %o0
20057a0: 40 00 38 ba call 2013a88 <fputs>
20057a4: d2 00 60 08 ld [ %g1 + 8 ], %o1
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
20057a8: 10 80 00 0a b 20057d0 <IMFS_dump_directory+0x140>
20057ac: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
20057b0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
20057b4: 40 00 38 65 call 2013948 <fprintf> <== NOT EXECUTED
20057b8: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
20057bc: 10 80 00 05 b 20057d0 <IMFS_dump_directory+0x140> <== NOT EXECUTED
20057c0: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
return;
}
puts("");
20057c4: 40 00 3f 98 call 2015624 <puts>
20057c8: 90 10 00 11 mov %l1, %o0
20057cc: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
20057d0: c2 00 40 00 ld [ %g1 ], %g1
20057d4: 80 a0 60 00 cmp %g1, 0
20057d8: 32 80 00 06 bne,a 20057f0 <IMFS_dump_directory+0x160>
20057dc: fa 07 40 00 ld [ %i5 ], %i5
IMFS_dump_directory( the_jnode, level + 1 );
20057e0: 90 10 00 1d mov %i5, %o0
20057e4: 7f ff ff ab call 2005690 <IMFS_dump_directory>
20057e8: 92 06 60 01 add %i1, 1, %o1
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
20057ec: fa 07 40 00 ld [ %i5 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
20057f0: 82 06 20 54 add %i0, 0x54, %g1
IMFS_assert( level >= 0 );
IMFS_assert( IMFS_is_directory( the_directory ) );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
20057f4: 80 a7 40 01 cmp %i5, %g1
20057f8: 12 bf ff b8 bne 20056d8 <IMFS_dump_directory+0x48>
20057fc: b6 10 20 00 clr %i3
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
IMFS_dump_directory( the_jnode, level + 1 );
}
}
2005800: 81 c7 e0 08 ret
2005804: 81 e8 00 00 restore
0200b794 <IMFS_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
200b794: 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;
200b798: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
bool access_ok = rtems_filesystem_eval_path_check_access(
200b79c: 90 10 00 18 mov %i0, %o0
200b7a0: d4 07 20 30 ld [ %i4 + 0x30 ], %o2
200b7a4: d6 17 20 3c lduh [ %i4 + 0x3c ], %o3
200b7a8: d8 17 20 3e lduh [ %i4 + 0x3e ], %o4
200b7ac: 40 00 02 f3 call 200c378 <rtems_filesystem_eval_path_check_access>
200b7b0: 92 10 20 01 mov 1, %o1
dir->st_mode,
dir->st_uid,
dir->st_gid
);
if ( access_ok ) {
200b7b4: 80 8a 20 ff btst 0xff, %o0
200b7b8: 12 80 00 04 bne 200b7c8 <IMFS_eval_token+0x34>
200b7bc: 80 a6 e0 01 cmp %i3, 1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200b7c0: 81 c7 e0 08 ret
200b7c4: 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] == '.';
200b7c8: 12 80 00 06 bne 200b7e0 <IMFS_eval_token+0x4c>
200b7cc: 82 10 20 00 clr %g1
200b7d0: c2 4e 80 00 ldsb [ %i2 ], %g1
200b7d4: 82 18 60 2e xor %g1, 0x2e, %g1
200b7d8: 80 a0 00 01 cmp %g0, %g1
200b7dc: 82 60 3f ff subx %g0, -1, %g1
IMFS_jnode_t *dir,
const char *token,
size_t tokenlen
)
{
if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {
200b7e0: 80 a0 60 00 cmp %g1, 0
200b7e4: 12 80 00 2b bne 200b890 <IMFS_eval_token+0xfc>
200b7e8: 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] == '.';
200b7ec: 12 80 00 0b bne 200b818 <IMFS_eval_token+0x84>
200b7f0: 80 a0 60 00 cmp %g1, 0
200b7f4: c4 4e 80 00 ldsb [ %i2 ], %g2
200b7f8: 80 a0 a0 2e cmp %g2, 0x2e
200b7fc: 12 80 00 07 bne 200b818 <IMFS_eval_token+0x84>
200b800: 80 a0 60 00 cmp %g1, 0
200b804: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
200b808: 82 18 60 2e xor %g1, 0x2e, %g1
200b80c: 80 a0 00 01 cmp %g0, %g1
200b810: 82 60 3f ff subx %g0, -1, %g1
return dir;
} else {
if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {
200b814: 80 a0 60 00 cmp %g1, 0
200b818: 22 80 00 04 be,a 200b828 <IMFS_eval_token+0x94>
200b81c: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
return dir->Parent;
200b820: 10 80 00 17 b 200b87c <IMFS_eval_token+0xe8>
200b824: fa 07 20 08 ld [ %i4 + 8 ], %i5
} else {
rtems_chain_control *entries = &dir->info.directory.Entries;
rtems_chain_node *current = rtems_chain_first( entries );
rtems_chain_node *tail = rtems_chain_tail( entries );
200b828: 10 80 00 10 b 200b868 <IMFS_eval_token+0xd4>
200b82c: b2 07 20 54 add %i4, 0x54, %i1
while ( current != tail ) {
IMFS_jnode_t *entry = (IMFS_jnode_t *) current;
bool match = strncmp( entry->name, token, tokenlen ) == 0
200b830: 92 10 00 1a mov %i2, %o1
200b834: 40 00 15 47 call 2010d50 <strncmp>
200b838: 94 10 00 1b mov %i3, %o2
&& entry->name [tokenlen] == '\0';
200b83c: 80 a2 20 00 cmp %o0, 0
200b840: 12 80 00 06 bne 200b858 <IMFS_eval_token+0xc4>
200b844: 82 10 20 00 clr %g1
200b848: 82 07 40 1b add %i5, %i3, %g1
200b84c: c2 48 60 0c ldsb [ %g1 + 0xc ], %g1
200b850: 80 a0 00 01 cmp %g0, %g1
200b854: 82 60 3f ff subx %g0, -1, %g1
if ( match ) {
200b858: 80 a0 60 00 cmp %g1, 0
200b85c: 12 80 00 09 bne 200b880 <IMFS_eval_token+0xec>
200b860: 80 a7 60 00 cmp %i5, 0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200b864: 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 ) {
200b868: 80 a7 40 19 cmp %i5, %i1
200b86c: 12 bf ff f1 bne 200b830 <IMFS_eval_token+0x9c>
200b870: 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;
200b874: 81 c7 e0 08 ret
200b878: 91 e8 20 02 restore %g0, 2, %o0
);
if ( access_ok ) {
IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
if ( entry != NULL ) {
200b87c: 80 a7 60 00 cmp %i5, 0
200b880: 32 80 00 06 bne,a 200b898 <IMFS_eval_token+0x104>
200b884: c2 06 20 04 ld [ %i0 + 4 ], %g1
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
}
}
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
200b888: 81 c7 e0 08 ret
200b88c: 91 e8 20 02 restore %g0, 2, %o0
IMFS_jnode_t *dir,
const char *token,
size_t tokenlen
)
{
if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {
200b890: ba 10 00 1c mov %i4, %i5
if ( access_ok ) {
IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
if ( entry != NULL ) {
bool terminal = !rtems_filesystem_eval_path_has_path( ctx );
200b894: c2 06 20 04 ld [ %i0 + 4 ], %g1
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
200b898: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
200b89c: 80 a0 00 01 cmp %g0, %g1
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
200b8a0: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
200b8a4: 84 60 3f ff subx %g0, -1, %g2
200b8a8: c2 00 40 00 ld [ %g1 ], %g1
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
200b8ac: c0 26 20 0c clr [ %i0 + 0xc ]
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
IMFS_jnode_types_t type = IMFS_type( entry );
rtems_filesystem_eval_path_clear_token( ctx );
if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
200b8b0: 80 a0 60 02 cmp %g1, 2
200b8b4: 12 80 00 0a bne 200b8dc <IMFS_eval_token+0x148>
200b8b8: 88 10 00 02 mov %g2, %g4
200b8bc: 80 a0 a0 00 cmp %g2, 0
200b8c0: 22 80 00 2b be,a 200b96c <IMFS_eval_token+0x1d8>
200b8c4: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
200b8c8: 80 88 e0 08 btst 8, %g3
200b8cc: 22 80 00 29 be,a 200b970 <IMFS_eval_token+0x1dc>
200b8d0: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
entry = entry->info.hard_link.link_node;
200b8d4: 10 80 00 26 b 200b96c <IMFS_eval_token+0x1d8>
200b8d8: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
200b8dc: 80 a0 60 03 cmp %g1, 3
200b8e0: 12 80 00 10 bne 200b920 <IMFS_eval_token+0x18c>
200b8e4: 80 a0 60 00 cmp %g1, 0
200b8e8: 80 a0 a0 00 cmp %g2, 0
200b8ec: 02 80 00 04 be 200b8fc <IMFS_eval_token+0x168>
200b8f0: 80 88 e0 10 btst 0x10, %g3
200b8f4: 22 80 00 1f be,a 200b970 <IMFS_eval_token+0x1dc>
200b8f8: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
const char *target = entry->info.sym_link.name;
200b8fc: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
rtems_filesystem_eval_path_recursive( ctx, target, strlen( target ) );
200b900: 40 00 14 e2 call 2010c88 <strlen>
200b904: 90 10 00 1d mov %i5, %o0
200b908: 92 10 00 1d mov %i5, %o1
200b90c: 94 10 00 08 mov %o0, %o2
200b910: 7f ff e4 38 call 20049f0 <rtems_filesystem_eval_path_recursive>
200b914: 90 10 00 18 mov %i0, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200b918: 81 c7 e0 08 ret
200b91c: 91 e8 20 01 restore %g0, 1, %o0
IMFS_jnode_types_t type
)
{
rtems_filesystem_global_location_t **fs_root_ptr = NULL;
if ( type == IMFS_DIRECTORY ) {
200b920: 32 80 00 14 bne,a 200b970 <IMFS_eval_token+0x1dc>
200b924: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
if ( node->info.directory.mt_fs != NULL ) {
200b928: d2 07 60 5c ld [ %i5 + 0x5c ], %o1
200b92c: 80 a2 60 00 cmp %o1, 0
200b930: 02 80 00 0f be 200b96c <IMFS_eval_token+0x1d8>
200b934: 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(
200b938: d4 07 60 30 ld [ %i5 + 0x30 ], %o2
200b93c: d6 17 60 3c lduh [ %i5 + 0x3c ], %o3
200b940: d8 17 60 3e lduh [ %i5 + 0x3e ], %o4
{
rtems_filesystem_global_location_t **fs_root_ptr = NULL;
if ( type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
fs_root_ptr = &node->info.directory.mt_fs->mt_fs_root;
200b944: b8 02 60 24 add %o1, 0x24, %i4
if ( !terminal ) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
access_ok = rtems_filesystem_eval_path_check_access(
200b948: 40 00 02 8c call 200c378 <rtems_filesystem_eval_path_check_access>
200b94c: 92 10 20 01 mov 1, %o1
RTEMS_FS_PERMS_EXEC,
entry->st_mode,
entry->st_uid,
entry->st_gid
);
if ( access_ok ) {
200b950: 80 8a 20 ff btst 0xff, %o0
200b954: 02 80 00 04 be 200b964 <IMFS_eval_token+0x1d0> <== NEVER TAKEN
200b958: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
200b95c: 7f ff e4 0c call 200498c <rtems_filesystem_eval_path_restart>
200b960: 92 10 00 1c mov %i4, %o1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200b964: 81 c7 e0 08 ret
200b968: 91 e8 20 01 restore %g0, 1, %o0
} else {
rtems_filesystem_global_location_t **fs_root_ptr =
IMFS_is_mount_point( entry, type );
if ( fs_root_ptr == NULL ) {
--dir->reference_count;
200b96c: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
200b970: 82 00 7f ff add %g1, -1, %g1
200b974: c2 37 20 34 sth %g1, [ %i4 + 0x34 ]
++entry->reference_count;
200b978: c2 17 60 34 lduh [ %i5 + 0x34 ], %g1
200b97c: 82 00 60 01 inc %g1
200b980: c2 37 60 34 sth %g1, [ %i5 + 0x34 ]
static inline void IMFS_Set_handlers( rtems_filesystem_location_info_t *loc )
{
IMFS_jnode_t *node = (IMFS_jnode_t *) loc->node_access;
loc->handlers = node->control->handlers;
200b984: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
currentloc->node_access = entry;
200b988: fa 26 20 20 st %i5, [ %i0 + 0x20 ]
200b98c: c2 00 60 04 ld [ %g1 + 4 ], %g1
200b990: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200b994: b0 09 20 ff and %g4, 0xff, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
}
}
return status;
}
200b998: 81 c7 e0 08 ret
200b99c: 81 e8 00 00 restore
0200b9b8 <IMFS_fchmod>:
int IMFS_fchmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
200b9b8: 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();
200b9bc: 40 00 01 58 call 200bf1c <geteuid>
200b9c0: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
200b9c4: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
200b9c8: 91 2a 20 10 sll %o0, 0x10, %o0
200b9cc: 91 32 20 10 srl %o0, 0x10, %o0
200b9d0: 80 a2 00 01 cmp %o0, %g1
200b9d4: 02 80 00 0a be 200b9fc <IMFS_fchmod+0x44>
200b9d8: 80 a2 20 00 cmp %o0, 0
200b9dc: 22 80 00 09 be,a 200ba00 <IMFS_fchmod+0x48> <== NEVER TAKEN
200b9e0: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
200b9e4: 40 00 0f 22 call 200f66c <__errno>
200b9e8: b0 10 3f ff mov -1, %i0
200b9ec: 82 10 20 01 mov 1, %g1
200b9f0: c2 22 00 00 st %g1, [ %o0 ]
200b9f4: 81 c7 e0 08 ret
200b9f8: 81 e8 00 00 restore
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
200b9fc: 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 );
200ba00: 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);
200ba04: 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 );
200ba08: 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);
200ba0c: b2 0e 6f ff and %i1, 0xfff, %i1
200ba10: b2 16 40 01 or %i1, %g1, %i1
IMFS_update_ctime( jnode );
200ba14: 7f ff df 11 call 2003658 <gettimeofday>
200ba18: f2 27 60 30 st %i1, [ %i5 + 0x30 ]
200ba1c: c2 07 bf f8 ld [ %fp + -8 ], %g1
200ba20: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
200ba24: 81 c7 e0 08 ret
200ba28: 91 e8 20 00 restore %g0, 0, %o0
02003890 <IMFS_fifo_write>:
static ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
2003890: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
2003894: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
2003898: 96 10 00 18 mov %i0, %o3
200389c: d0 07 60 50 ld [ %i5 + 0x50 ], %o0
20038a0: 92 10 00 19 mov %i1, %o1
20038a4: 40 00 2a 97 call 200e300 <pipe_write>
20038a8: 94 10 00 1a mov %i2, %o2
if (err > 0) {
20038ac: b0 92 20 00 orcc %o0, 0, %i0
20038b0: 04 80 00 09 ble 20038d4 <IMFS_fifo_write+0x44>
20038b4: 90 07 bf f8 add %fp, -8, %o0
IMFS_mtime_ctime_update(jnode);
20038b8: 40 00 04 0e call 20048f0 <gettimeofday>
20038bc: 92 10 20 00 clr %o1
20038c0: c2 07 bf f8 ld [ %fp + -8 ], %g1
20038c4: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
20038c8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
20038cc: 81 c7 e0 08 ret
20038d0: 81 e8 00 00 restore
}
IMFS_FIFO_RETURN(err);
20038d4: 80 a6 20 00 cmp %i0, 0
20038d8: 02 80 00 06 be 20038f0 <IMFS_fifo_write+0x60> <== NEVER TAKEN
20038dc: 01 00 00 00 nop
20038e0: 40 00 37 66 call 2011678 <__errno>
20038e4: b0 20 00 18 neg %i0
20038e8: f0 22 00 00 st %i0, [ %o0 ]
20038ec: b0 10 3f ff mov -1, %i0
}
20038f0: 81 c7 e0 08 ret
20038f4: 81 e8 00 00 restore
0200ba2c <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
)
{
200ba2c: 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;
200ba30: f6 06 20 24 ld [ %i0 + 0x24 ], %i3
200ba34: b8 07 bf e8 add %fp, -24, %i4
200ba38: 92 10 00 1b mov %i3, %o1
200ba3c: 90 10 00 1c mov %i4, %o0
200ba40: 40 00 11 5c call 200ffb0 <memcpy>
200ba44: 94 10 20 18 mov 0x18, %o2
jnode = (IMFS_jnode_t *)loc.node_access;
200ba48: fa 07 bf f0 ld [ %fp + -16 ], %i5
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
200ba4c: c0 26 e0 08 clr [ %i3 + 8 ]
200ba50: b6 10 00 1c mov %i4, %i3
200ba54: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
do {
next = jnode->Parent;
200ba58: f8 07 60 08 ld [ %i5 + 8 ], %i4
200ba5c: c4 00 60 04 ld [ %g1 + 4 ], %g2
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
200ba60: c2 00 40 00 ld [ %g1 ], %g1
temp_mt_entry->mt_fs_root->location.node_access = NULL;
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
200ba64: fa 27 bf f0 st %i5, [ %fp + -16 ]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
200ba68: 80 a0 60 00 cmp %g1, 0
200ba6c: 12 80 00 07 bne 200ba88 <IMFS_fsunmount+0x5c>
200ba70: c4 27 bf f8 st %g2, [ %fp + -8 ]
200ba74: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200ba78: 82 07 60 54 add %i5, 0x54, %g1
200ba7c: 80 a0 80 01 cmp %g2, %g1
200ba80: 32 80 00 10 bne,a 200bac0 <IMFS_fsunmount+0x94>
200ba84: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
result = IMFS_rmnod( NULL, &loc );
200ba88: 90 10 20 00 clr %o0
200ba8c: 7f ff dd 7d call 2003080 <IMFS_rmnod>
200ba90: 92 10 00 1b mov %i3, %o1
if ( result != 0 )
200ba94: 80 a2 20 00 cmp %o0, 0
200ba98: 02 80 00 04 be 200baa8 <IMFS_fsunmount+0x7c> <== ALWAYS TAKEN
200ba9c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
200baa0: 7f ff f0 e6 call 2007e38 <rtems_fatal_error_occurred> <== NOT EXECUTED
200baa4: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
IMFS_node_destroy( jnode );
200baa8: 7f ff dc a4 call 2002d38 <IMFS_node_destroy>
200baac: 90 10 00 1d mov %i5, %o0
jnode = next;
}
if ( jnode != NULL ) {
200bab0: 80 a7 20 00 cmp %i4, 0
200bab4: 02 80 00 0e be 200baec <IMFS_fsunmount+0xc0>
200bab8: ba 10 00 1c mov %i4, %i5
return node->control->imfs_type;
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
200babc: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
if ( IMFS_is_directory( jnode ) ) {
200bac0: c2 00 40 00 ld [ %g1 ], %g1
200bac4: 80 a0 60 00 cmp %g1, 0
200bac8: 32 bf ff e4 bne,a 200ba58 <IMFS_fsunmount+0x2c> <== NEVER TAKEN
200bacc: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200bad0: 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 );
200bad4: 84 07 60 54 add %i5, 0x54, %g2
if ( jnode_has_children( jnode ) )
200bad8: 80 a0 40 02 cmp %g1, %g2
200badc: 02 bf ff de be 200ba54 <IMFS_fsunmount+0x28>
200bae0: 80 a0 60 00 cmp %g1, 0
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
200bae4: 12 bf ff dc bne 200ba54 <IMFS_fsunmount+0x28> <== ALWAYS TAKEN
200bae8: ba 10 00 01 mov %g1, %i5
200baec: 81 c7 e0 08 ret
200baf0: 81 e8 00 00 restore
02002c2c <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]
)
{
2002c2c: 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 ) );
2002c30: 90 10 20 01 mov 1, %o0
2002c34: 40 00 01 ac call 20032e4 <calloc>
2002c38: 92 10 20 24 mov 0x24, %o1
if ( fs_info != NULL ) {
2002c3c: ba 92 20 00 orcc %o0, 0, %i5
2002c40: 02 80 00 24 be 2002cd0 <IMFS_initialize_support+0xa4>
2002c44: 03 00 80 74 sethi %hi(0x201d000), %g1
IMFS_jnode_t *root_node;
fs_info->instance = imfs_instance++;
2002c48: c4 00 61 bc ld [ %g1 + 0x1bc ], %g2 ! 201d1bc <imfs_instance.6626>
memcpy(
2002c4c: 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++;
2002c50: c4 27 40 00 st %g2, [ %i5 ]
2002c54: 84 00 a0 01 inc %g2
memcpy(
2002c58: 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++;
2002c5c: c4 20 61 bc st %g2, [ %g1 + 0x1bc ]
memcpy(
2002c60: 40 00 34 d4 call 200ffb0 <memcpy>
2002c64: 90 07 60 08 add %i5, 8, %o0
fs_info->node_controls,
node_controls,
sizeof( fs_info->node_controls )
);
root_node = IMFS_allocate_node(
2002c68: d2 07 60 08 ld [ %i5 + 8 ], %o1
2002c6c: 90 10 00 1d mov %i5, %o0
2002c70: 15 00 80 6b sethi %hi(0x201ac00), %o2
2002c74: 96 10 20 00 clr %o3
2002c78: 94 12 a1 28 or %o2, 0x128, %o2
2002c7c: 19 00 00 10 sethi %hi(0x4000), %o4
2002c80: 9a 10 20 00 clr %o5
2002c84: 40 00 22 75 call 200b658 <IMFS_allocate_node>
2002c88: 98 13 21 ed or %o4, 0x1ed, %o4
"",
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
2002c8c: 80 a2 20 00 cmp %o0, 0
2002c90: 02 80 00 10 be 2002cd0 <IMFS_initialize_support+0xa4> <== NEVER TAKEN
2002c94: 03 00 80 6d sethi %hi(0x201b400), %g1
static inline void IMFS_Set_handlers( rtems_filesystem_location_info_t *loc )
{
IMFS_jnode_t *node = (IMFS_jnode_t *) loc->node_access;
loc->handlers = node->control->handlers;
2002c98: 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;
2002c9c: 82 10 62 14 or %g1, 0x214, %g1
2002ca0: c4 00 a0 04 ld [ %g2 + 4 ], %g2
2002ca4: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
mt_entry->mt_fs_root->location.node_access = root_node;
2002ca8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
mt_entry->fs_info = fs_info;
2002cac: fa 26 20 08 st %i5, [ %i0 + 8 ]
mt_entry->ops = op_table;
2002cb0: f2 26 20 0c st %i1, [ %i0 + 0xc ]
2002cb4: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
mt_entry->mt_fs_root->location.node_access = root_node;
2002cb8: d0 20 60 08 st %o0, [ %g1 + 8 ]
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
2002cbc: 86 10 20 06 mov 6, %g3
2002cc0: 03 00 80 72 sethi %hi(0x201c800), %g1
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
2002cc4: 84 10 20 10 mov 0x10, %g2
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
2002cc8: 10 80 00 08 b 2002ce8 <IMFS_initialize_support+0xbc>
2002ccc: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1
} else {
errno = ENOMEM;
rv = -1;
}
} else {
errno = ENOMEM;
2002cd0: 40 00 32 67 call 200f66c <__errno>
2002cd4: b0 10 3f ff mov -1, %i0
2002cd8: 82 10 20 0c mov 0xc, %g1
2002cdc: c2 22 00 00 st %g1, [ %o0 ]
2002ce0: 81 c7 e0 08 ret
2002ce4: 81 e8 00 00 restore
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
2002ce8: 80 a0 80 01 cmp %g2, %g1
2002cec: 22 80 00 09 be,a 2002d10 <IMFS_initialize_support+0xe4>
2002cf0: 05 00 80 74 sethi %hi(0x201d000), %g2
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
2002cf4: 34 80 00 06 bg,a 2002d0c <IMFS_initialize_support+0xe0>
2002cf8: 82 10 20 80 mov 0x80, %g1
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
2002cfc: 86 80 ff ff addcc %g3, -1, %g3
2002d00: 12 bf ff fa bne 2002ce8 <IMFS_initialize_support+0xbc> <== ALWAYS TAKEN
2002d04: 85 28 a0 01 sll %g2, 1, %g2
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
2002d08: 82 10 20 80 mov 0x80, %g1 <== NOT EXECUTED
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
2002d0c: 05 00 80 74 sethi %hi(0x201d000), %g2
2002d10: c2 20 a1 b8 st %g1, [ %g2 + 0x1b8 ] ! 201d1b8 <imfs_memfile_bytes_per_block>
2002d14: b0 10 20 00 clr %i0
IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK
);
}
return rv;
}
2002d18: 81 c7 e0 08 ret
2002d1c: 81 e8 00 00 restore
02004874 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
2004874: 9d e3 bf 48 save %sp, -184, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
2004878: 03 00 80 85 sethi %hi(0x2021400), %g1
200487c: c2 00 60 a4 ld [ %g1 + 0xa4 ], %g1 ! 20214a4 <rtems_current_user_env>
switch (mode & S_IFMT) {
2004880: 05 00 00 08 sethi %hi(0x2000), %g2
void *context
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
2004884: c2 00 60 08 ld [ %g1 + 8 ], %g1
2004888: b2 2e 40 01 andn %i1, %g1, %i1
switch (mode & S_IFMT) {
200488c: 03 00 00 3c sethi %hi(0xf000), %g1
2004890: 82 0e 40 01 and %i1, %g1, %g1
2004894: 80 a0 40 02 cmp %g1, %g2
2004898: 22 80 00 3a be,a 2004980 <IMFS_make_generic_node+0x10c>
200489c: c2 06 80 00 ld [ %i2 ], %g1
20048a0: 38 80 00 04 bgu,a 20048b0 <IMFS_make_generic_node+0x3c> <== ALWAYS TAKEN
20048a4: 05 00 00 18 sethi %hi(0x6000), %g2
20048a8: 10 80 00 05 b 20048bc <IMFS_make_generic_node+0x48> <== NOT EXECUTED
20048ac: 05 00 00 04 sethi %hi(0x1000), %g2 <== NOT EXECUTED
20048b0: 80 a0 40 02 cmp %g1, %g2
20048b4: 02 80 00 32 be 200497c <IMFS_make_generic_node+0x108>
20048b8: 05 00 00 20 sethi %hi(0x8000), %g2
20048bc: 80 a0 40 02 cmp %g1, %g2
20048c0: 22 80 00 30 be,a 2004980 <IMFS_make_generic_node+0x10c> <== NEVER TAKEN
20048c4: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
20048c8: 30 80 00 27 b,a 2004964 <IMFS_make_generic_node+0xf0>
if ( node_control->imfs_type == IMFS_GENERIC ) {
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK
| RTEMS_FS_MAKE
| RTEMS_FS_EXCLUSIVE;
const rtems_filesystem_location_info_t *currentloc =
20048cc: 94 10 20 78 mov 0x78, %o2
20048d0: 40 00 07 fa call 20068b8 <rtems_filesystem_eval_path_start>
20048d4: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
20048d8: 7f ff ff d5 call 200482c <IMFS_is_imfs_instance>
20048dc: ba 10 00 08 mov %o0, %i5
20048e0: 80 8a 20 ff btst 0xff, %o0
20048e4: 02 80 00 19 be 2004948 <IMFS_make_generic_node+0xd4>
20048e8: 90 07 bf c8 add %fp, -56, %o0
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
new_node = IMFS_create_node_with_control(
20048ec: d4 1f bf d0 ldd [ %fp + -48 ], %o2
if ( IMFS_is_imfs_instance( currentloc ) ) {
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
20048f0: f6 27 bf b0 st %i3, [ %fp + -80 ]
new_node = IMFS_create_node_with_control(
20048f4: 90 10 00 1d mov %i5, %o0
20048f8: 92 10 00 1a mov %i2, %o1
20048fc: 98 10 00 19 mov %i1, %o4
2004900: 9a 07 bf b0 add %fp, -80, %o5
2004904: 40 00 2d 7a call 200feec <IMFS_create_node_with_control>
2004908: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
&info
);
if ( new_node != NULL ) {
200490c: 80 a2 20 00 cmp %o0, 0
2004910: 02 80 00 11 be 2004954 <IMFS_make_generic_node+0xe0>
2004914: 92 10 20 00 clr %o1
IMFS_jnode_t *parent = currentloc->node_access;
2004918: fa 07 60 08 ld [ %i5 + 8 ], %i5
IMFS_update_ctime( parent );
200491c: 40 00 02 90 call 200535c <gettimeofday>
2004920: 90 07 bf a8 add %fp, -88, %o0
2004924: c2 07 bf a8 ld [ %fp + -88 ], %g1
IMFS_update_mtime( parent );
2004928: 90 07 bf a8 add %fp, -88, %o0
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
200492c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
2004930: 40 00 02 8b call 200535c <gettimeofday>
2004934: 92 10 20 00 clr %o1
2004938: c2 07 bf a8 ld [ %fp + -88 ], %g1
200493c: b0 10 20 00 clr %i0
2004940: 10 80 00 05 b 2004954 <IMFS_make_generic_node+0xe0>
2004944: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
2004948: 92 10 20 86 mov 0x86, %o1
200494c: 40 00 07 45 call 2006660 <rtems_filesystem_eval_path_error>
2004950: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2004954: 40 00 08 15 call 20069a8 <rtems_filesystem_eval_path_cleanup>
2004958: 90 07 bf c8 add %fp, -56, %o0
200495c: 81 c7 e0 08 ret
2004960: 81 e8 00 00 restore
} else {
errno = EINVAL;
2004964: 40 00 3d a3 call 2013ff0 <__errno>
2004968: b0 10 3f ff mov -1, %i0
200496c: 82 10 20 16 mov 0x16, %g1
2004970: c2 22 00 00 st %g1, [ %o0 ]
2004974: 81 c7 e0 08 ret
2004978: 81 e8 00 00 restore
rv = -1;
break;
}
if ( rv == 0 ) {
if ( node_control->imfs_type == IMFS_GENERIC ) {
200497c: c2 06 80 00 ld [ %i2 ], %g1
2004980: 80 a0 60 07 cmp %g1, 7
2004984: 02 bf ff d2 be 20048cc <IMFS_make_generic_node+0x58>
2004988: 92 10 00 18 mov %i0, %o1
200498c: 30 bf ff f6 b,a 2004964 <IMFS_make_generic_node+0xf0>
0200e194 <IMFS_memfile_addblock>:
*/
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
200e194: 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 );
200e198: 94 10 20 01 mov 1, %o2
200e19c: 90 10 00 18 mov %i0, %o0
200e1a0: 7f ff fe d7 call 200dcfc <IMFS_memfile_get_block_pointer>
200e1a4: 92 10 00 19 mov %i1, %o1
if ( *block_entry_ptr )
200e1a8: 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 );
200e1ac: ba 10 00 08 mov %o0, %i5
if ( *block_entry_ptr )
200e1b0: 80 a0 60 00 cmp %g1, 0
200e1b4: 12 80 00 08 bne 200e1d4 <IMFS_memfile_addblock+0x40>
200e1b8: b0 10 20 00 clr %i0
return 0;
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
200e1bc: 7f ff fe c3 call 200dcc8 <memfile_alloc_block>
200e1c0: 01 00 00 00 nop
if ( !memory )
200e1c4: 80 a2 20 00 cmp %o0, 0
200e1c8: 22 80 00 03 be,a 200e1d4 <IMFS_memfile_addblock+0x40> <== NEVER TAKEN
200e1cc: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
*block_entry_ptr = memory;
200e1d0: d0 27 40 00 st %o0, [ %i5 ]
return 0;
200e1d4: 81 c7 e0 08 ret
200e1d8: 81 e8 00 00 restore
0200e3a8 <IMFS_memfile_extend>:
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
bool zero_fill,
off_t new_length
)
{
200e3a8: 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 )
200e3ac: 03 00 80 74 sethi %hi(0x201d000), %g1
200e3b0: fa 00 61 b8 ld [ %g1 + 0x1b8 ], %i5 ! 201d1b8 <imfs_memfile_bytes_per_block>
200e3b4: b9 37 60 02 srl %i5, 2, %i4
200e3b8: 92 10 00 1c mov %i4, %o1
200e3bc: 40 00 28 11 call 2018400 <.umul>
200e3c0: 90 07 20 01 add %i4, 1, %o0
200e3c4: 92 10 00 1c mov %i4, %o1
200e3c8: 40 00 28 0e call 2018400 <.umul>
200e3cc: 90 02 20 01 inc %o0
200e3d0: 92 10 00 1d mov %i5, %o1
200e3d4: 40 00 28 0b call 2018400 <.umul>
200e3d8: 90 02 3f ff add %o0, -1, %o0
200e3dc: 82 10 20 00 clr %g1
200e3e0: 80 a0 40 1a cmp %g1, %i2
200e3e4: 34 80 00 0b bg,a 200e410 <IMFS_memfile_extend+0x68> <== NEVER TAKEN
200e3e8: f8 06 20 50 ld [ %i0 + 0x50 ], %i4 <== NOT EXECUTED
200e3ec: 80 a0 40 1a cmp %g1, %i2
200e3f0: 12 80 00 04 bne 200e400 <IMFS_memfile_extend+0x58> <== NEVER TAKEN
200e3f4: 80 a2 00 1b cmp %o0, %i3
200e3f8: 38 80 00 06 bgu,a 200e410 <IMFS_memfile_extend+0x68>
200e3fc: f8 06 20 50 ld [ %i0 + 0x50 ], %i4
rtems_set_errno_and_return_minus_one( EFBIG );
200e400: 40 00 04 9b call 200f66c <__errno>
200e404: 01 00 00 00 nop
200e408: 10 80 00 3c b 200e4f8 <IMFS_memfile_extend+0x150>
200e40c: 82 10 20 1b mov 0x1b, %g1 ! 1b <PROM_START+0x1b>
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
200e410: 80 a6 80 1c cmp %i2, %i4
200e414: 14 80 00 07 bg 200e430 <IMFS_memfile_extend+0x88> <== NEVER TAKEN
200e418: e0 06 20 54 ld [ %i0 + 0x54 ], %l0
200e41c: 80 a6 80 1c cmp %i2, %i4
200e420: 12 80 00 48 bne 200e540 <IMFS_memfile_extend+0x198> <== NEVER TAKEN
200e424: 80 a6 c0 10 cmp %i3, %l0
200e428: 08 80 00 46 bleu 200e540 <IMFS_memfile_extend+0x198> <== NEVER TAKEN
200e42c: 01 00 00 00 nop
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e430: a3 3f 60 1f sra %i5, 0x1f, %l1
200e434: 96 10 00 1d mov %i5, %o3
200e438: 94 10 00 11 mov %l1, %o2
200e43c: 90 10 00 1a mov %i2, %o0
200e440: 40 00 29 82 call 2018a48 <__divdi3>
200e444: 92 10 00 1b mov %i3, %o1
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e448: 94 10 00 11 mov %l1, %o2
200e44c: 90 10 00 1c mov %i4, %o0
200e450: 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;
200e454: a4 10 00 09 mov %o1, %l2
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e458: 40 00 29 7c call 2018a48 <__divdi3>
200e45c: 92 10 00 10 mov %l0, %o1
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
200e460: a2 10 20 00 clr %l1
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
200e464: 90 10 00 09 mov %o1, %o0
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e468: b8 10 00 09 mov %o1, %i4
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
if ( zero_fill ) {
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
200e46c: 27 00 80 74 sethi %hi(0x201d000), %l3
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
200e470: 40 00 27 e4 call 2018400 <.umul>
200e474: 92 10 00 1d mov %i5, %o1
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
200e478: 10 80 00 23 b 200e504 <IMFS_memfile_extend+0x15c>
200e47c: a0 24 00 08 sub %l0, %o0, %l0
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
200e480: 7f ff ff 45 call 200e194 <IMFS_memfile_addblock>
200e484: 92 10 00 1d mov %i5, %o1
200e488: 80 a2 20 00 cmp %o0, 0
200e48c: 12 80 00 15 bne 200e4e0 <IMFS_memfile_extend+0x138> <== NEVER TAKEN
200e490: 80 a6 60 00 cmp %i1, 0
if ( zero_fill ) {
200e494: 22 80 00 1c be,a 200e504 <IMFS_memfile_extend+0x15c>
200e498: a2 04 60 01 inc %l1
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
200e49c: e8 04 e1 b8 ld [ %l3 + 0x1b8 ], %l4
block_p *block_ptr =
200e4a0: 92 10 00 1d mov %i5, %o1
200e4a4: 94 10 20 00 clr %o2
200e4a8: 7f ff fe 15 call 200dcfc <IMFS_memfile_get_block_pointer>
200e4ac: 90 10 00 18 mov %i0, %o0
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
200e4b0: 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;
200e4b4: a8 25 00 10 sub %l4, %l0, %l4
block_p *block_ptr =
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
200e4b8: 90 02 00 10 add %o0, %l0, %o0
200e4bc: 92 10 20 00 clr %o1
200e4c0: 94 10 00 14 mov %l4, %o2
200e4c4: 40 00 06 f8 call 20100a4 <memset>
200e4c8: a0 10 20 00 clr %l0
200e4cc: 10 80 00 0e b 200e504 <IMFS_memfile_extend+0x15c>
200e4d0: a2 04 60 01 inc %l1
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
200e4d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e4d8: 7f ff ff a8 call 200e378 <IMFS_memfile_remove_block> <== NOT EXECUTED
200e4dc: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
memset( &(*block_ptr) [offset], 0, count);
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
200e4e0: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
200e4e4: 1a bf ff fc bcc 200e4d4 <IMFS_memfile_extend+0x12c> <== NOT EXECUTED
200e4e8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
200e4ec: 40 00 04 60 call 200f66c <__errno> <== NOT EXECUTED
200e4f0: 01 00 00 00 nop <== NOT EXECUTED
200e4f4: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c> <== NOT EXECUTED
200e4f8: c2 22 00 00 st %g1, [ %o0 ]
200e4fc: 81 c7 e0 08 ret
200e500: 91 e8 3f ff restore %g0, -1, %o0
*
* This routine insures that the in-memory file is of the length
* specified. If necessary, it will allocate memory blocks to
* extend the file.
*/
MEMFILE_STATIC int IMFS_memfile_extend(
200e504: ba 04 40 1c add %l1, %i4, %i5
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
200e508: 80 a7 40 12 cmp %i5, %l2
200e50c: 08 bf ff dd bleu 200e480 <IMFS_memfile_extend+0xd8>
200e510: 90 10 00 18 mov %i0, %o0
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
200e514: 92 10 20 00 clr %o1
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
200e518: f4 3e 20 50 std %i2, [ %i0 + 0x50 ]
IMFS_update_ctime(the_jnode);
200e51c: 7f ff d4 4f call 2003658 <gettimeofday>
200e520: 90 07 bf f8 add %fp, -8, %o0
200e524: c2 07 bf f8 ld [ %fp + -8 ], %g1
IMFS_update_mtime(the_jnode);
200e528: 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);
200e52c: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
IMFS_update_mtime(the_jnode);
200e530: 7f ff d4 4a call 2003658 <gettimeofday>
200e534: 92 10 20 00 clr %o1
200e538: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e53c: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
return 0;
}
200e540: 81 c7 e0 08 ret
200e544: 91 e8 20 00 restore %g0, 0, %o0
0200dcfc <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
200dcfc: 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 ) {
200dd00: 03 00 80 74 sethi %hi(0x201d000), %g1
200dd04: fa 00 61 b8 ld [ %g1 + 0x1b8 ], %i5 ! 201d1b8 <imfs_memfile_bytes_per_block>
200dd08: bb 37 60 02 srl %i5, 2, %i5
200dd0c: 82 07 7f ff add %i5, -1, %g1
200dd10: 80 a6 40 01 cmp %i1, %g1
200dd14: 18 80 00 18 bgu 200dd74 <IMFS_memfile_get_block_pointer+0x78>
200dd18: 90 07 60 01 add %i5, 1, %o0
p = info->indirect;
if ( malloc_it ) {
200dd1c: 80 a6 a0 00 cmp %i2, 0
200dd20: 02 80 00 10 be 200dd60 <IMFS_memfile_get_block_pointer+0x64>
200dd24: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
if ( !p ) {
200dd28: 80 a0 60 00 cmp %g1, 0
200dd2c: 32 80 00 0a bne,a 200dd54 <IMFS_memfile_get_block_pointer+0x58>
200dd30: f0 06 20 58 ld [ %i0 + 0x58 ], %i0
p = memfile_alloc_block();
200dd34: 7f ff ff e5 call 200dcc8 <memfile_alloc_block>
200dd38: 01 00 00 00 nop
if ( !p )
200dd3c: 80 a2 20 00 cmp %o0, 0
200dd40: 32 80 00 04 bne,a 200dd50 <IMFS_memfile_get_block_pointer+0x54><== ALWAYS TAKEN
200dd44: d0 26 20 58 st %o0, [ %i0 + 0x58 ]
return 0;
200dd48: 81 c7 e0 08 ret <== NOT EXECUTED
200dd4c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
info->indirect = p;
}
return &info->indirect[ my_block ];
200dd50: f0 06 20 58 ld [ %i0 + 0x58 ], %i0
200dd54: b3 2e 60 02 sll %i1, 2, %i1
200dd58: 81 c7 e0 08 ret
200dd5c: 91 ee 00 19 restore %i0, %i1, %o0
}
if ( !p )
200dd60: 80 a0 60 00 cmp %g1, 0
200dd64: 02 bf ff f9 be 200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200dd68: b3 2e 60 02 sll %i1, 2, %i1
return 0;
return &info->indirect[ my_block ];
200dd6c: 81 c7 e0 08 ret
200dd70: 91 e8 40 19 restore %g1, %i1, %o0
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
200dd74: 40 00 29 a3 call 2018400 <.umul>
200dd78: 92 10 00 1d mov %i5, %o1
200dd7c: 82 02 3f ff add %o0, -1, %g1
200dd80: 80 a6 40 01 cmp %i1, %g1
200dd84: 18 80 00 2c bgu 200de34 <IMFS_memfile_get_block_pointer+0x138>
200dd88: b8 10 00 08 mov %o0, %i4
my_block -= FIRST_DOUBLY_INDIRECT;
200dd8c: b2 26 40 1d sub %i1, %i5, %i1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200dd90: 92 10 00 1d mov %i5, %o1
200dd94: 40 00 2a 81 call 2018798 <.urem>
200dd98: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200dd9c: 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;
200dda0: b8 10 00 08 mov %o0, %i4
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200dda4: 40 00 29 d1 call 20184e8 <.udiv>
200dda8: 90 10 00 19 mov %i1, %o0
p = info->doubly_indirect;
if ( malloc_it ) {
200ddac: 80 a6 a0 00 cmp %i2, 0
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200ddb0: ba 10 00 08 mov %o0, %i5
p = info->doubly_indirect;
if ( malloc_it ) {
200ddb4: 02 80 00 17 be 200de10 <IMFS_memfile_get_block_pointer+0x114>
200ddb8: d0 06 20 5c ld [ %i0 + 0x5c ], %o0
if ( !p ) {
200ddbc: 80 a2 20 00 cmp %o0, 0
200ddc0: 12 80 00 08 bne 200dde0 <IMFS_memfile_get_block_pointer+0xe4>
200ddc4: bb 2f 60 02 sll %i5, 2, %i5
p = memfile_alloc_block();
200ddc8: 7f ff ff c0 call 200dcc8 <memfile_alloc_block>
200ddcc: 01 00 00 00 nop
if ( !p )
200ddd0: 80 a2 20 00 cmp %o0, 0
200ddd4: 02 bf ff dd be 200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200ddd8: 01 00 00 00 nop
return 0;
info->doubly_indirect = p;
200dddc: d0 26 20 5c st %o0, [ %i0 + 0x5c ]
}
p1 = (block_p *)p[ doubly ];
200dde0: b6 02 00 1d add %o0, %i5, %i3
200dde4: d0 02 00 1d ld [ %o0 + %i5 ], %o0
if ( !p1 ) {
200dde8: 80 a2 20 00 cmp %o0, 0
200ddec: 12 80 00 4a bne 200df14 <IMFS_memfile_get_block_pointer+0x218>
200ddf0: b1 2f 20 02 sll %i4, 2, %i0
p1 = memfile_alloc_block();
200ddf4: 7f ff ff b5 call 200dcc8 <memfile_alloc_block>
200ddf8: 01 00 00 00 nop
if ( !p1 )
200ddfc: 80 a2 20 00 cmp %o0, 0
200de00: 02 bf ff d2 be 200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200de04: 01 00 00 00 nop
return 0;
p[ doubly ] = (block_p) p1;
200de08: 10 80 00 43 b 200df14 <IMFS_memfile_get_block_pointer+0x218>
200de0c: d0 26 c0 00 st %o0, [ %i3 ]
}
return (block_p *)&p1[ singly ];
}
if ( !p )
200de10: 80 a2 20 00 cmp %o0, 0
200de14: 02 bf ff cd be 200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200de18: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p = (block_p *)p[ doubly ];
200de1c: c2 02 00 1d ld [ %o0 + %i5 ], %g1
if ( !p )
200de20: 80 a0 60 00 cmp %g1, 0
200de24: 02 bf ff c9 be 200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200de28: 01 00 00 00 nop
return 0;
return (block_p *)&p[ singly ];
200de2c: 10 80 00 48 b 200df4c <IMFS_memfile_get_block_pointer+0x250>
200de30: b1 2f 20 02 sll %i4, 2, %i0
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
200de34: 90 02 20 01 inc %o0
200de38: 40 00 29 72 call 2018400 <.umul>
200de3c: 92 10 00 1d mov %i5, %o1
200de40: 90 02 3f ff add %o0, -1, %o0
200de44: 80 a6 40 08 cmp %i1, %o0
200de48: 18 bf ff c0 bgu 200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200de4c: b2 26 40 1c sub %i1, %i4, %i1
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200de50: 92 10 00 1d mov %i5, %o1
200de54: 40 00 2a 51 call 2018798 <.urem>
200de58: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200de5c: 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;
200de60: b6 10 00 08 mov %o0, %i3
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200de64: 40 00 29 a1 call 20184e8 <.udiv>
200de68: 90 10 00 19 mov %i1, %o0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
200de6c: 92 10 00 1d mov %i5, %o1
200de70: 40 00 29 9e call 20184e8 <.udiv>
200de74: b2 10 00 08 mov %o0, %i1
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
200de78: 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;
200de7c: b8 10 00 08 mov %o0, %i4
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
200de80: 40 00 2a 46 call 2018798 <.urem>
200de84: 90 10 00 19 mov %i1, %o0
p = info->triply_indirect;
if ( malloc_it ) {
200de88: 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;
200de8c: ba 10 00 08 mov %o0, %i5
p = info->triply_indirect;
if ( malloc_it ) {
200de90: 02 80 00 23 be 200df1c <IMFS_memfile_get_block_pointer+0x220>
200de94: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
if ( !p ) {
200de98: 80 a2 20 00 cmp %o0, 0
200de9c: 12 80 00 08 bne 200debc <IMFS_memfile_get_block_pointer+0x1c0>
200dea0: b9 2f 20 02 sll %i4, 2, %i4
p = memfile_alloc_block();
200dea4: 7f ff ff 89 call 200dcc8 <memfile_alloc_block>
200dea8: 01 00 00 00 nop
if ( !p )
200deac: 80 a2 20 00 cmp %o0, 0
200deb0: 02 bf ff a6 be 200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200deb4: 01 00 00 00 nop
return 0;
info->triply_indirect = p;
200deb8: d0 26 20 60 st %o0, [ %i0 + 0x60 ]
}
p1 = (block_p *) p[ triply ];
200debc: b4 02 00 1c add %o0, %i4, %i2
200dec0: d0 02 00 1c ld [ %o0 + %i4 ], %o0
if ( !p1 ) {
200dec4: 80 a2 20 00 cmp %o0, 0
200dec8: 12 80 00 08 bne 200dee8 <IMFS_memfile_get_block_pointer+0x1ec>
200decc: bb 2f 60 02 sll %i5, 2, %i5
p1 = memfile_alloc_block();
200ded0: 7f ff ff 7e call 200dcc8 <memfile_alloc_block>
200ded4: 01 00 00 00 nop
if ( !p1 )
200ded8: 80 a2 20 00 cmp %o0, 0
200dedc: 02 bf ff 9b be 200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200dee0: 01 00 00 00 nop
return 0;
p[ triply ] = (block_p) p1;
200dee4: d0 26 80 00 st %o0, [ %i2 ]
}
p2 = (block_p *)p1[ doubly ];
200dee8: b8 02 00 1d add %o0, %i5, %i4
200deec: d0 02 00 1d ld [ %o0 + %i5 ], %o0
if ( !p2 ) {
200def0: 80 a2 20 00 cmp %o0, 0
200def4: 12 80 00 08 bne 200df14 <IMFS_memfile_get_block_pointer+0x218>
200def8: b1 2e e0 02 sll %i3, 2, %i0
p2 = memfile_alloc_block();
200defc: 7f ff ff 73 call 200dcc8 <memfile_alloc_block>
200df00: 01 00 00 00 nop
if ( !p2 )
200df04: 80 a2 20 00 cmp %o0, 0
200df08: 02 bf ff 90 be 200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200df0c: 01 00 00 00 nop
return 0;
p1[ doubly ] = (block_p) p2;
200df10: d0 27 00 00 st %o0, [ %i4 ]
}
return (block_p *)&p2[ singly ];
200df14: 81 c7 e0 08 ret
200df18: 91 ea 00 18 restore %o0, %i0, %o0
}
if ( !p )
200df1c: 80 a2 20 00 cmp %o0, 0
200df20: 02 bf ff 8a be 200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200df24: b9 2f 20 02 sll %i4, 2, %i4
return 0;
p1 = (block_p *) p[ triply ];
200df28: c2 02 00 1c ld [ %o0 + %i4 ], %g1
if ( !p1 )
200df2c: 80 a0 60 00 cmp %g1, 0
200df30: 02 bf ff 86 be 200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200df34: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p2 = (block_p *)p1[ doubly ];
200df38: c2 00 40 1d ld [ %g1 + %i5 ], %g1
if ( !p2 )
200df3c: 80 a0 60 00 cmp %g1, 0
200df40: 02 bf ff 82 be 200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200df44: 01 00 00 00 nop
return 0;
return (block_p *)&p2[ singly ];
200df48: b1 2e e0 02 sll %i3, 2, %i0
/*
* This means the requested block number is out of range.
*/
return 0;
}
200df4c: 81 c7 e0 08 ret
200df50: 91 e8 40 18 restore %g1, %i0, %o0
0200df54 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
200df54: 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;
200df58: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
200df5c: ba 10 00 18 mov %i0, %i5
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
200df60: c2 00 40 00 ld [ %g1 ], %g1
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
200df64: a0 10 00 19 mov %i1, %l0
200df68: 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 ) {
200df6c: 80 a0 60 05 cmp %g1, 5
200df70: 12 80 00 17 bne 200dfcc <IMFS_memfile_read+0x78>
200df74: a4 10 00 1b mov %i3, %l2
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
200df78: f4 1e 20 50 ldd [ %i0 + 0x50 ], %i2
200df7c: 82 10 20 00 clr %g1
200df80: 86 a6 c0 11 subcc %i3, %l1, %g3
200df84: 84 66 80 19 subx %i2, %i1, %g2
200df88: 80 a0 40 02 cmp %g1, %g2
200df8c: 14 80 00 07 bg 200dfa8 <IMFS_memfile_read+0x54> <== NEVER TAKEN
200df90: d2 06 20 58 ld [ %i0 + 0x58 ], %o1
200df94: 80 a0 40 02 cmp %g1, %g2
200df98: 12 80 00 06 bne 200dfb0 <IMFS_memfile_read+0x5c> <== NEVER TAKEN
200df9c: 80 a7 00 03 cmp %i4, %g3
200dfa0: 28 80 00 05 bleu,a 200dfb4 <IMFS_memfile_read+0x60> <== NEVER TAKEN
200dfa4: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
my_length = the_jnode->info.linearfile.size - start;
200dfa8: 10 80 00 03 b 200dfb4 <IMFS_memfile_read+0x60>
200dfac: 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;
200dfb0: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
200dfb4: 90 10 00 12 mov %l2, %o0
200dfb8: 92 02 40 11 add %o1, %l1, %o1
200dfbc: 40 00 07 fd call 200ffb0 <memcpy>
200dfc0: 94 10 00 18 mov %i0, %o2
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
200dfc4: 10 80 00 5d b 200e138 <IMFS_memfile_read+0x1e4>
200dfc8: 90 07 bf f8 add %fp, -8, %o0
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
200dfcc: c6 06 20 50 ld [ %i0 + 0x50 ], %g3
200dfd0: 88 10 20 00 clr %g4
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
200dfd4: 82 10 00 1a mov %i2, %g1
if ( last_byte > the_jnode->info.file.size )
200dfd8: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
200dfdc: 80 a1 00 03 cmp %g4, %g3
200dfe0: 14 80 00 08 bg 200e000 <IMFS_memfile_read+0xac> <== NEVER TAKEN
200dfe4: b6 07 00 1a add %i4, %i2, %i3
200dfe8: 80 a1 00 03 cmp %g4, %g3
200dfec: 32 80 00 07 bne,a 200e008 <IMFS_memfile_read+0xb4> <== NEVER TAKEN
200dff0: 03 00 80 74 sethi %hi(0x201d000), %g1 <== NOT EXECUTED
200dff4: 80 a6 c0 02 cmp %i3, %g2
200dff8: 28 80 00 04 bleu,a 200e008 <IMFS_memfile_read+0xb4>
200dffc: 03 00 80 74 sethi %hi(0x201d000), %g1
my_length = the_jnode->info.file.size - start;
200e000: b8 20 80 01 sub %g2, %g1, %i4
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e004: 03 00 80 74 sethi %hi(0x201d000), %g1
200e008: f6 00 61 b8 ld [ %g1 + 0x1b8 ], %i3 ! 201d1b8 <imfs_memfile_bytes_per_block>
200e00c: 90 10 00 10 mov %l0, %o0
200e010: b5 3e e0 1f sra %i3, 0x1f, %i2
200e014: 96 10 00 1b mov %i3, %o3
200e018: 94 10 00 1a mov %i2, %o2
200e01c: 40 00 2b 76 call 2018df4 <__moddi3>
200e020: 92 10 00 11 mov %l1, %o1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e024: 94 10 00 1a mov %i2, %o2
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e028: a6 10 00 09 mov %o1, %l3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e02c: 90 10 00 10 mov %l0, %o0
200e030: 92 10 00 11 mov %l1, %o1
200e034: 40 00 2a 85 call 2018a48 <__divdi3>
200e038: 96 10 00 1b mov %i3, %o3
if ( start_offset ) {
200e03c: 80 a4 e0 00 cmp %l3, 0
200e040: 02 80 00 18 be 200e0a0 <IMFS_memfile_read+0x14c>
200e044: b4 10 00 09 mov %o1, %i2
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
200e048: b6 26 c0 13 sub %i3, %l3, %i3
200e04c: 80 a7 00 1b cmp %i4, %i3
200e050: 08 80 00 03 bleu 200e05c <IMFS_memfile_read+0x108>
200e054: b2 10 00 1c mov %i4, %i1
200e058: b2 10 00 1b mov %i3, %i1
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e05c: 90 10 00 1d mov %i5, %o0
200e060: 92 10 00 1a mov %i2, %o1
200e064: 94 10 20 00 clr %o2
200e068: 7f ff ff 25 call 200dcfc <IMFS_memfile_get_block_pointer>
200e06c: b0 10 20 00 clr %i0
if ( !block_ptr )
200e070: 80 a2 20 00 cmp %o0, 0
200e074: 02 80 00 35 be 200e148 <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
200e078: 94 10 00 19 mov %i1, %o2
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
200e07c: d2 02 00 00 ld [ %o0 ], %o1
200e080: 90 10 00 12 mov %l2, %o0
200e084: 92 02 40 13 add %o1, %l3, %o1
200e088: 40 00 07 ca call 200ffb0 <memcpy>
200e08c: a4 04 80 19 add %l2, %i1, %l2
dest += to_copy;
block++;
200e090: b4 06 a0 01 inc %i2
my_length -= to_copy;
200e094: b8 27 00 19 sub %i4, %i1, %i4
copied += to_copy;
200e098: 10 80 00 03 b 200e0a4 <IMFS_memfile_read+0x150>
200e09c: b0 10 00 19 mov %i1, %i0
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
200e0a0: b0 10 20 00 clr %i0
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e0a4: 03 00 80 74 sethi %hi(0x201d000), %g1
* is considered an error. Read from an offset for more bytes than
* are between the offset and the end of the file will result in
* reading the data between offset and the end of the file (truncated
* read).
*/
MEMFILE_STATIC ssize_t IMFS_memfile_read(
200e0a8: a4 24 80 18 sub %l2, %i0, %l2
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e0ac: f6 00 61 b8 ld [ %g1 + 0x1b8 ], %i3
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e0b0: 10 80 00 0f b 200e0ec <IMFS_memfile_read+0x198>
200e0b4: a0 10 00 01 mov %g1, %l0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e0b8: 90 10 00 1d mov %i5, %o0
200e0bc: 92 10 00 1a mov %i2, %o1
200e0c0: 7f ff ff 0f call 200dcfc <IMFS_memfile_get_block_pointer>
200e0c4: 94 10 20 00 clr %o2
if ( !block_ptr )
200e0c8: 82 92 20 00 orcc %o0, 0, %g1
200e0cc: 02 80 00 1f be 200e148 <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
200e0d0: 90 10 00 19 mov %i1, %o0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
200e0d4: d2 00 40 00 ld [ %g1 ], %o1
200e0d8: 94 10 00 1b mov %i3, %o2
200e0dc: 40 00 07 b5 call 200ffb0 <memcpy>
200e0e0: b4 06 a0 01 inc %i2
dest += to_copy;
block++;
my_length -= to_copy;
200e0e4: b8 27 00 1b sub %i4, %i3, %i4
copied += to_copy;
200e0e8: b0 06 00 1b add %i0, %i3, %i0
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e0ec: c2 04 21 b8 ld [ %l0 + 0x1b8 ], %g1
200e0f0: 80 a7 00 01 cmp %i4, %g1
200e0f4: 1a bf ff f1 bcc 200e0b8 <IMFS_memfile_read+0x164>
200e0f8: b2 04 80 18 add %l2, %i0, %i1
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
200e0fc: 80 a7 20 00 cmp %i4, 0
200e100: 02 80 00 0e be 200e138 <IMFS_memfile_read+0x1e4>
200e104: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e108: 90 10 00 1d mov %i5, %o0
200e10c: 92 10 00 1a mov %i2, %o1
200e110: 7f ff fe fb call 200dcfc <IMFS_memfile_get_block_pointer>
200e114: 94 10 20 00 clr %o2
if ( !block_ptr )
200e118: 82 92 20 00 orcc %o0, 0, %g1
200e11c: 02 80 00 0b be 200e148 <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
200e120: 90 10 00 19 mov %i1, %o0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
200e124: d2 00 40 00 ld [ %g1 ], %o1
200e128: 94 10 00 1c mov %i4, %o2
200e12c: 40 00 07 a1 call 200ffb0 <memcpy>
200e130: b0 07 00 18 add %i4, %i0, %i0
copied += my_length;
}
IMFS_update_atime( the_jnode );
200e134: 90 07 bf f8 add %fp, -8, %o0
200e138: 7f ff d5 48 call 2003658 <gettimeofday>
200e13c: 92 10 20 00 clr %o1
200e140: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e144: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
return copied;
}
200e148: 81 c7 e0 08 ret
200e14c: 81 e8 00 00 restore
0200e24c <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
200e24c: 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;
200e250: 03 00 80 74 sethi %hi(0x201d000), %g1
200e254: fa 00 61 b8 ld [ %g1 + 0x1b8 ], %i5 ! 201d1b8 <imfs_memfile_bytes_per_block>
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
200e258: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
200e25c: 80 a0 60 00 cmp %g1, 0
200e260: 02 80 00 05 be 200e274 <IMFS_memfile_remove+0x28>
200e264: bb 37 60 02 srl %i5, 2, %i5
memfile_free_blocks_in_table( &info->indirect, to_free );
200e268: 90 06 20 58 add %i0, 0x58, %o0
200e26c: 7f ff ff e5 call 200e200 <memfile_free_blocks_in_table>
200e270: 92 10 00 1d mov %i5, %o1
}
if ( info->doubly_indirect ) {
200e274: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
200e278: b8 10 20 00 clr %i4
200e27c: 80 a0 60 00 cmp %g1, 0
200e280: 12 80 00 0d bne 200e2b4 <IMFS_memfile_remove+0x68>
200e284: 37 00 80 74 sethi %hi(0x201d000), %i3
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
200e288: 10 80 00 15 b 200e2dc <IMFS_memfile_remove+0x90>
200e28c: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
* a significant difference in the performance of this routine.
*
* Regardless until the IMFS implementation is proven, it
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
200e290: 83 2f 20 02 sll %i4, 2, %g1
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
200e294: 90 00 80 01 add %g2, %g1, %o0
200e298: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200e29c: 80 a0 60 00 cmp %g1, 0
200e2a0: 22 80 00 05 be,a 200e2b4 <IMFS_memfile_remove+0x68> <== NEVER TAKEN
200e2a4: b8 07 20 01 inc %i4 <== NOT EXECUTED
memfile_free_blocks_in_table(
200e2a8: 7f ff ff d6 call 200e200 <memfile_free_blocks_in_table>
200e2ac: 92 10 00 1d mov %i5, %o1
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
200e2b0: b8 07 20 01 inc %i4
200e2b4: c2 06 e1 b8 ld [ %i3 + 0x1b8 ], %g1
200e2b8: 83 30 60 02 srl %g1, 2, %g1
200e2bc: 80 a7 00 01 cmp %i4, %g1
200e2c0: 2a bf ff f4 bcs,a 200e290 <IMFS_memfile_remove+0x44>
200e2c4: c4 06 20 5c ld [ %i0 + 0x5c ], %g2
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
(block_p **)&info->doubly_indirect[i], to_free );
}
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
200e2c8: 90 06 20 5c add %i0, 0x5c, %o0
200e2cc: 7f ff ff cd call 200e200 <memfile_free_blocks_in_table>
200e2d0: 92 10 00 1d mov %i5, %o1
}
if ( info->triply_indirect ) {
200e2d4: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
200e2d8: b8 10 20 00 clr %i4
200e2dc: 80 a0 60 00 cmp %g1, 0
200e2e0: 12 80 00 1c bne 200e350 <IMFS_memfile_remove+0x104>
200e2e4: 33 00 80 74 sethi %hi(0x201d000), %i1
200e2e8: 81 c7 e0 08 ret
200e2ec: 81 e8 00 00 restore
* a significant difference in the performance of this routine.
*
* Regardless until the IMFS implementation is proven, it
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
200e2f0: a1 2f 20 02 sll %i4, 2, %l0
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
200e2f4: f6 00 40 10 ld [ %g1 + %l0 ], %i3
if ( !p ) /* ensure we have a valid pointer */
200e2f8: 80 a6 e0 00 cmp %i3, 0
200e2fc: 02 80 00 1b be 200e368 <IMFS_memfile_remove+0x11c> <== NEVER TAKEN
200e300: 90 06 20 60 add %i0, 0x60, %o0
200e304: 10 80 00 09 b 200e328 <IMFS_memfile_remove+0xdc>
200e308: b4 10 20 00 clr %i2
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
200e30c: 80 a0 60 00 cmp %g1, 0
200e310: 02 80 00 04 be 200e320 <IMFS_memfile_remove+0xd4> <== NEVER TAKEN
200e314: 90 10 00 1b mov %i3, %o0
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
200e318: 7f ff ff ba call 200e200 <memfile_free_blocks_in_table>
200e31c: 92 10 00 1d mov %i5, %o1
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
200e320: b4 06 a0 01 inc %i2
200e324: b6 06 e0 04 add %i3, 4, %i3
200e328: c2 06 61 b8 ld [ %i1 + 0x1b8 ], %g1
200e32c: 83 30 60 02 srl %g1, 2, %g1
200e330: 80 a6 80 01 cmp %i2, %g1
200e334: 2a bf ff f6 bcs,a 200e30c <IMFS_memfile_remove+0xc0>
200e338: c2 06 c0 00 ld [ %i3 ], %g1
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
200e33c: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
200e340: 92 10 00 1d mov %i5, %o1
200e344: 90 02 00 10 add %o0, %l0, %o0
200e348: 7f ff ff ae call 200e200 <memfile_free_blocks_in_table>
200e34c: b8 07 20 01 inc %i4
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
200e350: c2 06 61 b8 ld [ %i1 + 0x1b8 ], %g1
200e354: 83 30 60 02 srl %g1, 2, %g1
200e358: 80 a7 00 01 cmp %i4, %g1
200e35c: 2a bf ff e5 bcs,a 200e2f0 <IMFS_memfile_remove+0xa4>
200e360: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
200e364: 90 06 20 60 add %i0, 0x60, %o0
200e368: 7f ff ff a6 call 200e200 <memfile_free_blocks_in_table>
200e36c: 92 10 00 1d mov %i5, %o1
(block_p **)&info->triply_indirect, to_free );
}
return the_jnode;
}
200e370: 81 c7 e0 08 ret
200e374: 81 e8 00 00 restore
0200e378 <IMFS_memfile_remove_block>:
*/
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
200e378: 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 );
200e37c: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e380: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e384: 7f ff fe 5e call 200dcfc <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
200e388: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e38c: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
200e390: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
*block_ptr = 0;
memfile_free_block( ptr );
return 1;
}
200e394: 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 );
200e398: 7f ff ff 91 call 200e1dc <memfile_free_block> <== NOT EXECUTED
200e39c: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
return 1;
}
200e3a0: 81 c7 e0 08 ret <== NOT EXECUTED
200e3a4: 81 e8 00 00 restore <== NOT EXECUTED
0200e548 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
200e548: 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 ) {
200e54c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
200e550: 86 10 20 00 clr %g3
/*
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
200e554: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > the_jnode->info.file.size ) {
200e558: 80 a0 c0 01 cmp %g3, %g1
200e55c: 14 80 00 1b bg 200e5c8 <IMFS_memfile_write+0x80> <== NEVER TAKEN
200e560: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
200e564: 80 a0 c0 01 cmp %g3, %g1
200e568: 32 80 00 06 bne,a 200e580 <IMFS_memfile_write+0x38> <== NEVER TAKEN
200e56c: 03 00 80 74 sethi %hi(0x201d000), %g1 <== NOT EXECUTED
200e570: 80 a2 c0 02 cmp %o3, %g2
200e574: 18 80 00 16 bgu 200e5cc <IMFS_memfile_write+0x84>
200e578: 80 a6 40 01 cmp %i1, %g1
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e57c: 03 00 80 74 sethi %hi(0x201d000), %g1
200e580: fa 00 61 b8 ld [ %g1 + 0x1b8 ], %i5 ! 201d1b8 <imfs_memfile_bytes_per_block>
200e584: 92 10 00 1a mov %i2, %o1
200e588: a3 3f 60 1f sra %i5, 0x1f, %l1
200e58c: 96 10 00 1d mov %i5, %o3
200e590: 94 10 00 11 mov %l1, %o2
200e594: 40 00 2a 18 call 2018df4 <__moddi3>
200e598: 90 10 00 19 mov %i1, %o0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e59c: 90 10 00 19 mov %i1, %o0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e5a0: a0 10 00 09 mov %o1, %l0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e5a4: 94 10 00 11 mov %l1, %o2
200e5a8: 92 10 00 1a mov %i2, %o1
200e5ac: 40 00 29 27 call 2018a48 <__divdi3>
200e5b0: 96 10 00 1d mov %i5, %o3
if ( start_offset ) {
200e5b4: 80 a4 20 00 cmp %l0, 0
200e5b8: 12 80 00 17 bne 200e614 <IMFS_memfile_write+0xcc>
200e5bc: b4 10 00 09 mov %o1, %i2
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
if ( status )
return status;
}
copied = 0;
200e5c0: 10 80 00 28 b 200e660 <IMFS_memfile_write+0x118>
200e5c4: ba 10 20 00 clr %i5
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
bool zero_fill = start > the_jnode->info.file.size;
200e5c8: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
200e5cc: 14 80 00 09 bg 200e5f0 <IMFS_memfile_write+0xa8> <== NEVER TAKEN
200e5d0: 92 10 20 01 mov 1, %o1
200e5d4: 80 a6 40 01 cmp %i1, %g1
200e5d8: 32 80 00 06 bne,a 200e5f0 <IMFS_memfile_write+0xa8> <== NEVER TAKEN
200e5dc: 92 10 20 00 clr %o1 <== NOT EXECUTED
200e5e0: 80 a6 80 02 cmp %i2, %g2
200e5e4: 18 80 00 04 bgu 200e5f4 <IMFS_memfile_write+0xac>
200e5e8: 90 10 00 18 mov %i0, %o0
200e5ec: 92 10 20 00 clr %o1
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
200e5f0: 90 10 00 18 mov %i0, %o0
200e5f4: 92 0a 60 01 and %o1, 1, %o1
200e5f8: 7f ff ff 6c call 200e3a8 <IMFS_memfile_extend>
200e5fc: 94 10 20 00 clr %o2
if ( status )
200e600: 82 92 20 00 orcc %o0, 0, %g1
200e604: 22 bf ff df be,a 200e580 <IMFS_memfile_write+0x38>
200e608: 03 00 80 74 sethi %hi(0x201d000), %g1
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
200e60c: 81 c7 e0 08 ret
200e610: 91 e8 00 01 restore %g0, %g1, %o0
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
200e614: ba 27 40 10 sub %i5, %l0, %i5
200e618: 80 a7 40 1c cmp %i5, %i4
200e61c: 38 80 00 02 bgu,a 200e624 <IMFS_memfile_write+0xdc>
200e620: ba 10 00 1c mov %i4, %i5
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e624: 90 10 00 18 mov %i0, %o0
200e628: 92 10 00 1a mov %i2, %o1
200e62c: 7f ff fd b4 call 200dcfc <IMFS_memfile_get_block_pointer>
200e630: 94 10 20 00 clr %o2
if ( !block_ptr )
200e634: 80 a2 20 00 cmp %o0, 0
200e638: 02 80 00 36 be 200e710 <IMFS_memfile_write+0x1c8> <== NEVER TAKEN
200e63c: 82 10 20 00 clr %g1
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
200e640: d0 02 00 00 ld [ %o0 ], %o0
200e644: 92 10 00 1b mov %i3, %o1
200e648: 90 02 00 10 add %o0, %l0, %o0
200e64c: 94 10 00 1d mov %i5, %o2
200e650: 40 00 06 58 call 200ffb0 <memcpy>
200e654: b6 06 c0 1d add %i3, %i5, %i3
src += to_copy;
block++;
200e658: b4 06 a0 01 inc %i2
my_length -= to_copy;
200e65c: b8 27 00 1d sub %i4, %i5, %i4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e660: 03 00 80 74 sethi %hi(0x201d000), %g1
* IMFS_memfile_write
*
* This routine writes the specified data buffer into the in memory
* file pointed to by the_jnode. The file is extended as needed.
*/
MEMFILE_STATIC ssize_t IMFS_memfile_write(
200e664: b6 26 c0 1d sub %i3, %i5, %i3
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e668: f2 00 61 b8 ld [ %g1 + 0x1b8 ], %i1
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e66c: 10 80 00 0f b 200e6a8 <IMFS_memfile_write+0x160>
200e670: a2 10 00 01 mov %g1, %l1
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e674: 90 10 00 18 mov %i0, %o0
200e678: 92 10 00 1a mov %i2, %o1
200e67c: 7f ff fd a0 call 200dcfc <IMFS_memfile_get_block_pointer>
200e680: 94 10 20 00 clr %o2
if ( !block_ptr )
200e684: 80 a2 20 00 cmp %o0, 0
200e688: 02 80 00 21 be 200e70c <IMFS_memfile_write+0x1c4> <== NEVER TAKEN
200e68c: 94 10 00 19 mov %i1, %o2
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
200e690: d0 02 00 00 ld [ %o0 ], %o0
200e694: 92 10 00 10 mov %l0, %o1
200e698: 40 00 06 46 call 200ffb0 <memcpy>
200e69c: b4 06 a0 01 inc %i2
src += to_copy;
block++;
my_length -= to_copy;
200e6a0: b8 27 00 19 sub %i4, %i1, %i4
* IMFS_memfile_write
*
* This routine writes the specified data buffer into the in memory
* file pointed to by the_jnode. The file is extended as needed.
*/
MEMFILE_STATIC ssize_t IMFS_memfile_write(
200e6a4: ba 07 40 19 add %i5, %i1, %i5
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e6a8: c2 04 61 b8 ld [ %l1 + 0x1b8 ], %g1
200e6ac: 80 a7 00 01 cmp %i4, %g1
200e6b0: 1a bf ff f1 bcc 200e674 <IMFS_memfile_write+0x12c>
200e6b4: a0 06 c0 1d add %i3, %i5, %l0
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
200e6b8: 80 a7 20 00 cmp %i4, 0
200e6bc: 02 80 00 0f be 200e6f8 <IMFS_memfile_write+0x1b0>
200e6c0: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e6c4: 90 10 00 18 mov %i0, %o0
200e6c8: 92 10 00 1a mov %i2, %o1
200e6cc: 7f ff fd 8c call 200dcfc <IMFS_memfile_get_block_pointer>
200e6d0: 94 10 20 00 clr %o2
if ( !block_ptr )
200e6d4: 80 a2 20 00 cmp %o0, 0
200e6d8: 02 80 00 0e be 200e710 <IMFS_memfile_write+0x1c8> <== NEVER TAKEN
200e6dc: 82 10 00 1d mov %i5, %g1
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
200e6e0: d0 02 00 00 ld [ %o0 ], %o0
200e6e4: 92 10 00 10 mov %l0, %o1
200e6e8: 94 10 00 1c mov %i4, %o2
200e6ec: 40 00 06 31 call 200ffb0 <memcpy>
200e6f0: ba 07 40 1c add %i5, %i4, %i5
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
200e6f4: 90 07 bf f8 add %fp, -8, %o0
200e6f8: 7f ff d3 d8 call 2003658 <gettimeofday>
200e6fc: 92 10 20 00 clr %o1
200e700: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e704: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
200e708: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
200e70c: 82 10 00 1d mov %i5, %g1
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
200e710: b0 10 00 01 mov %g1, %i0
200e714: 81 c7 e0 08 ret
200e718: 81 e8 00 00 restore
02002e20 <IMFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
2002e20: 9d e3 bf 80 save %sp, -128, %sp
dev_t dev,
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
2002e24: 05 00 00 3c sethi %hi(0xf000), %g2
2002e28: 07 00 00 10 sethi %hi(0x4000), %g3
2002e2c: 84 0e c0 02 and %i3, %g2, %g2
2002e30: 80 a0 80 03 cmp %g2, %g3
2002e34: 02 80 00 12 be 2002e7c <IMFS_mknod+0x5c>
2002e38: 07 00 00 20 sethi %hi(0x8000), %g3
*type = IMFS_DIRECTORY;
} else if ( S_ISREG( mode ) ) {
2002e3c: 80 a0 80 03 cmp %g2, %g3
2002e40: 02 80 00 11 be 2002e84 <IMFS_mknod+0x64>
2002e44: 09 00 00 2c sethi %hi(0xb000), %g4
*type = IMFS_MEMORY_FILE;
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
2002e48: 07 00 00 08 sethi %hi(0x2000), %g3
2002e4c: 88 0e c0 04 and %i3, %g4, %g4
2002e50: 80 a1 00 03 cmp %g4, %g3
2002e54: 12 80 00 05 bne 2002e68 <IMFS_mknod+0x48>
2002e58: 07 00 00 04 sethi %hi(0x1000), %g3
*type = IMFS_DEVICE;
rtems_filesystem_split_dev_t(
2002e5c: 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;
2002e60: 10 80 00 0a b 2002e88 <IMFS_mknod+0x68>
2002e64: 82 10 20 01 mov 1, %g1
rtems_filesystem_split_dev_t(
dev,
info->device.major,
info->device.minor
);
} else if (S_ISFIFO( mode )) {
2002e68: 80 a0 80 03 cmp %g2, %g3
2002e6c: 32 80 00 08 bne,a 2002e8c <IMFS_mknod+0x6c> <== NEVER TAKEN
2002e70: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
*type = IMFS_FIFO;
2002e74: 10 80 00 05 b 2002e88 <IMFS_mknod+0x68>
2002e78: 82 10 20 06 mov 6, %g1
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
*type = IMFS_DIRECTORY;
2002e7c: 10 80 00 03 b 2002e88 <IMFS_mknod+0x68>
2002e80: 82 10 20 00 clr %g1
2002e84: 82 10 20 04 mov 4, %g1
size_t namelen,
mode_t mode,
const IMFS_types_union *info
)
{
const IMFS_fs_info_t *fs_info =
2002e88: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
2002e8c: 82 00 60 02 add %g1, 2, %g1
2002e90: c4 00 a0 08 ld [ %g2 + 8 ], %g2
2002e94: 83 28 60 02 sll %g1, 2, %g1
2002e98: d2 00 80 01 ld [ %g2 + %g1 ], %o1
2002e9c: 90 10 00 18 mov %i0, %o0
2002ea0: 94 10 00 19 mov %i1, %o2
2002ea4: 96 10 00 1a mov %i2, %o3
2002ea8: 98 10 00 1b mov %i3, %o4
2002eac: 40 00 22 1e call 200b724 <IMFS_create_node_with_control>
2002eb0: 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 ) {
2002eb4: 80 a2 20 00 cmp %o0, 0
2002eb8: 02 80 00 0e be 2002ef0 <IMFS_mknod+0xd0>
2002ebc: 90 07 bf e0 add %fp, -32, %o0
IMFS_jnode_t *parent = parentloc->node_access;
2002ec0: fa 06 20 08 ld [ %i0 + 8 ], %i5
IMFS_update_ctime( parent );
2002ec4: 40 00 01 e5 call 2003658 <gettimeofday>
2002ec8: 92 10 20 00 clr %o1
2002ecc: c2 07 bf e0 ld [ %fp + -32 ], %g1
IMFS_update_mtime( parent );
2002ed0: 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 );
2002ed4: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
2002ed8: 40 00 01 e0 call 2003658 <gettimeofday>
2002edc: 92 10 20 00 clr %o1
2002ee0: c2 07 bf e0 ld [ %fp + -32 ], %g1
2002ee4: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
size_t namelen,
mode_t mode,
dev_t dev
)
{
int rv = 0;
2002ee8: 81 c7 e0 08 ret
2002eec: 91 e8 20 00 restore %g0, 0, %o0
} else {
rv = -1;
}
return rv;
}
2002ef0: 81 c7 e0 08 ret
2002ef4: 91 e8 3f ff restore %g0, -1, %o0
02002ef8 <IMFS_mount>:
#endif
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
2002ef8: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
2002efc: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
2002f00: 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;
2002f04: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
2002f08: c4 00 80 00 ld [ %g2 ], %g2
2002f0c: 80 a0 a0 00 cmp %g2, 0
2002f10: 12 80 00 0d bne 2002f44 <IMFS_mount+0x4c>
2002f14: 01 00 00 00 nop
if ( node->info.directory.mt_fs == NULL ) {
2002f18: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
2002f1c: 80 a0 a0 00 cmp %g2, 0
2002f20: 12 80 00 05 bne 2002f34 <IMFS_mount+0x3c> <== NEVER TAKEN
2002f24: 01 00 00 00 nop
node->info.directory.mt_fs = mt_entry;
2002f28: 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;
2002f2c: 81 c7 e0 08 ret
2002f30: 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;
2002f34: 40 00 31 ce call 200f66c <__errno> <== NOT EXECUTED
2002f38: 01 00 00 00 nop <== NOT EXECUTED
2002f3c: 10 80 00 05 b 2002f50 <IMFS_mount+0x58> <== NOT EXECUTED
2002f40: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
2002f44: 40 00 31 ca call 200f66c <__errno>
2002f48: 01 00 00 00 nop
2002f4c: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
2002f50: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
2002f54: 81 c7 e0 08 ret
2002f58: 91 e8 3f ff restore %g0, -1, %o0
0200bb74 <IMFS_node_remove_directory>:
}
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node
)
{
200bb74: 9d e3 bf a0 save %sp, -96, %sp
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
200bb78: 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 );
200bb7c: 82 06 20 54 add %i0, 0x54, %g1
200bb80: 80 a0 80 01 cmp %g2, %g1
200bb84: 22 80 00 06 be,a 200bb9c <IMFS_node_remove_directory+0x28>
200bb88: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
errno = ENOTEMPTY;
200bb8c: 40 00 0e b8 call 200f66c <__errno>
200bb90: 01 00 00 00 nop
200bb94: 10 80 00 08 b 200bbb4 <IMFS_node_remove_directory+0x40>
200bb98: 82 10 20 5a mov 0x5a, %g1 ! 5a <PROM_START+0x5a>
node = NULL;
} else if ( IMFS_is_mount_point( node ) ) {
200bb9c: 80 a0 60 00 cmp %g1, 0
200bba0: 02 80 00 07 be 200bbbc <IMFS_node_remove_directory+0x48> <== ALWAYS TAKEN
200bba4: 01 00 00 00 nop
errno = EBUSY;
200bba8: 40 00 0e b1 call 200f66c <__errno> <== NOT EXECUTED
200bbac: 01 00 00 00 nop <== NOT EXECUTED
200bbb0: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
200bbb4: c2 22 00 00 st %g1, [ %o0 ]
200bbb8: b0 10 20 00 clr %i0
node = NULL;
}
return node;
}
200bbbc: 81 c7 e0 08 ret
200bbc0: 81 e8 00 00 restore
02002f5c <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;
2002f5c: 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;
2002f60: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
2002f64: 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 ) {
2002f68: 80 a0 60 02 cmp %g1, 2
2002f6c: 02 80 00 06 be 2002f84 <IMFS_node_type+0x28>
2002f70: 80 a0 60 05 cmp %g1, 5
2002f74: 12 80 00 08 bne 2002f94 <IMFS_node_type+0x38> <== ALWAYS TAKEN
2002f78: 90 10 20 04 mov 4, %o0
2002f7c: 81 c3 e0 08 retl <== NOT EXECUTED
2002f80: 01 00 00 00 nop <== NOT EXECUTED
2002f84: c2 00 a0 50 ld [ %g2 + 0x50 ], %g1
2002f88: c2 00 60 4c ld [ %g1 + 0x4c ], %g1
case IMFS_HARD_LINK:
type = IMFS_type( node->info.hard_link.link_node );
break;
2002f8c: 81 c3 e0 08 retl
2002f90: d0 00 40 00 ld [ %g1 ], %o0
type = imfs_type;
break;
}
return type;
}
2002f94: 81 c3 e0 08 retl
2002f98: 90 10 00 01 mov %g1, %o0
02002fd8 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
2002fd8: 9d e3 bf 98 save %sp, -104, %sp
int rv = 0;
IMFS_jnode_t *node = oldloc->node_access;
2002fdc: 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 ) {
2002fe0: c2 07 60 08 ld [ %i5 + 8 ], %g1
2002fe4: 80 a0 60 00 cmp %g1, 0
2002fe8: 02 80 00 20 be 2003068 <IMFS_rename+0x90> <== NEVER TAKEN
2002fec: f4 06 a0 08 ld [ %i2 + 8 ], %i2
if ( namelen < IMFS_NAME_MAX ) {
2002ff0: 80 a7 20 1f cmp %i4, 0x1f
2002ff4: 18 80 00 19 bgu 2003058 <IMFS_rename+0x80> <== NEVER TAKEN
2002ff8: 94 10 00 1c mov %i4, %o2
memcpy( node->name, name, namelen );
2002ffc: 92 10 00 1b mov %i3, %o1
2003000: 40 00 33 ec call 200ffb0 <memcpy>
2003004: 90 07 60 0c add %i5, 0xc, %o0
node->name [namelen] = '\0';
2003008: b8 07 40 1c add %i5, %i4, %i4
200300c: c0 2f 20 0c clrb [ %i4 + 0xc ]
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
2003010: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
2003014: c2 07 60 04 ld [ %i5 + 4 ], %g1
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
2003018: 90 07 bf f8 add %fp, -8, %o0
next->previous = previous;
200301c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
2003020: c4 20 40 00 st %g2, [ %g1 ]
static inline void IMFS_add_to_directory(
IMFS_jnode_t *dir,
IMFS_jnode_t *node
)
{
node->Parent = dir;
2003024: f4 27 60 08 st %i2, [ %i5 + 8 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
2003028: c2 06 a0 58 ld [ %i2 + 0x58 ], %g1
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
200302c: 84 06 a0 54 add %i2, 0x54, %g2
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
2003030: fa 26 a0 58 st %i5, [ %i2 + 0x58 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
2003034: c4 27 40 00 st %g2, [ %i5 ]
tail->previous = the_node;
old_last->next = the_node;
2003038: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
200303c: c2 27 60 04 st %g1, [ %i5 + 4 ]
2003040: 40 00 01 86 call 2003658 <gettimeofday>
2003044: 92 10 20 00 clr %o1
2003048: c2 07 bf f8 ld [ %fp + -8 ], %g1
200304c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
int rv = 0;
2003050: 81 c7 e0 08 ret
2003054: 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;
2003058: 40 00 31 85 call 200f66c <__errno> <== NOT EXECUTED
200305c: 01 00 00 00 nop <== NOT EXECUTED
2003060: 10 80 00 05 b 2003074 <IMFS_rename+0x9c> <== NOT EXECUTED
2003064: 82 10 20 5b mov 0x5b, %g1 ! 5b <PROM_START+0x5b> <== NOT EXECUTED
rv = -1;
}
} else {
errno = EINVAL;
2003068: 40 00 31 81 call 200f66c <__errno> <== NOT EXECUTED
200306c: 01 00 00 00 nop <== NOT EXECUTED
2003070: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2003074: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003078: 81 c7 e0 08 ret <== NOT EXECUTED
200307c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02003158 <IMFS_unmount>:
#endif
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
2003158: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
200315c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
2003160: 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;
2003164: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
2003168: c4 00 80 00 ld [ %g2 ], %g2
200316c: 80 a0 a0 00 cmp %g2, 0
2003170: 12 80 00 0d bne 20031a4 <IMFS_unmount+0x4c> <== NEVER TAKEN
2003174: 01 00 00 00 nop
if ( node->info.directory.mt_fs == mt_entry ) {
2003178: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
200317c: 80 a0 80 18 cmp %g2, %i0
2003180: 12 80 00 05 bne 2003194 <IMFS_unmount+0x3c> <== NEVER TAKEN
2003184: 01 00 00 00 nop
node->info.directory.mt_fs = NULL;
2003188: c0 20 60 5c clr [ %g1 + 0x5c ]
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
200318c: 81 c7 e0 08 ret
2003190: 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;
2003194: 40 00 31 36 call 200f66c <__errno> <== NOT EXECUTED
2003198: 01 00 00 00 nop <== NOT EXECUTED
200319c: 10 80 00 05 b 20031b0 <IMFS_unmount+0x58> <== NOT EXECUTED
20031a0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
20031a4: 40 00 31 32 call 200f66c <__errno> <== NOT EXECUTED
20031a8: 01 00 00 00 nop <== NOT EXECUTED
20031ac: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14> <== NOT EXECUTED
20031b0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20031b4: 81 c7 e0 08 ret <== NOT EXECUTED
20031b8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02003844 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
2003844: 9d e3 bf a0 save %sp, -96, %sp
Heap_Control *heap = RTEMS_Malloc_Heap;
2003848: 03 00 80 72 sethi %hi(0x201c800), %g1
200384c: f6 00 61 b0 ld [ %g1 + 0x1b0 ], %i3 ! 201c9b0 <RTEMS_Malloc_Heap>
if ( !rtems_configuration_get_unified_work_area() ) {
2003850: 03 00 80 69 sethi %hi(0x201a400), %g1
2003854: c2 08 63 a9 ldub [ %g1 + 0x3a9 ], %g1 ! 201a7a9 <Configuration+0x31>
2003858: 80 a0 60 00 cmp %g1, 0
200385c: 12 80 00 1b bne 20038c8 <RTEMS_Malloc_Initialize+0x84>
2003860: 03 00 80 74 sethi %hi(0x201d000), %g1
2003864: 3b 00 80 22 sethi %hi(0x2008800), %i5
2003868: b8 10 20 00 clr %i4
200386c: 10 80 00 0b b 2003898 <RTEMS_Malloc_Initialize+0x54>
2003870: ba 17 60 b0 or %i5, 0xb0, %i5
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
size_t i;
for (i = 0; i < area_count; ++i) {
const Heap_Area *area = &areas [i];
uintptr_t space_available = (*init_or_extend)(
2003874: d4 06 20 04 ld [ %i0 + 4 ], %o2
2003878: 90 10 00 1b mov %i3, %o0
200387c: 9f c7 40 00 call %i5
2003880: 96 10 20 08 mov 8, %o3
area->begin,
area->size,
page_size
);
if ( space_available > 0 ) {
2003884: 80 a2 20 00 cmp %o0, 0
2003888: 32 80 00 02 bne,a 2003890 <RTEMS_Malloc_Initialize+0x4c> <== ALWAYS TAKEN
200388c: ba 10 00 1a mov %i2, %i5
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) {
2003890: b8 07 20 01 inc %i4
2003894: b0 06 20 08 add %i0, 8, %i0
2003898: 80 a7 00 19 cmp %i4, %i1
200389c: 32 bf ff f6 bne,a 2003874 <RTEMS_Malloc_Initialize+0x30>
20038a0: d2 06 00 00 ld [ %i0 ], %o1
if ( space_available > 0 ) {
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
20038a4: 03 00 80 22 sethi %hi(0x2008800), %g1
20038a8: 82 10 60 b0 or %g1, 0xb0, %g1 ! 20088b0 <_Heap_Initialize>
20038ac: 80 a7 40 01 cmp %i5, %g1
20038b0: 12 80 00 06 bne 20038c8 <RTEMS_Malloc_Initialize+0x84>
20038b4: 03 00 80 74 sethi %hi(0x201d000), %g1
_Internal_error_Occurred(
20038b8: 90 10 20 00 clr %o0
20038bc: 92 10 20 01 mov 1, %o1
20038c0: 40 00 14 8f call 2008afc <_Internal_error_Occurred>
20038c4: 94 10 20 17 mov 0x17, %o2
}
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
20038c8: c2 00 61 90 ld [ %g1 + 0x190 ], %g1
20038cc: 80 a0 60 00 cmp %g1, 0
20038d0: 02 80 00 05 be 20038e4 <RTEMS_Malloc_Initialize+0xa0>
20038d4: 3b 00 80 75 sethi %hi(0x201d400), %i5
(*rtems_malloc_statistics_helpers->initialize)();
20038d8: c2 00 40 00 ld [ %g1 ], %g1
20038dc: 9f c0 40 00 call %g1
20038e0: 01 00 00 00 nop
}
MSBUMP( space_available, _Protected_heap_Get_size( heap ) );
20038e4: f8 07 60 50 ld [ %i5 + 0x50 ], %i4
20038e8: 40 00 16 dd call 200945c <_Protected_heap_Get_size>
20038ec: 90 10 00 1b mov %i3, %o0
20038f0: 90 02 00 1c add %o0, %i4, %o0
20038f4: d0 27 60 50 st %o0, [ %i5 + 0x50 ]
20038f8: 81 c7 e0 08 ret
20038fc: 81 e8 00 00 restore
020224b8 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
20224b8: 9d e3 bf 98 save %sp, -104, %sp
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
20224bc: 80 a6 3f ff cmp %i0, -1
20224c0: 32 80 00 0a bne,a 20224e8 <Stack_check_Dump_threads_usage+0x30>
20224c4: e0 06 21 40 ld [ %i0 + 0x140 ], %l0
if (!Stack_check_Interrupt_stack.area)
20224c8: 3b 00 81 8a sethi %hi(0x2062800), %i5
20224cc: ba 17 62 9c or %i5, 0x29c, %i5 ! 2062a9c <Stack_check_Interrupt_stack>
20224d0: c2 07 60 04 ld [ %i5 + 4 ], %g1
20224d4: 80 a0 60 00 cmp %g1, 0
20224d8: 02 80 00 4c be 2022608 <Stack_check_Dump_threads_usage+0x150><== NEVER TAKEN
20224dc: a0 10 20 00 clr %l0
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
20224e0: 10 80 00 04 b 20224f0 <Stack_check_Dump_threads_usage+0x38>
20224e4: b0 10 20 00 clr %i0
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
20224e8: ba 06 20 b4 add %i0, 0xb4, %i5
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
20224ec: c2 07 60 04 ld [ %i5 + 4 ], %g1
size = Stack_check_usable_stack_size(stack);
20224f0: f2 07 40 00 ld [ %i5 ], %i1
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
20224f4: 84 00 60 10 add %g1, 0x10, %g2
size = Stack_check_usable_stack_size(stack);
20224f8: b2 06 7f f0 add %i1, -16, %i1
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
20224fc: 82 00 60 20 add %g1, 0x20, %g1
for (ebase = base + length; base < ebase; base++)
2022500: 86 0e 7f fc and %i1, -4, %g3
if (*base != U32_PATTERN)
2022504: 09 29 69 69 sethi %hi(0xa5a5a400), %g4
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
2022508: 86 00 40 03 add %g1, %g3, %g3
if (*base != U32_PATTERN)
202250c: 10 80 00 06 b 2022524 <Stack_check_Dump_threads_usage+0x6c>
2022510: 88 11 21 a5 or %g4, 0x1a5, %g4
2022514: 80 a7 00 04 cmp %i4, %g4
2022518: 12 80 00 08 bne 2022538 <Stack_check_Dump_threads_usage+0x80>
202251c: 80 a0 60 00 cmp %g1, 0
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
2022520: 82 00 60 04 add %g1, 4, %g1
2022524: 80 a0 40 03 cmp %g1, %g3
2022528: 2a bf ff fb bcs,a 2022514 <Stack_check_Dump_threads_usage+0x5c><== ALWAYS TAKEN
202252c: f8 00 40 00 ld [ %g1 ], %i4
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
2022530: 10 80 00 06 b 2022548 <Stack_check_Dump_threads_usage+0x90><== NOT EXECUTED
2022534: b8 10 20 00 clr %i4 <== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
2022538: 02 80 00 04 be 2022548 <Stack_check_Dump_threads_usage+0x90><== NEVER TAKEN
202253c: b8 10 20 00 clr %i4
used = Stack_check_Calculate_used( low, size, high_water_mark );
2022540: b8 00 80 19 add %g2, %i1, %i4
2022544: b8 27 00 01 sub %i4, %g1, %i4
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
2022548: 80 a6 20 00 cmp %i0, 0
202254c: 02 80 00 12 be 2022594 <Stack_check_Dump_threads_usage+0xdc>
2022550: 03 00 81 86 sethi %hi(0x2061800), %g1
#endif
{
(*print_handler)(
2022554: f6 06 20 08 ld [ %i0 + 8 ], %i3
2022558: f4 00 60 a8 ld [ %g1 + 0xa8 ], %i2
202255c: 03 00 81 86 sethi %hi(0x2061800), %g1
2022560: e2 00 60 a4 ld [ %g1 + 0xa4 ], %l1 ! 20618a4 <print_context>
2022564: 94 07 bf f8 add %fp, -8, %o2
2022568: 90 10 00 1b mov %i3, %o0
202256c: 7f ff b2 49 call 200ee90 <rtems_object_get_name>
2022570: 92 10 20 05 mov 5, %o1
2022574: 13 00 81 61 sethi %hi(0x2058400), %o1
2022578: 96 10 00 08 mov %o0, %o3
202257c: 92 12 63 f0 or %o1, 0x3f0, %o1
2022580: 90 10 00 11 mov %l1, %o0
2022584: 9f c6 80 00 call %i2
2022588: 94 10 00 1b mov %i3, %o2
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
202258c: 10 80 00 0a b 20225b4 <Stack_check_Dump_threads_usage+0xfc>
2022590: d4 07 60 04 ld [ %i5 + 4 ], %o2
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
}
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
2022594: 05 00 81 86 sethi %hi(0x2061800), %g2
2022598: c2 00 60 a8 ld [ %g1 + 0xa8 ], %g1
202259c: d0 00 a0 a4 ld [ %g2 + 0xa4 ], %o0
20225a0: 13 00 81 62 sethi %hi(0x2058800), %o1
20225a4: 94 10 3f ff mov -1, %o2
20225a8: 9f c0 40 00 call %g1
20225ac: 92 12 60 00 mov %o1, %o1
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
20225b0: d4 07 60 04 ld [ %i5 + 4 ], %o2
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
20225b4: 35 00 81 86 sethi %hi(0x2061800), %i2
20225b8: 37 00 81 86 sethi %hi(0x2061800), %i3
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
20225bc: d6 07 40 00 ld [ %i5 ], %o3
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
20225c0: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1
20225c4: d0 06 e0 a4 ld [ %i3 + 0xa4 ], %o0
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
20225c8: 96 02 ff ff add %o3, -1, %o3
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
20225cc: 13 00 81 62 sethi %hi(0x2058800), %o1
20225d0: 96 02 80 0b add %o2, %o3, %o3
20225d4: 92 12 60 10 or %o1, 0x10, %o1
20225d8: 98 10 00 10 mov %l0, %o4
20225dc: 9f c0 40 00 call %g1
20225e0: 9a 10 00 19 mov %i1, %o5
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
20225e4: 03 00 81 86 sethi %hi(0x2061800), %g1
20225e8: c2 00 60 a0 ld [ %g1 + 0xa0 ], %g1 ! 20618a0 <Stack_check_Initialized>
(*print_handler)( print_context, "Unavailable\n" );
20225ec: d0 06 e0 a4 ld [ %i3 + 0xa4 ], %o0
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
20225f0: 80 a0 60 00 cmp %g1, 0
20225f4: 12 80 00 07 bne 2022610 <Stack_check_Dump_threads_usage+0x158><== ALWAYS TAKEN
20225f8: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1
(*print_handler)( print_context, "Unavailable\n" );
20225fc: 13 00 81 62 sethi %hi(0x2058800), %o1 <== NOT EXECUTED
2022600: 9f c0 40 00 call %g1 <== NOT EXECUTED
2022604: 92 12 60 30 or %o1, 0x30, %o1 ! 2058830 <RTEMS_BDPART_MBR_MASTER_TYPE+0x300><== NOT EXECUTED
2022608: 81 c7 e0 08 ret <== NOT EXECUTED
202260c: 81 e8 00 00 restore <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
2022610: 13 00 81 62 sethi %hi(0x2058800), %o1
2022614: 94 10 00 1c mov %i4, %o2
2022618: 9f c0 40 00 call %g1
202261c: 92 12 60 40 or %o1, 0x40, %o1
2022620: 81 c7 e0 08 ret
2022624: 81 e8 00 00 restore
02022710 <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)
{
2022710: 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");
2022714: 11 00 81 62 sethi %hi(0x2058800), %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);
2022718: fa 06 20 b8 ld [ %i0 + 0xb8 ], %i5
char name[32];
printk("BLOWN STACK!!!\n");
202271c: 7f ff 86 96 call 2004174 <printk>
2022720: 90 12 20 48 or %o0, 0x48, %o0
printk("task control block: 0x%08" PRIxPTR "\n", running);
2022724: 92 10 00 18 mov %i0, %o1
2022728: 11 00 81 62 sethi %hi(0x2058800), %o0
202272c: 7f ff 86 92 call 2004174 <printk>
2022730: 90 12 20 58 or %o0, 0x58, %o0 ! 2058858 <RTEMS_BDPART_MBR_MASTER_TYPE+0x328>
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
2022734: d2 06 20 08 ld [ %i0 + 8 ], %o1
2022738: 11 00 81 62 sethi %hi(0x2058800), %o0
202273c: 7f ff 86 8e call 2004174 <printk>
2022740: 90 12 20 78 or %o0, 0x78, %o0 ! 2058878 <RTEMS_BDPART_MBR_MASTER_TYPE+0x348>
printk(
2022744: d2 06 20 0c ld [ %i0 + 0xc ], %o1
2022748: 11 00 81 62 sethi %hi(0x2058800), %o0
202274c: 7f ff 86 8a call 2004174 <printk>
2022750: 90 12 20 90 or %o0, 0x90, %o0 ! 2058890 <RTEMS_BDPART_MBR_MASTER_TYPE+0x360>
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
2022754: d0 06 20 08 ld [ %i0 + 8 ], %o0
2022758: 94 07 bf e0 add %fp, -32, %o2
202275c: 7f ff b1 cd call 200ee90 <rtems_object_get_name>
2022760: 92 10 20 20 mov 0x20, %o1
2022764: 92 10 00 08 mov %o0, %o1
2022768: 11 00 81 62 sethi %hi(0x2058800), %o0
202276c: 7f ff 86 82 call 2004174 <printk>
2022770: 90 12 20 a8 or %o0, 0xa8, %o0 ! 20588a8 <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)
2022774: d4 06 20 b8 ld [ %i0 + 0xb8 ], %o2
2022778: 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(
202277c: 11 00 81 62 sethi %hi(0x2058800), %o0
2022780: 96 02 80 09 add %o2, %o1, %o3
2022784: 7f ff 86 7c call 2004174 <printk>
2022788: 90 12 20 c0 or %o0, 0xc0, %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) {
202278c: 80 a6 60 00 cmp %i1, 0
2022790: 32 80 00 09 bne,a 20227b4 <Stack_check_report_blown_task+0xa4><== NEVER TAKEN
2022794: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
printk(
2022798: 11 00 81 62 sethi %hi(0x2058800), %o0
202279c: 92 10 20 10 mov 0x10, %o1
20227a0: 90 12 20 f0 or %o0, 0xf0, %o0
20227a4: 94 07 60 08 add %i5, 8, %o2
20227a8: 7f ff 86 73 call 2004174 <printk>
20227ac: 96 07 60 18 add %i5, 0x18, %o3
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal(
20227b0: d2 06 20 0c ld [ %i0 + 0xc ], %o1
20227b4: 7f ff 94 e6 call 2007b4c <rtems_fatal>
20227b8: 90 10 20 09 mov 9, %o0
0200a790 <_CORE_RWLock_Release>:
#include <rtems/score/watchdog.h>
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
200a790: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
200a794: 03 00 80 83 sethi %hi(0x2020c00), %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 );
200a798: 7f ff e4 d2 call 2003ae0 <sparc_disable_interrupts>
200a79c: fa 00 60 10 ld [ %g1 + 0x10 ], %i5 ! 2020c10 <_Per_CPU_Information+0x10>
200a7a0: 84 10 00 08 mov %o0, %g2
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
200a7a4: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
200a7a8: 80 a0 60 00 cmp %g1, 0
200a7ac: 12 80 00 08 bne 200a7cc <_CORE_RWLock_Release+0x3c>
200a7b0: 80 a0 60 01 cmp %g1, 1
_ISR_Enable( level );
200a7b4: 7f ff e4 cf call 2003af0 <sparc_enable_interrupts>
200a7b8: b0 10 20 00 clr %i0
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
200a7bc: 82 10 20 02 mov 2, %g1
200a7c0: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
200a7c4: 81 c7 e0 08 ret
200a7c8: 81 e8 00 00 restore
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
200a7cc: 32 80 00 0b bne,a 200a7f8 <_CORE_RWLock_Release+0x68>
200a7d0: c0 27 60 34 clr [ %i5 + 0x34 ]
the_rwlock->number_of_readers -= 1;
200a7d4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
200a7d8: 82 00 7f ff add %g1, -1, %g1
if ( the_rwlock->number_of_readers != 0 ) {
200a7dc: 80 a0 60 00 cmp %g1, 0
200a7e0: 02 80 00 05 be 200a7f4 <_CORE_RWLock_Release+0x64>
200a7e4: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/* must be unlocked again */
_ISR_Enable( level );
200a7e8: 7f ff e4 c2 call 2003af0 <sparc_enable_interrupts>
200a7ec: b0 10 20 00 clr %i0
return CORE_RWLOCK_SUCCESSFUL;
200a7f0: 30 80 00 24 b,a 200a880 <_CORE_RWLock_Release+0xf0>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
200a7f4: 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;
200a7f8: c0 26 20 44 clr [ %i0 + 0x44 ]
_ISR_Enable( level );
200a7fc: 7f ff e4 bd call 2003af0 <sparc_enable_interrupts>
200a800: 90 10 00 02 mov %g2, %o0
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
200a804: 40 00 07 b3 call 200c6d0 <_Thread_queue_Dequeue>
200a808: 90 10 00 18 mov %i0, %o0
if ( next ) {
200a80c: 80 a2 20 00 cmp %o0, 0
200a810: 22 80 00 1c be,a 200a880 <_CORE_RWLock_Release+0xf0>
200a814: b0 10 20 00 clr %i0
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
200a818: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
200a81c: 80 a0 60 01 cmp %g1, 1
200a820: 32 80 00 05 bne,a 200a834 <_CORE_RWLock_Release+0xa4>
200a824: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
200a828: 82 10 20 02 mov 2, %g1
return CORE_RWLOCK_SUCCESSFUL;
200a82c: 10 80 00 14 b 200a87c <_CORE_RWLock_Release+0xec>
200a830: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
200a834: 82 00 60 01 inc %g1
200a838: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
200a83c: 82 10 20 01 mov 1, %g1
200a840: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
200a844: 40 00 08 df call 200cbc0 <_Thread_queue_First>
200a848: 90 10 00 18 mov %i0, %o0
if ( !next ||
200a84c: 92 92 20 00 orcc %o0, 0, %o1
200a850: 22 80 00 0c be,a 200a880 <_CORE_RWLock_Release+0xf0>
200a854: b0 10 20 00 clr %i0
200a858: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
200a85c: 80 a0 60 01 cmp %g1, 1
200a860: 02 80 00 07 be 200a87c <_CORE_RWLock_Release+0xec> <== NEVER TAKEN
200a864: 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;
200a868: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
200a86c: 82 00 60 01 inc %g1
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
200a870: 40 00 08 85 call 200ca84 <_Thread_queue_Extract>
200a874: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
}
200a878: 30 bf ff f3 b,a 200a844 <_CORE_RWLock_Release+0xb4>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
200a87c: b0 10 20 00 clr %i0
200a880: 81 c7 e0 08 ret
200a884: 81 e8 00 00 restore
0200a888 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
200a888: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200a88c: 90 10 00 18 mov %i0, %o0
200a890: 40 00 06 b5 call 200c364 <_Thread_Get>
200a894: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a898: c2 07 bf fc ld [ %fp + -4 ], %g1
200a89c: 80 a0 60 00 cmp %g1, 0
200a8a0: 12 80 00 08 bne 200a8c0 <_CORE_RWLock_Timeout+0x38> <== NEVER TAKEN
200a8a4: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
200a8a8: 40 00 09 03 call 200ccb4 <_Thread_queue_Process_timeout>
200a8ac: 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;
200a8b0: 03 00 80 81 sethi %hi(0x2020400), %g1
200a8b4: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 20206e0 <_Thread_Dispatch_disable_level>
--level;
200a8b8: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
200a8bc: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ]
200a8c0: 81 c7 e0 08 ret
200a8c4: 81 e8 00 00 restore
020085d8 <_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
)
{
20085d8: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
20085dc: 90 10 00 18 mov %i0, %o0
20085e0: 40 00 07 83 call 200a3ec <_Thread_queue_Dequeue>
20085e4: ba 10 00 18 mov %i0, %i5
20085e8: 80 a2 20 00 cmp %o0, 0
20085ec: 12 80 00 0e bne 2008624 <_CORE_semaphore_Surrender+0x4c>
20085f0: b0 10 20 00 clr %i0
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
20085f4: 7f ff e7 f4 call 20025c4 <sparc_disable_interrupts>
20085f8: 01 00 00 00 nop
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
20085fc: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
2008600: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
2008604: 80 a0 40 02 cmp %g1, %g2
2008608: 1a 80 00 05 bcc 200861c <_CORE_semaphore_Surrender+0x44> <== NEVER TAKEN
200860c: b0 10 20 04 mov 4, %i0
the_semaphore->count += 1;
2008610: 82 00 60 01 inc %g1
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
2008614: b0 10 20 00 clr %i0
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
2008618: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
200861c: 7f ff e7 ee call 20025d4 <sparc_enable_interrupts>
2008620: 01 00 00 00 nop
}
return status;
}
2008624: 81 c7 e0 08 ret
2008628: 81 e8 00 00 restore
02007260 <_Event_Surrender>:
rtems_event_set event_in,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
2007260: 9d e3 bf a0 save %sp, -96, %sp
rtems_event_set pending_events;
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
option_set = the_thread->Wait.option;
2007264: e0 06 20 30 ld [ %i0 + 0x30 ], %l0
_ISR_Disable( level );
2007268: 7f ff ec d7 call 20025c4 <sparc_disable_interrupts>
200726c: ba 10 00 18 mov %i0, %i5
2007270: b0 10 00 08 mov %o0, %i0
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;
2007274: c2 06 80 00 ld [ %i2 ], %g1
2007278: b2 16 40 01 or %i1, %g1, %i1
200727c: 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;
2007280: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
2007284: 82 8e 40 02 andcc %i1, %g2, %g1
2007288: 02 80 00 3d be 200737c <_Event_Surrender+0x11c>
200728c: 07 00 80 76 sethi %hi(0x201d800), %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() &&
2007290: 86 10 e2 f0 or %g3, 0x2f0, %g3 ! 201daf0 <_Per_CPU_Information>
2007294: c8 00 e0 08 ld [ %g3 + 8 ], %g4
2007298: 80 a1 20 00 cmp %g4, 0
200729c: 22 80 00 18 be,a 20072fc <_Event_Surrender+0x9c>
20072a0: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
20072a4: c6 00 e0 10 ld [ %g3 + 0x10 ], %g3
20072a8: 80 a7 40 03 cmp %i5, %g3
20072ac: 32 80 00 14 bne,a 20072fc <_Event_Surrender+0x9c>
20072b0: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
20072b4: c6 06 c0 00 ld [ %i3 ], %g3
20072b8: 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 ) &&
20072bc: 80 a0 e0 01 cmp %g3, 1
20072c0: 38 80 00 0f bgu,a 20072fc <_Event_Surrender+0x9c>
20072c4: c6 07 60 10 ld [ %i5 + 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) ) {
20072c8: 80 a0 40 02 cmp %g1, %g2
20072cc: 02 80 00 04 be 20072dc <_Event_Surrender+0x7c>
20072d0: 80 8c 20 02 btst 2, %l0
20072d4: 02 80 00 2a be 200737c <_Event_Surrender+0x11c> <== NEVER TAKEN
20072d8: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
20072dc: b2 2e 40 01 andn %i1, %g1, %i1
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;
20072e0: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
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(
20072e4: f2 26 80 00 st %i1, [ %i2 ]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
20072e8: c0 27 60 24 clr [ %i5 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
20072ec: c2 20 80 00 st %g1, [ %g2 ]
*sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
20072f0: 82 10 20 03 mov 3, %g1
20072f4: 10 80 00 22 b 200737c <_Event_Surrender+0x11c>
20072f8: c2 26 c0 00 st %g1, [ %i3 ]
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Are_set( the_thread->current_state, wait_state ) ) {
20072fc: 80 8f 00 03 btst %i4, %g3
2007300: 02 80 00 1f be 200737c <_Event_Surrender+0x11c>
2007304: 80 a0 40 02 cmp %g1, %g2
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
2007308: 02 80 00 04 be 2007318 <_Event_Surrender+0xb8>
200730c: 80 8c 20 02 btst 2, %l0
2007310: 02 80 00 1b be 200737c <_Event_Surrender+0x11c> <== NEVER TAKEN
2007314: 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;
2007318: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
200731c: b2 2e 40 01 andn %i1, %g1, %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(
2007320: f2 26 80 00 st %i1, [ %i2 ]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
2007324: c0 27 60 24 clr [ %i5 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
2007328: c2 20 80 00 st %g1, [ %g2 ]
_ISR_Flash( level );
200732c: 7f ff ec aa call 20025d4 <sparc_enable_interrupts>
2007330: 90 10 00 18 mov %i0, %o0
2007334: 7f ff ec a4 call 20025c4 <sparc_disable_interrupts>
2007338: 01 00 00 00 nop
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
200733c: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
2007340: 80 a0 60 02 cmp %g1, 2
2007344: 02 80 00 06 be 200735c <_Event_Surrender+0xfc>
2007348: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
200734c: 7f ff ec a2 call 20025d4 <sparc_enable_interrupts>
2007350: 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 );
2007354: 10 80 00 08 b 2007374 <_Event_Surrender+0x114>
2007358: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1007fff8 <RAM_END+0xdc7fff8>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
200735c: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
2007360: 7f ff ec 9d call 20025d4 <sparc_enable_interrupts>
2007364: 33 04 01 ff sethi %hi(0x1007fc00), %i1
(void) _Watchdog_Remove( &the_thread->Timer );
2007368: 40 00 0e b7 call 200ae44 <_Watchdog_Remove>
200736c: 90 07 60 48 add %i5, 0x48, %o0
2007370: b2 16 63 f8 or %i1, 0x3f8, %i1
2007374: 40 00 0a 49 call 2009c98 <_Thread_Clear_state>
2007378: 91 e8 00 1d restore %g0, %i5, %o0
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
200737c: 7f ff ec 96 call 20025d4 <sparc_enable_interrupts>
2007380: 81 e8 00 00 restore
02007384 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *arg
)
{
2007384: 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 );
2007388: 90 10 00 18 mov %i0, %o0
200738c: 40 00 0b 3d call 200a080 <_Thread_Get>
2007390: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
2007394: c2 07 bf fc ld [ %fp + -4 ], %g1
2007398: 80 a0 60 00 cmp %g1, 0
200739c: 12 80 00 1b bne 2007408 <_Event_Timeout+0x84> <== NEVER TAKEN
20073a0: 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 );
20073a4: 7f ff ec 88 call 20025c4 <sparc_disable_interrupts>
20073a8: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
20073ac: 03 00 80 76 sethi %hi(0x201d800), %g1
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
20073b0: c2 00 63 00 ld [ %g1 + 0x300 ], %g1 ! 201db00 <_Per_CPU_Information+0x10>
20073b4: 80 a7 40 01 cmp %i5, %g1
20073b8: 12 80 00 08 bne 20073d8 <_Event_Timeout+0x54>
20073bc: c0 27 60 24 clr [ %i5 + 0x24 ]
if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
20073c0: c2 06 40 00 ld [ %i1 ], %g1
20073c4: 80 a0 60 01 cmp %g1, 1
20073c8: 12 80 00 05 bne 20073dc <_Event_Timeout+0x58>
20073cc: 82 10 20 06 mov 6, %g1
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
20073d0: 82 10 20 02 mov 2, %g1
20073d4: c2 26 40 00 st %g1, [ %i1 ]
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
20073d8: 82 10 20 06 mov 6, %g1
20073dc: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
_ISR_Enable( level );
20073e0: 7f ff ec 7d call 20025d4 <sparc_enable_interrupts>
20073e4: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
20073e8: 90 10 00 1d mov %i5, %o0
20073ec: 13 04 01 ff sethi %hi(0x1007fc00), %o1
20073f0: 40 00 0a 2a call 2009c98 <_Thread_Clear_state>
20073f4: 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;
20073f8: 03 00 80 75 sethi %hi(0x201d400), %g1
20073fc: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 201d5d0 <_Thread_Dispatch_disable_level>
--level;
2007400: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
2007404: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ]
2007408: 81 c7 e0 08 ret
200740c: 81 e8 00 00 restore
0200d550 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
200d550: 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 ) {
200d554: 80 a6 60 00 cmp %i1, 0
200d558: 02 80 00 7a be 200d740 <_Heap_Free+0x1f0>
200d55c: 88 10 20 01 mov 1, %g4
200d560: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200d564: 40 00 2c 8d call 2018798 <.urem>
200d568: 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
200d56c: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200d570: 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);
200d574: 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;
200d578: 80 a2 00 1b cmp %o0, %i3
200d57c: 0a 80 00 05 bcs 200d590 <_Heap_Free+0x40>
200d580: 82 10 20 00 clr %g1
200d584: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200d588: 80 a0 40 08 cmp %g1, %o0
200d58c: 82 60 3f ff subx %g0, -1, %g1
}
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
200d590: 80 a0 60 00 cmp %g1, 0
200d594: 02 80 00 6b be 200d740 <_Heap_Free+0x1f0>
200d598: 88 10 20 00 clr %g4
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
200d59c: f8 02 20 04 ld [ %o0 + 4 ], %i4
200d5a0: 84 0f 3f fe and %i4, -2, %g2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200d5a4: 82 02 00 02 add %o0, %g2, %g1
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
200d5a8: 80 a0 40 1b cmp %g1, %i3
200d5ac: 0a 80 00 05 bcs 200d5c0 <_Heap_Free+0x70> <== NEVER TAKEN
200d5b0: 86 10 20 00 clr %g3
200d5b4: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
200d5b8: 80 a0 c0 01 cmp %g3, %g1
200d5bc: 86 60 3f ff subx %g0, -1, %g3
_Heap_Protection_block_check( heap, block );
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
200d5c0: 80 a0 e0 00 cmp %g3, 0
200d5c4: 02 80 00 5f be 200d740 <_Heap_Free+0x1f0> <== NEVER TAKEN
200d5c8: 88 10 20 00 clr %g4
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
200d5cc: fa 00 60 04 ld [ %g1 + 4 ], %i5
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
200d5d0: 80 8f 60 01 btst 1, %i5
200d5d4: 22 80 00 5c be,a 200d744 <_Heap_Free+0x1f4> <== NEVER TAKEN
200d5d8: b0 09 20 01 and %g4, 1, %i0 <== NOT EXECUTED
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
200d5dc: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
200d5e0: 80 a0 40 04 cmp %g1, %g4
200d5e4: 02 80 00 07 be 200d600 <_Heap_Free+0xb0>
200d5e8: ba 0f 7f fe and %i5, -2, %i5
200d5ec: 86 00 40 1d add %g1, %i5, %g3
200d5f0: f4 00 e0 04 ld [ %g3 + 4 ], %i2
200d5f4: b4 1e a0 01 xor %i2, 1, %i2
200d5f8: 10 80 00 03 b 200d604 <_Heap_Free+0xb4>
200d5fc: b4 0e a0 01 and %i2, 1, %i2
200d600: b4 10 20 00 clr %i2
if ( !_Heap_Is_prev_used( block ) ) {
200d604: 80 8f 20 01 btst 1, %i4
200d608: 12 80 00 26 bne 200d6a0 <_Heap_Free+0x150>
200d60c: 80 8e a0 ff btst 0xff, %i2
uintptr_t const prev_size = block->prev_size;
200d610: f8 02 00 00 ld [ %o0 ], %i4
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200d614: 86 22 00 1c sub %o0, %i4, %g3
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
200d618: 80 a0 c0 1b cmp %g3, %i3
200d61c: 0a 80 00 04 bcs 200d62c <_Heap_Free+0xdc> <== NEVER TAKEN
200d620: b2 10 20 00 clr %i1
200d624: 80 a1 00 03 cmp %g4, %g3
200d628: b2 60 3f ff subx %g0, -1, %i1
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
200d62c: 80 a6 60 00 cmp %i1, 0
200d630: 02 80 00 44 be 200d740 <_Heap_Free+0x1f0> <== NEVER TAKEN
200d634: 88 10 20 00 clr %g4
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
200d638: f6 00 e0 04 ld [ %g3 + 4 ], %i3
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
200d63c: 80 8e e0 01 btst 1, %i3
200d640: 02 80 00 40 be 200d740 <_Heap_Free+0x1f0> <== NEVER TAKEN
200d644: 80 8e a0 ff btst 0xff, %i2
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
200d648: 22 80 00 0f be,a 200d684 <_Heap_Free+0x134>
200d64c: b8 00 80 1c add %g2, %i4, %i4
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
200d650: c8 00 60 08 ld [ %g1 + 8 ], %g4
Heap_Block *prev = block->prev;
200d654: c2 00 60 0c ld [ %g1 + 0xc ], %g1
uintptr_t const size = block_size + prev_size + next_block_size;
200d658: ba 00 80 1d add %g2, %i5, %i5
prev->next = next;
200d65c: c8 20 60 08 st %g4, [ %g1 + 8 ]
next->prev = prev;
200d660: c2 21 20 0c st %g1, [ %g4 + 0xc ]
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
200d664: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
200d668: b8 07 40 1c add %i5, %i4, %i4
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
200d66c: 82 00 7f ff add %g1, -1, %g1
200d670: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
200d674: f8 20 c0 1c st %i4, [ %g3 + %i4 ]
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
200d678: 82 17 20 01 or %i4, 1, %g1
200d67c: 10 80 00 27 b 200d718 <_Heap_Free+0x1c8>
200d680: c2 20 e0 04 st %g1, [ %g3 + 4 ]
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
200d684: 88 17 20 01 or %i4, 1, %g4
200d688: c8 20 e0 04 st %g4, [ %g3 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200d68c: c6 00 60 04 ld [ %g1 + 4 ], %g3
next_block->prev_size = size;
200d690: f8 22 00 02 st %i4, [ %o0 + %g2 ]
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200d694: 86 08 ff fe and %g3, -2, %g3
200d698: 10 80 00 20 b 200d718 <_Heap_Free+0x1c8>
200d69c: c6 20 60 04 st %g3, [ %g1 + 4 ]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
200d6a0: 22 80 00 0d be,a 200d6d4 <_Heap_Free+0x184>
200d6a4: c6 06 20 08 ld [ %i0 + 8 ], %g3
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
200d6a8: c8 00 60 08 ld [ %g1 + 8 ], %g4
Heap_Block *prev = old_block->prev;
200d6ac: c2 00 60 0c ld [ %g1 + 0xc ], %g1
new_block->next = next;
200d6b0: c8 22 20 08 st %g4, [ %o0 + 8 ]
new_block->prev = prev;
200d6b4: c2 22 20 0c st %g1, [ %o0 + 0xc ]
uintptr_t const size = block_size + next_block_size;
200d6b8: 86 07 40 02 add %i5, %g2, %g3
next->prev = new_block;
prev->next = new_block;
200d6bc: d0 20 60 08 st %o0, [ %g1 + 8 ]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
200d6c0: d0 21 20 0c st %o0, [ %g4 + 0xc ]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
200d6c4: 82 10 e0 01 or %g3, 1, %g1
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
200d6c8: c6 22 00 03 st %g3, [ %o0 + %g3 ]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
200d6cc: 10 80 00 13 b 200d718 <_Heap_Free+0x1c8>
200d6d0: c2 22 20 04 st %g1, [ %o0 + 4 ]
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
200d6d4: f0 22 20 0c st %i0, [ %o0 + 0xc ]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
200d6d8: c6 22 20 08 st %g3, [ %o0 + 8 ]
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
200d6dc: d0 20 e0 0c st %o0, [ %g3 + 0xc ]
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
200d6e0: 86 10 a0 01 or %g2, 1, %g3
200d6e4: c6 22 20 04 st %g3, [ %o0 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200d6e8: c6 00 60 04 ld [ %g1 + 4 ], %g3
next_block->prev_size = block_size;
200d6ec: c4 22 00 02 st %g2, [ %o0 + %g2 ]
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200d6f0: 86 08 ff fe and %g3, -2, %g3
200d6f4: c6 20 60 04 st %g3, [ %g1 + 4 ]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
200d6f8: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
if ( stats->max_free_blocks < stats->free_blocks ) {
200d6fc: c6 06 20 3c ld [ %i0 + 0x3c ], %g3
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
200d700: 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;
200d704: d0 26 20 08 st %o0, [ %i0 + 8 ]
if ( stats->max_free_blocks < stats->free_blocks ) {
200d708: 80 a0 c0 01 cmp %g3, %g1
200d70c: 1a 80 00 03 bcc 200d718 <_Heap_Free+0x1c8>
200d710: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
stats->max_free_blocks = stats->free_blocks;
200d714: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
}
}
/* Statistics */
--stats->used_blocks;
200d718: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
200d71c: 82 00 7f ff add %g1, -1, %g1
200d720: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
++stats->frees;
200d724: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
200d728: 82 00 60 01 inc %g1
200d72c: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
stats->free_size += block_size;
200d730: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
200d734: 84 00 40 02 add %g1, %g2, %g2
200d738: c4 26 20 30 st %g2, [ %i0 + 0x30 ]
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
200d73c: 88 10 20 01 mov 1, %g4
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
200d740: b0 09 20 01 and %g4, 1, %i0
200d744: 81 c7 e0 08 ret
200d748: 81 e8 00 00 restore
0200a750 <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
200a750: 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) {
200a754: b6 10 20 00 clr %i3
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
200a758: ba 10 00 18 mov %i0, %i5
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
200a75c: 10 80 00 11 b 200a7a0 <_Heap_Greedy_allocate+0x50>
200a760: b8 10 20 00 clr %i4
* @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
* boundary equals zero.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
200a764: d2 06 40 01 ld [ %i1 + %g1 ], %o1
200a768: 90 10 00 1d mov %i5, %o0
200a76c: 94 10 20 00 clr %o2
200a770: 40 00 1d 8e call 2011da8 <_Heap_Allocate_aligned_with_boundary>
200a774: 96 10 20 00 clr %o3
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
200a778: 82 92 20 00 orcc %o0, 0, %g1
200a77c: 22 80 00 09 be,a 200a7a0 <_Heap_Greedy_allocate+0x50> <== NEVER TAKEN
200a780: b6 06 e0 01 inc %i3 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200a784: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
200a788: 40 00 4a 8c call 201d1b8 <.urem>
200a78c: 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);
200a790: 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;
200a794: f8 22 20 08 st %i4, [ %o0 + 8 ]
200a798: b8 10 00 08 mov %o0, %i4
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
200a79c: b6 06 e0 01 inc %i3
200a7a0: 80 a6 c0 1a cmp %i3, %i2
200a7a4: 12 bf ff f0 bne 200a764 <_Heap_Greedy_allocate+0x14>
200a7a8: 83 2e e0 02 sll %i3, 2, %g1
200a7ac: 10 80 00 0a b 200a7d4 <_Heap_Greedy_allocate+0x84>
200a7b0: b0 10 20 00 clr %i0
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
_Heap_Block_allocate(
200a7b4: 90 10 00 1d mov %i5, %o0
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
200a7b8: 96 0a ff fe and %o3, -2, %o3
200a7bc: 92 10 00 1b mov %i3, %o1
200a7c0: 94 06 e0 08 add %i3, 8, %o2
200a7c4: 40 00 00 cb call 200aaf0 <_Heap_Block_allocate>
200a7c8: 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;
200a7cc: f0 26 e0 08 st %i0, [ %i3 + 8 ]
200a7d0: b0 10 00 1b mov %i3, %i0
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
200a7d4: f6 07 60 08 ld [ %i5 + 8 ], %i3
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
200a7d8: 80 a6 c0 1d cmp %i3, %i5
200a7dc: 32 bf ff f6 bne,a 200a7b4 <_Heap_Greedy_allocate+0x64>
200a7e0: d6 06 e0 04 ld [ %i3 + 4 ], %o3
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
200a7e4: 10 80 00 07 b 200a800 <_Heap_Greedy_allocate+0xb0>
200a7e8: 80 a7 20 00 cmp %i4, 0
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
200a7ec: 92 07 20 08 add %i4, 8, %o1
200a7f0: 90 10 00 1d mov %i5, %o0
200a7f4: 40 00 1d de call 2011f6c <_Heap_Free>
200a7f8: b8 10 00 1b mov %i3, %i4
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
200a7fc: 80 a7 20 00 cmp %i4, 0
200a800: 32 bf ff fb bne,a 200a7ec <_Heap_Greedy_allocate+0x9c>
200a804: f6 07 20 08 ld [ %i4 + 8 ], %i3
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
return blocks;
}
200a808: 81 c7 e0 08 ret
200a80c: 81 e8 00 00 restore
020120f0 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
20120f0: 9d e3 bf a0 save %sp, -96, %sp
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
20120f4: 90 10 20 00 clr %o0
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
Heap_Block *current = heap->first_block;
20120f8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
20120fc: 10 80 00 0a b 2012124 <_Heap_Iterate+0x34>
2012100: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
uintptr_t size = _Heap_Block_size( current );
Heap_Block *next = _Heap_Block_at( current, size );
bool used = _Heap_Is_prev_used( next );
stop = (*visitor)( current, size, used, visitor_arg );
2012104: 90 10 00 01 mov %g1, %o0
2012108: 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);
201210c: 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;
2012110: d4 07 60 04 ld [ %i5 + 4 ], %o2
2012114: 96 10 00 1a mov %i2, %o3
2012118: 9f c6 40 00 call %i1
201211c: 94 0a a0 01 and %o2, 1, %o2
2012120: 82 10 00 1d mov %i5, %g1
{
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
2012124: 80 a0 40 1c cmp %g1, %i4
2012128: 02 80 00 05 be 201213c <_Heap_Iterate+0x4c>
201212c: 90 1a 20 01 xor %o0, 1, %o0
2012130: 80 8a 20 ff btst 0xff, %o0
2012134: 32 bf ff f4 bne,a 2012104 <_Heap_Iterate+0x14> <== ALWAYS TAKEN
2012138: d2 00 60 04 ld [ %g1 + 4 ], %o1
201213c: 81 c7 e0 08 ret
2012140: 81 e8 00 00 restore
0200d874 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
200d874: 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);
200d878: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200d87c: 40 00 2b c7 call 2018798 <.urem>
200d880: 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
200d884: c8 06 20 20 ld [ %i0 + 0x20 ], %g4
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200d888: 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);
200d88c: 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;
200d890: 80 a2 00 04 cmp %o0, %g4
200d894: 0a 80 00 05 bcs 200d8a8 <_Heap_Size_of_alloc_area+0x34>
200d898: 82 10 20 00 clr %g1
200d89c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200d8a0: 80 a0 40 08 cmp %g1, %o0
200d8a4: 82 60 3f ff subx %g0, -1, %g1
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
200d8a8: 80 a0 60 00 cmp %g1, 0
200d8ac: 02 80 00 15 be 200d900 <_Heap_Size_of_alloc_area+0x8c>
200d8b0: 86 10 20 00 clr %g3
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
200d8b4: c2 02 20 04 ld [ %o0 + 4 ], %g1
200d8b8: 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);
200d8bc: 82 02 00 01 add %o0, %g1, %g1
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
200d8c0: 80 a0 40 04 cmp %g1, %g4
200d8c4: 0a 80 00 05 bcs 200d8d8 <_Heap_Size_of_alloc_area+0x64> <== NEVER TAKEN
200d8c8: 84 10 20 00 clr %g2
200d8cc: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
200d8d0: 80 a0 80 01 cmp %g2, %g1
200d8d4: 84 60 3f ff subx %g0, -1, %g2
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
200d8d8: 80 a0 a0 00 cmp %g2, 0
200d8dc: 02 80 00 09 be 200d900 <_Heap_Size_of_alloc_area+0x8c> <== NEVER TAKEN
200d8e0: 86 10 20 00 clr %g3
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
200d8e4: c4 00 60 04 ld [ %g1 + 4 ], %g2
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
200d8e8: 80 88 a0 01 btst 1, %g2
200d8ec: 02 80 00 05 be 200d900 <_Heap_Size_of_alloc_area+0x8c> <== NEVER TAKEN
200d8f0: 82 20 40 19 sub %g1, %i1, %g1
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
200d8f4: 86 10 20 01 mov 1, %g3
|| !_Heap_Is_prev_used( next_block )
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
200d8f8: 82 00 60 04 add %g1, 4, %g1
200d8fc: c2 26 80 00 st %g1, [ %i2 ]
return true;
}
200d900: b0 08 e0 01 and %g3, 1, %i0
200d904: 81 c7 e0 08 ret
200d908: 81 e8 00 00 restore
02009708 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
2009708: 9d e3 bf 80 save %sp, -128, %sp
200970c: ac 10 00 19 mov %i1, %l6
uintptr_t const page_size = heap->page_size;
2009710: f8 06 20 10 ld [ %i0 + 0x10 ], %i4
uintptr_t const min_block_size = heap->min_block_size;
2009714: f6 06 20 14 ld [ %i0 + 0x14 ], %i3
Heap_Block *const first_block = heap->first_block;
2009718: f2 06 20 20 ld [ %i0 + 0x20 ], %i1
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
200971c: 80 a6 a0 00 cmp %i2, 0
2009720: 02 80 00 05 be 2009734 <_Heap_Walk+0x2c>
2009724: e0 06 20 24 ld [ %i0 + 0x24 ], %l0
2009728: 3b 00 80 25 sethi %hi(0x2009400), %i5
200972c: 10 80 00 04 b 200973c <_Heap_Walk+0x34>
2009730: ba 17 62 b8 or %i5, 0x2b8, %i5 ! 20096b8 <_Heap_Walk_print>
2009734: 3b 00 80 25 sethi %hi(0x2009400), %i5
2009738: ba 17 62 b0 or %i5, 0x2b0, %i5 ! 20096b0 <_Heap_Walk_print_nothing>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
200973c: 05 00 80 7f sethi %hi(0x201fc00), %g2
2009740: c4 00 a2 e8 ld [ %g2 + 0x2e8 ], %g2 ! 201fee8 <_System_state_Current>
2009744: 80 a0 a0 03 cmp %g2, 3
2009748: 22 80 00 04 be,a 2009758 <_Heap_Walk+0x50>
200974c: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
return true;
2009750: 10 80 01 2a b 2009bf8 <_Heap_Walk+0x4f0>
2009754: b0 10 20 01 mov 1, %i0
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
2009758: da 06 20 18 ld [ %i0 + 0x18 ], %o5
200975c: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
2009760: f2 23 a0 60 st %i1, [ %sp + 0x60 ]
2009764: e0 23 a0 64 st %l0, [ %sp + 0x64 ]
2009768: c4 06 20 08 ld [ %i0 + 8 ], %g2
200976c: 90 10 00 16 mov %l6, %o0
2009770: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
2009774: c4 06 20 0c ld [ %i0 + 0xc ], %g2
2009778: 92 10 20 00 clr %o1
200977c: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
2009780: 15 00 80 71 sethi %hi(0x201c400), %o2
2009784: 96 10 00 1c mov %i4, %o3
2009788: 94 12 a1 30 or %o2, 0x130, %o2
200978c: 9f c7 40 00 call %i5
2009790: 98 10 00 1b mov %i3, %o4
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
2009794: 80 a7 20 00 cmp %i4, 0
2009798: 12 80 00 07 bne 20097b4 <_Heap_Walk+0xac>
200979c: 80 8f 20 07 btst 7, %i4
(*printer)( source, true, "page size is zero\n" );
20097a0: 15 00 80 71 sethi %hi(0x201c400), %o2
20097a4: 90 10 00 16 mov %l6, %o0
20097a8: 92 10 20 01 mov 1, %o1
20097ac: 10 80 00 37 b 2009888 <_Heap_Walk+0x180>
20097b0: 94 12 a1 c8 or %o2, 0x1c8, %o2
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
20097b4: 22 80 00 08 be,a 20097d4 <_Heap_Walk+0xcc>
20097b8: 90 10 00 1b mov %i3, %o0
(*printer)(
20097bc: 15 00 80 71 sethi %hi(0x201c400), %o2
20097c0: 90 10 00 16 mov %l6, %o0
20097c4: 92 10 20 01 mov 1, %o1
20097c8: 94 12 a1 e0 or %o2, 0x1e0, %o2
20097cc: 10 80 01 12 b 2009c14 <_Heap_Walk+0x50c>
20097d0: 96 10 00 1c mov %i4, %o3
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
20097d4: 7f ff e0 ec call 2001b84 <.urem>
20097d8: 92 10 00 1c mov %i4, %o1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
20097dc: 80 a2 20 00 cmp %o0, 0
20097e0: 22 80 00 08 be,a 2009800 <_Heap_Walk+0xf8>
20097e4: 90 06 60 08 add %i1, 8, %o0
(*printer)(
20097e8: 15 00 80 71 sethi %hi(0x201c400), %o2
20097ec: 90 10 00 16 mov %l6, %o0
20097f0: 92 10 20 01 mov 1, %o1
20097f4: 94 12 a2 00 or %o2, 0x200, %o2
20097f8: 10 80 01 07 b 2009c14 <_Heap_Walk+0x50c>
20097fc: 96 10 00 1b mov %i3, %o3
2009800: 7f ff e0 e1 call 2001b84 <.urem>
2009804: 92 10 00 1c mov %i4, %o1
);
return false;
}
if (
2009808: 80 a2 20 00 cmp %o0, 0
200980c: 22 80 00 07 be,a 2009828 <_Heap_Walk+0x120>
2009810: c4 06 60 04 ld [ %i1 + 4 ], %g2
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
2009814: 15 00 80 71 sethi %hi(0x201c400), %o2
2009818: 90 10 00 16 mov %l6, %o0
200981c: 92 10 20 01 mov 1, %o1
2009820: 10 80 00 fc b 2009c10 <_Heap_Walk+0x508>
2009824: 94 12 a2 28 or %o2, 0x228, %o2
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
2009828: 80 88 a0 01 btst 1, %g2
200982c: 32 80 00 07 bne,a 2009848 <_Heap_Walk+0x140>
2009830: f4 04 20 04 ld [ %l0 + 4 ], %i2
(*printer)(
2009834: 15 00 80 71 sethi %hi(0x201c400), %o2
2009838: 90 10 00 16 mov %l6, %o0
200983c: 92 10 20 01 mov 1, %o1
2009840: 10 80 00 12 b 2009888 <_Heap_Walk+0x180>
2009844: 94 12 a2 60 or %o2, 0x260, %o2
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
2009848: b4 0e bf fe and %i2, -2, %i2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200984c: b4 04 00 1a add %l0, %i2, %i2
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
2009850: c4 06 a0 04 ld [ %i2 + 4 ], %g2
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
2009854: 80 88 a0 01 btst 1, %g2
2009858: 12 80 00 07 bne 2009874 <_Heap_Walk+0x16c>
200985c: 80 a6 80 19 cmp %i2, %i1
(*printer)(
2009860: 15 00 80 71 sethi %hi(0x201c400), %o2
2009864: 90 10 00 16 mov %l6, %o0
2009868: 92 10 20 01 mov 1, %o1
200986c: 10 80 00 07 b 2009888 <_Heap_Walk+0x180>
2009870: 94 12 a2 90 or %o2, 0x290, %o2
);
return false;
}
if (
2009874: 02 80 00 0a be 200989c <_Heap_Walk+0x194>
2009878: 15 00 80 71 sethi %hi(0x201c400), %o2
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
200987c: 90 10 00 16 mov %l6, %o0
2009880: 92 10 20 01 mov 1, %o1
2009884: 94 12 a2 a8 or %o2, 0x2a8, %o2
2009888: 9f c7 40 00 call %i5
200988c: b0 10 20 00 clr %i0
2009890: b0 0e 20 ff and %i0, 0xff, %i0
2009894: 81 c7 e0 08 ret
2009898: 81 e8 00 00 restore
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
200989c: e2 06 20 10 ld [ %i0 + 0x10 ], %l1
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
20098a0: d6 06 20 08 ld [ %i0 + 8 ], %o3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
20098a4: 10 80 00 30 b 2009964 <_Heap_Walk+0x25c>
20098a8: b2 10 00 18 mov %i0, %i1
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
20098ac: 80 a0 c0 0b cmp %g3, %o3
20098b0: 18 80 00 05 bgu 20098c4 <_Heap_Walk+0x1bc>
20098b4: 84 10 20 00 clr %g2
20098b8: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
20098bc: 80 a0 80 0b cmp %g2, %o3
20098c0: 84 60 3f ff subx %g0, -1, %g2
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
20098c4: 80 a0 a0 00 cmp %g2, 0
20098c8: 32 80 00 07 bne,a 20098e4 <_Heap_Walk+0x1dc>
20098cc: 90 02 e0 08 add %o3, 8, %o0
(*printer)(
20098d0: 15 00 80 71 sethi %hi(0x201c400), %o2
20098d4: 90 10 00 16 mov %l6, %o0
20098d8: 92 10 20 01 mov 1, %o1
20098dc: 10 80 00 ce b 2009c14 <_Heap_Walk+0x50c>
20098e0: 94 12 a2 d8 or %o2, 0x2d8, %o2
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
20098e4: d6 27 bf fc st %o3, [ %fp + -4 ]
20098e8: 7f ff e0 a7 call 2001b84 <.urem>
20098ec: 92 10 00 11 mov %l1, %o1
);
return false;
}
if (
20098f0: 80 a2 20 00 cmp %o0, 0
20098f4: 02 80 00 07 be 2009910 <_Heap_Walk+0x208>
20098f8: d6 07 bf fc ld [ %fp + -4 ], %o3
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
20098fc: 15 00 80 71 sethi %hi(0x201c400), %o2
2009900: 90 10 00 16 mov %l6, %o0
2009904: 92 10 20 01 mov 1, %o1
2009908: 10 80 00 c3 b 2009c14 <_Heap_Walk+0x50c>
200990c: 94 12 a2 f8 or %o2, 0x2f8, %o2
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
2009910: c4 02 e0 04 ld [ %o3 + 4 ], %g2
2009914: 84 08 bf fe and %g2, -2, %g2
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
2009918: 84 02 c0 02 add %o3, %g2, %g2
200991c: c4 00 a0 04 ld [ %g2 + 4 ], %g2
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
2009920: 80 88 a0 01 btst 1, %g2
2009924: 22 80 00 07 be,a 2009940 <_Heap_Walk+0x238>
2009928: d8 02 e0 0c ld [ %o3 + 0xc ], %o4
(*printer)(
200992c: 15 00 80 71 sethi %hi(0x201c400), %o2
2009930: 90 10 00 16 mov %l6, %o0
2009934: 92 10 20 01 mov 1, %o1
2009938: 10 80 00 b7 b 2009c14 <_Heap_Walk+0x50c>
200993c: 94 12 a3 28 or %o2, 0x328, %o2
);
return false;
}
if ( free_block->prev != prev_block ) {
2009940: 80 a3 00 19 cmp %o4, %i1
2009944: 02 80 00 07 be 2009960 <_Heap_Walk+0x258>
2009948: b2 10 00 0b mov %o3, %i1
(*printer)(
200994c: 15 00 80 71 sethi %hi(0x201c400), %o2
2009950: 90 10 00 16 mov %l6, %o0
2009954: 92 10 20 01 mov 1, %o1
2009958: 10 80 00 4d b 2009a8c <_Heap_Walk+0x384>
200995c: 94 12 a3 48 or %o2, 0x348, %o2
return false;
}
prev_block = free_block;
free_block = free_block->next;
2009960: d6 02 e0 08 ld [ %o3 + 8 ], %o3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
2009964: 80 a2 c0 18 cmp %o3, %i0
2009968: 32 bf ff d1 bne,a 20098ac <_Heap_Walk+0x1a4>
200996c: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
2009970: 2b 00 80 72 sethi %hi(0x201c800), %l5
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
2009974: b2 10 00 1a mov %i2, %i1
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
2009978: aa 15 60 48 or %l5, 0x48, %l5
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
200997c: 23 00 80 72 sethi %hi(0x201c800), %l1
2009980: 2f 00 80 71 sethi %hi(0x201c400), %l7
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
2009984: e4 06 60 04 ld [ %i1 + 4 ], %l2
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
2009988: d8 06 20 20 ld [ %i0 + 0x20 ], %o4
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
200998c: 9e 1e 40 10 xor %i1, %l0, %o7
2009990: 80 a0 00 0f cmp %g0, %o7
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
2009994: a8 0c bf fe and %l2, -2, %l4
2009998: 9a 40 20 00 addx %g0, 0, %o5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200999c: a6 06 40 14 add %i1, %l4, %l3
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
20099a0: a4 0c a0 01 and %l2, 1, %l2
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
20099a4: 80 a3 00 13 cmp %o4, %l3
20099a8: 18 80 00 05 bgu 20099bc <_Heap_Walk+0x2b4> <== NEVER TAKEN
20099ac: 9e 10 20 00 clr %o7
20099b0: de 06 20 24 ld [ %i0 + 0x24 ], %o7
20099b4: 80 a3 c0 13 cmp %o7, %l3
20099b8: 9e 60 3f ff subx %g0, -1, %o7
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
20099bc: 80 a3 e0 00 cmp %o7, 0
20099c0: 32 80 00 07 bne,a 20099dc <_Heap_Walk+0x2d4>
20099c4: da 27 bf f8 st %o5, [ %fp + -8 ]
(*printer)(
20099c8: 15 00 80 71 sethi %hi(0x201c400), %o2
20099cc: 90 10 00 16 mov %l6, %o0
20099d0: 92 10 20 01 mov 1, %o1
20099d4: 10 80 00 2c b 2009a84 <_Heap_Walk+0x37c>
20099d8: 94 12 a3 80 or %o2, 0x380, %o2
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
20099dc: 90 10 00 14 mov %l4, %o0
20099e0: 7f ff e0 69 call 2001b84 <.urem>
20099e4: 92 10 00 1c mov %i4, %o1
20099e8: da 07 bf f8 ld [ %fp + -8 ], %o5
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
20099ec: 80 a2 20 00 cmp %o0, 0
20099f0: 02 80 00 0c be 2009a20 <_Heap_Walk+0x318>
20099f4: 9e 0b 60 ff and %o5, 0xff, %o7
20099f8: 80 a3 e0 00 cmp %o7, 0
20099fc: 02 80 00 19 be 2009a60 <_Heap_Walk+0x358>
2009a00: 80 a6 40 13 cmp %i1, %l3
(*printer)(
2009a04: 15 00 80 71 sethi %hi(0x201c400), %o2
2009a08: 90 10 00 16 mov %l6, %o0
2009a0c: 92 10 20 01 mov 1, %o1
2009a10: 94 12 a3 b0 or %o2, 0x3b0, %o2
2009a14: 96 10 00 19 mov %i1, %o3
2009a18: 10 80 00 1d b 2009a8c <_Heap_Walk+0x384>
2009a1c: 98 10 00 14 mov %l4, %o4
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
2009a20: 80 a3 e0 00 cmp %o7, 0
2009a24: 02 80 00 0f be 2009a60 <_Heap_Walk+0x358>
2009a28: 80 a6 40 13 cmp %i1, %l3
2009a2c: 80 a5 00 1b cmp %l4, %i3
2009a30: 1a 80 00 0c bcc 2009a60 <_Heap_Walk+0x358>
2009a34: 80 a6 40 13 cmp %i1, %l3
(*printer)(
2009a38: 90 10 00 16 mov %l6, %o0
2009a3c: 92 10 20 01 mov 1, %o1
2009a40: 15 00 80 71 sethi %hi(0x201c400), %o2
2009a44: 96 10 00 19 mov %i1, %o3
2009a48: 94 12 a3 e0 or %o2, 0x3e0, %o2
2009a4c: 98 10 00 14 mov %l4, %o4
2009a50: 9f c7 40 00 call %i5
2009a54: 9a 10 00 1b mov %i3, %o5
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
2009a58: 10 80 00 68 b 2009bf8 <_Heap_Walk+0x4f0>
2009a5c: b0 10 20 00 clr %i0
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
2009a60: 2a 80 00 10 bcs,a 2009aa0 <_Heap_Walk+0x398>
2009a64: de 04 e0 04 ld [ %l3 + 4 ], %o7
2009a68: 80 8b 60 ff btst 0xff, %o5
2009a6c: 22 80 00 0d be,a 2009aa0 <_Heap_Walk+0x398>
2009a70: de 04 e0 04 ld [ %l3 + 4 ], %o7
(*printer)(
2009a74: 15 00 80 72 sethi %hi(0x201c800), %o2
2009a78: 90 10 00 16 mov %l6, %o0
2009a7c: 92 10 20 01 mov 1, %o1
2009a80: 94 12 a0 10 or %o2, 0x10, %o2
2009a84: 96 10 00 19 mov %i1, %o3
2009a88: 98 10 00 13 mov %l3, %o4
2009a8c: 9f c7 40 00 call %i5
2009a90: b0 10 20 00 clr %i0
2009a94: b0 0e 20 ff and %i0, 0xff, %i0
2009a98: 81 c7 e0 08 ret
2009a9c: 81 e8 00 00 restore
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
2009aa0: 80 8b e0 01 btst 1, %o7
2009aa4: 12 80 00 3f bne 2009ba0 <_Heap_Walk+0x498>
2009aa8: 90 10 00 16 mov %l6, %o0
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
2009aac: da 06 60 0c ld [ %i1 + 0xc ], %o5
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
2009ab0: d8 06 20 08 ld [ %i0 + 8 ], %o4
2009ab4: 80 a3 40 0c cmp %o5, %o4
2009ab8: 02 80 00 08 be 2009ad8 <_Heap_Walk+0x3d0>
2009abc: de 06 20 0c ld [ %i0 + 0xc ], %o7
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
2009ac0: 80 a3 40 18 cmp %o5, %i0
2009ac4: 12 80 00 07 bne 2009ae0 <_Heap_Walk+0x3d8>
2009ac8: 96 14 60 b8 or %l1, 0xb8, %o3
2009acc: 17 00 80 71 sethi %hi(0x201c400), %o3
2009ad0: 10 80 00 04 b 2009ae0 <_Heap_Walk+0x3d8>
2009ad4: 96 12 e1 00 or %o3, 0x100, %o3 ! 201c500 <__log2table+0x130>
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
2009ad8: 03 00 80 71 sethi %hi(0x201c400), %g1
2009adc: 96 10 60 f0 or %g1, 0xf0, %o3 ! 201c4f0 <__log2table+0x120>
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
2009ae0: d8 06 60 08 ld [ %i1 + 8 ], %o4
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
2009ae4: 80 a3 00 0f cmp %o4, %o7
2009ae8: 02 80 00 06 be 2009b00 <_Heap_Walk+0x3f8>
2009aec: 80 a3 00 18 cmp %o4, %i0
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
2009af0: 12 80 00 06 bne 2009b08 <_Heap_Walk+0x400>
2009af4: 9e 14 60 b8 or %l1, 0xb8, %o7
2009af8: 10 80 00 04 b 2009b08 <_Heap_Walk+0x400>
2009afc: 9e 15 e1 20 or %l7, 0x120, %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)(
2009b00: 03 00 80 71 sethi %hi(0x201c400), %g1
2009b04: 9e 10 61 10 or %g1, 0x110, %o7 ! 201c510 <__log2table+0x140>
2009b08: d6 23 a0 5c st %o3, [ %sp + 0x5c ]
2009b0c: d8 23 a0 60 st %o4, [ %sp + 0x60 ]
2009b10: de 23 a0 64 st %o7, [ %sp + 0x64 ]
2009b14: 90 10 00 16 mov %l6, %o0
2009b18: 92 10 20 00 clr %o1
2009b1c: 94 10 00 15 mov %l5, %o2
2009b20: 96 10 00 19 mov %i1, %o3
2009b24: 9f c7 40 00 call %i5
2009b28: 98 10 00 14 mov %l4, %o4
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
2009b2c: da 04 c0 00 ld [ %l3 ], %o5
2009b30: 80 a5 00 0d cmp %l4, %o5
2009b34: 02 80 00 0c be 2009b64 <_Heap_Walk+0x45c>
2009b38: 80 a4 a0 00 cmp %l2, 0
(*printer)(
2009b3c: e6 23 a0 5c st %l3, [ %sp + 0x5c ]
2009b40: 90 10 00 16 mov %l6, %o0
2009b44: 92 10 20 01 mov 1, %o1
2009b48: 15 00 80 72 sethi %hi(0x201c800), %o2
2009b4c: 96 10 00 19 mov %i1, %o3
2009b50: 94 12 a0 80 or %o2, 0x80, %o2
2009b54: 9f c7 40 00 call %i5
2009b58: 98 10 00 14 mov %l4, %o4
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
2009b5c: 10 bf ff ce b 2009a94 <_Heap_Walk+0x38c>
2009b60: b0 10 20 00 clr %i0
);
return false;
}
if ( !prev_used ) {
2009b64: 32 80 00 0a bne,a 2009b8c <_Heap_Walk+0x484>
2009b68: c6 06 20 08 ld [ %i0 + 8 ], %g3
(*printer)(
2009b6c: 15 00 80 72 sethi %hi(0x201c800), %o2
2009b70: 90 10 00 16 mov %l6, %o0
2009b74: 92 10 20 01 mov 1, %o1
2009b78: 10 80 00 26 b 2009c10 <_Heap_Walk+0x508>
2009b7c: 94 12 a0 c0 or %o2, 0xc0, %o2
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
2009b80: 22 80 00 19 be,a 2009be4 <_Heap_Walk+0x4dc>
2009b84: b2 10 00 13 mov %l3, %i1
return true;
}
free_block = free_block->next;
2009b88: c6 00 e0 08 ld [ %g3 + 8 ], %g3
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
2009b8c: 80 a0 c0 18 cmp %g3, %i0
2009b90: 12 bf ff fc bne 2009b80 <_Heap_Walk+0x478>
2009b94: 80 a0 c0 19 cmp %g3, %i1
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
2009b98: 10 80 00 1b b 2009c04 <_Heap_Walk+0x4fc>
2009b9c: 15 00 80 72 sethi %hi(0x201c800), %o2
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
2009ba0: 80 a4 a0 00 cmp %l2, 0
2009ba4: 02 80 00 09 be 2009bc8 <_Heap_Walk+0x4c0>
2009ba8: 92 10 20 00 clr %o1
(*printer)(
2009bac: 15 00 80 72 sethi %hi(0x201c800), %o2
2009bb0: 96 10 00 19 mov %i1, %o3
2009bb4: 94 12 a0 f0 or %o2, 0xf0, %o2
2009bb8: 9f c7 40 00 call %i5
2009bbc: 98 10 00 14 mov %l4, %o4
2009bc0: 10 80 00 09 b 2009be4 <_Heap_Walk+0x4dc>
2009bc4: b2 10 00 13 mov %l3, %i1
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
2009bc8: da 06 40 00 ld [ %i1 ], %o5
2009bcc: 15 00 80 72 sethi %hi(0x201c800), %o2
2009bd0: 96 10 00 19 mov %i1, %o3
2009bd4: 94 12 a1 08 or %o2, 0x108, %o2
2009bd8: 9f c7 40 00 call %i5
2009bdc: 98 10 00 14 mov %l4, %o4
2009be0: b2 10 00 13 mov %l3, %i1
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
2009be4: 80 a4 c0 1a cmp %l3, %i2
2009be8: 32 bf ff 68 bne,a 2009988 <_Heap_Walk+0x280>
2009bec: e4 06 60 04 ld [ %i1 + 4 ], %l2
2009bf0: 10 80 00 02 b 2009bf8 <_Heap_Walk+0x4f0>
2009bf4: b0 10 20 01 mov 1, %i0
2009bf8: b0 0e 20 ff and %i0, 0xff, %i0
2009bfc: 81 c7 e0 08 ret
2009c00: 81 e8 00 00 restore
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
2009c04: 90 10 00 16 mov %l6, %o0
2009c08: 92 10 20 01 mov 1, %o1
2009c0c: 94 12 a1 30 or %o2, 0x130, %o2
2009c10: 96 10 00 19 mov %i1, %o3
2009c14: 9f c7 40 00 call %i5
2009c18: b0 10 20 00 clr %i0
2009c1c: b0 0e 20 ff and %i0, 0xff, %i0
2009c20: 81 c7 e0 08 ret
2009c24: 81 e8 00 00 restore
02008afc <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
2008afc: 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 );
2008b00: 13 00 80 2a sethi %hi(0x200a800), %o1
2008b04: 90 07 bf f4 add %fp, -12, %o0
2008b08: 92 12 63 b8 or %o1, 0x3b8, %o1
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
2008b0c: f0 27 bf f4 st %i0, [ %fp + -12 ]
2008b10: f2 2f bf f8 stb %i1, [ %fp + -8 ]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
2008b14: 40 00 08 34 call 200abe4 <_User_extensions_Iterate>
2008b18: 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;
2008b1c: 05 00 80 76 sethi %hi(0x201d800), %g2 <== NOT EXECUTED
2008b20: 82 10 a2 dc or %g2, 0x2dc, %g1 ! 201dadc <_Internal_errors_What_happened><== NOT EXECUTED
2008b24: f0 20 a2 dc st %i0, [ %g2 + 0x2dc ] <== NOT EXECUTED
_Internal_errors_What_happened.is_internal = is_internal;
2008b28: f2 28 60 04 stb %i1, [ %g1 + 4 ] <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
2008b2c: 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;
2008b30: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
2008b34: 03 00 80 76 sethi %hi(0x201d800), %g1 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
2008b38: 7f ff e6 a3 call 20025c4 <sparc_disable_interrupts> <== NOT EXECUTED
2008b3c: c4 20 62 e8 st %g2, [ %g1 + 0x2e8 ] ! 201dae8 <_System_state_Current><== NOT EXECUTED
2008b40: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
2008b44: 30 80 00 00 b,a 2008b44 <_Internal_error_Occurred+0x48> <== NOT EXECUTED
02008bb0 <_Objects_Allocate>:
#endif
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
2008bb0: 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 )
2008bb4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
2008bb8: 80 a0 60 00 cmp %g1, 0
2008bbc: 12 80 00 04 bne 2008bcc <_Objects_Allocate+0x1c> <== ALWAYS TAKEN
2008bc0: ba 10 00 18 mov %i0, %i5
return NULL;
2008bc4: 81 c7 e0 08 ret
2008bc8: 91 e8 20 00 restore %g0, 0, %o0
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
2008bcc: b8 06 20 20 add %i0, 0x20, %i4
2008bd0: 7f ff fd 85 call 20081e4 <_Chain_Get>
2008bd4: 90 10 00 1c mov %i4, %o0
if ( information->auto_extend ) {
2008bd8: c2 0f 60 12 ldub [ %i5 + 0x12 ], %g1
2008bdc: 80 a0 60 00 cmp %g1, 0
2008be0: 02 80 00 1d be 2008c54 <_Objects_Allocate+0xa4>
2008be4: 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 ) {
2008be8: 80 a2 20 00 cmp %o0, 0
2008bec: 32 80 00 0a bne,a 2008c14 <_Objects_Allocate+0x64>
2008bf0: c4 07 60 08 ld [ %i5 + 8 ], %g2
_Objects_Extend_information( information );
2008bf4: 40 00 00 21 call 2008c78 <_Objects_Extend_information>
2008bf8: 90 10 00 1d mov %i5, %o0
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
2008bfc: 7f ff fd 7a call 20081e4 <_Chain_Get>
2008c00: 90 10 00 1c mov %i4, %o0
}
if ( the_object ) {
2008c04: b0 92 20 00 orcc %o0, 0, %i0
2008c08: 02 bf ff ef be 2008bc4 <_Objects_Allocate+0x14>
2008c0c: 01 00 00 00 nop
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
2008c10: c4 07 60 08 ld [ %i5 + 8 ], %g2
2008c14: d0 06 20 08 ld [ %i0 + 8 ], %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
2008c18: d2 17 60 14 lduh [ %i5 + 0x14 ], %o1
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
2008c1c: 03 00 00 3f sethi %hi(0xfc00), %g1
2008c20: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2008c24: 90 0a 00 01 and %o0, %g1, %o0
2008c28: 82 08 80 01 and %g2, %g1, %g1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
2008c2c: 40 00 3e 2f call 20184e8 <.udiv>
2008c30: 90 22 00 01 sub %o0, %g1, %o0
information->inactive_per_block[ block ]--;
2008c34: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
2008c38: 91 2a 20 02 sll %o0, 2, %o0
2008c3c: c4 00 40 08 ld [ %g1 + %o0 ], %g2
2008c40: 84 00 bf ff add %g2, -1, %g2
2008c44: c4 20 40 08 st %g2, [ %g1 + %o0 ]
information->inactive--;
2008c48: c2 17 60 2c lduh [ %i5 + 0x2c ], %g1
2008c4c: 82 00 7f ff add %g1, -1, %g1
2008c50: c2 37 60 2c sth %g1, [ %i5 + 0x2c ]
);
}
#endif
return the_object;
}
2008c54: 81 c7 e0 08 ret
2008c58: 81 e8 00 00 restore
02008fe0 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
2008fe0: 9d e3 bf a0 save %sp, -96, %sp
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
2008fe4: 80 a6 60 00 cmp %i1, 0
2008fe8: 12 80 00 04 bne 2008ff8 <_Objects_Get_information+0x18>
2008fec: 01 00 00 00 nop
return NULL;
2008ff0: 81 c7 e0 08 ret
2008ff4: 91 e8 20 00 restore %g0, 0, %o0
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
2008ff8: 40 00 12 45 call 200d90c <_Objects_API_maximum_class>
2008ffc: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum == 0 )
2009000: 80 a2 20 00 cmp %o0, 0
2009004: 02 bf ff fb be 2008ff0 <_Objects_Get_information+0x10>
2009008: 80 a6 40 08 cmp %i1, %o0
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
200900c: 18 bf ff f9 bgu 2008ff0 <_Objects_Get_information+0x10>
2009010: 03 00 80 75 sethi %hi(0x201d400), %g1
return NULL;
if ( !_Objects_Information_table[ the_api ] )
2009014: b1 2e 20 02 sll %i0, 2, %i0
2009018: 82 10 61 34 or %g1, 0x134, %g1
200901c: c2 00 40 18 ld [ %g1 + %i0 ], %g1
2009020: 80 a0 60 00 cmp %g1, 0
2009024: 02 bf ff f3 be 2008ff0 <_Objects_Get_information+0x10> <== NEVER TAKEN
2009028: b3 2e 60 02 sll %i1, 2, %i1
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
200902c: f0 00 40 19 ld [ %g1 + %i1 ], %i0
if ( !info )
2009030: 80 a6 20 00 cmp %i0, 0
2009034: 02 bf ff ef be 2008ff0 <_Objects_Get_information+0x10> <== NEVER TAKEN
2009038: 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 )
200903c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
2009040: 80 a0 60 00 cmp %g1, 0
2009044: 02 bf ff eb be 2008ff0 <_Objects_Get_information+0x10>
2009048: 01 00 00 00 nop
return NULL;
#endif
return info;
}
200904c: 81 c7 e0 08 ret
2009050: 81 e8 00 00 restore
0201b3d8 <_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;
201b3d8: c2 02 20 08 ld [ %o0 + 8 ], %g1
201b3dc: 92 22 40 01 sub %o1, %g1, %o1
if ( information->maximum >= index ) {
201b3e0: 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;
201b3e4: 92 02 60 01 inc %o1
if ( information->maximum >= index ) {
201b3e8: 80 a0 40 09 cmp %g1, %o1
201b3ec: 0a 80 00 09 bcs 201b410 <_Objects_Get_no_protection+0x38>
201b3f0: 93 2a 60 02 sll %o1, 2, %o1
if ( (the_object = information->local_table[ index ]) != NULL ) {
201b3f4: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
201b3f8: d0 00 40 09 ld [ %g1 + %o1 ], %o0
201b3fc: 80 a2 20 00 cmp %o0, 0
201b400: 02 80 00 05 be 201b414 <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
201b404: 82 10 20 01 mov 1, %g1
*location = OBJECTS_LOCAL;
return the_object;
201b408: 81 c3 e0 08 retl
201b40c: 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;
201b410: 82 10 20 01 mov 1, %g1
return NULL;
201b414: 90 10 20 00 clr %o0
}
201b418: 81 c3 e0 08 retl
201b41c: c2 22 80 00 st %g1, [ %o2 ]
0200d0e8 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
200d0e8: 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;
200d0ec: 80 a6 20 00 cmp %i0, 0
200d0f0: 12 80 00 06 bne 200d108 <_Objects_Id_to_name+0x20>
200d0f4: 83 36 20 18 srl %i0, 0x18, %g1
200d0f8: 03 00 80 b7 sethi %hi(0x202dc00), %g1
200d0fc: c2 00 63 30 ld [ %g1 + 0x330 ], %g1 ! 202df30 <_Per_CPU_Information+0x10>
200d100: f0 00 60 08 ld [ %g1 + 8 ], %i0
200d104: 83 36 20 18 srl %i0, 0x18, %g1
200d108: 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 )
200d10c: 84 00 7f ff add %g1, -1, %g2
200d110: 80 a0 a0 02 cmp %g2, 2
200d114: 08 80 00 18 bleu 200d174 <_Objects_Id_to_name+0x8c>
200d118: 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;
200d11c: 81 c7 e0 08 ret
200d120: 91 e8 20 03 restore %g0, 3, %o0
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
200d124: 85 28 a0 02 sll %g2, 2, %g2
200d128: d0 00 40 02 ld [ %g1 + %g2 ], %o0
if ( !information )
200d12c: 80 a2 20 00 cmp %o0, 0
200d130: 02 bf ff fb be 200d11c <_Objects_Id_to_name+0x34> <== NEVER TAKEN
200d134: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
200d138: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
200d13c: 80 a0 60 00 cmp %g1, 0
200d140: 12 bf ff f7 bne 200d11c <_Objects_Id_to_name+0x34> <== NEVER TAKEN
200d144: 92 10 00 18 mov %i0, %o1
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
200d148: 7f ff ff cb call 200d074 <_Objects_Get>
200d14c: 94 07 bf fc add %fp, -4, %o2
if ( !the_object )
200d150: 80 a2 20 00 cmp %o0, 0
200d154: 02 bf ff f2 be 200d11c <_Objects_Id_to_name+0x34>
200d158: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
*name = the_object->name;
200d15c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
200d160: 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();
200d164: 40 00 03 d0 call 200e0a4 <_Thread_Enable_dispatch>
200d168: c2 26 40 00 st %g1, [ %i1 ]
200d16c: 81 c7 e0 08 ret
200d170: 81 e8 00 00 restore
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
200d174: 05 00 80 b6 sethi %hi(0x202d800), %g2
200d178: 84 10 a1 24 or %g2, 0x124, %g2 ! 202d924 <_Objects_Information_table>
200d17c: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200d180: 80 a0 60 00 cmp %g1, 0
200d184: 12 bf ff e8 bne 200d124 <_Objects_Id_to_name+0x3c>
200d188: 85 36 20 1b srl %i0, 0x1b, %g2
200d18c: 30 bf ff e4 b,a 200d11c <_Objects_Id_to_name+0x34>
0200ee88 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
200ee88: 9d e3 bf a0 save %sp, -96, %sp
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
200ee8c: 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 ];
200ee90: 39 00 00 3f sethi %hi(0xfc00), %i4
200ee94: b5 30 60 18 srl %g1, 0x18, %i2
200ee98: b8 17 23 ff or %i4, 0x3ff, %i4
200ee9c: b4 0e a0 07 and %i2, 7, %i2
200eea0: b8 08 40 1c and %g1, %i4, %i4
200eea4: b4 06 a0 04 add %i2, 4, %i2
200eea8: b9 2f 20 02 sll %i4, 2, %i4
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
200eeac: 37 00 80 76 sethi %hi(0x201d800), %i3
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
200eeb0: b5 2e a0 02 sll %i2, 2, %i2
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
200eeb4: 82 16 e1 bc or %i3, 0x1bc, %g1
done = true;
for ( index = 1 ; index <= max ; ++index ) {
200eeb8: ba 10 20 01 mov 1, %i5
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
200eebc: 84 10 20 01 mov 1, %g2
for ( index = 1 ; index <= max ; ++index ) {
200eec0: 10 80 00 18 b 200ef20 <_POSIX_Keys_Run_destructors+0x98>
200eec4: f2 10 60 10 lduh [ %g1 + 0x10 ], %i1
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
200eec8: 86 16 e1 bc or %i3, 0x1bc, %g3
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
200eecc: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
200eed0: 83 28 60 02 sll %g1, 2, %g1
200eed4: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
200eed8: 80 a0 60 00 cmp %g1, 0
200eedc: 22 80 00 11 be,a 200ef20 <_POSIX_Keys_Run_destructors+0x98>
200eee0: ba 07 60 01 inc %i5
200eee4: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
200eee8: 80 a0 e0 00 cmp %g3, 0
200eeec: 02 80 00 0c be 200ef1c <_POSIX_Keys_Run_destructors+0x94>
200eef0: 86 00 40 1a add %g1, %i2, %g3
void *value = key->Values [ thread_api ][ thread_index ];
200eef4: c6 00 e0 04 ld [ %g3 + 4 ], %g3
200eef8: d0 00 c0 1c ld [ %g3 + %i4 ], %o0
if ( value != NULL ) {
200eefc: 80 a2 20 00 cmp %o0, 0
200ef00: 22 80 00 08 be,a 200ef20 <_POSIX_Keys_Run_destructors+0x98><== ALWAYS TAKEN
200ef04: ba 07 60 01 inc %i5
key->Values [ thread_api ][ thread_index ] = NULL;
200ef08: c0 20 c0 1c clr [ %g3 + %i4 ] <== NOT EXECUTED
(*key->destructor)( value );
200ef0c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
200ef10: 9f c0 40 00 call %g1 <== NOT EXECUTED
200ef14: 01 00 00 00 nop <== NOT EXECUTED
done = false;
200ef18: 84 10 20 00 clr %g2 ! 0 <PROM_START> <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
200ef1c: ba 07 60 01 inc %i5
200ef20: 83 2f 60 10 sll %i5, 0x10, %g1
200ef24: 83 30 60 10 srl %g1, 0x10, %g1
200ef28: 80 a0 40 19 cmp %g1, %i1
200ef2c: 08 bf ff e7 bleu 200eec8 <_POSIX_Keys_Run_destructors+0x40>
200ef30: 80 88 a0 ff btst 0xff, %g2
* number of iterations. An infinite loop may happen if destructors set
* thread specific data. This can be considered dubious.
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
200ef34: 02 bf ff e1 be 200eeb8 <_POSIX_Keys_Run_destructors+0x30> <== NEVER TAKEN
200ef38: 82 16 e1 bc or %i3, 0x1bc, %g1
done = false;
}
}
}
}
}
200ef3c: 81 c7 e0 08 ret
200ef40: 81 e8 00 00 restore
0200c850 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
200c850: 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(
200c854: 11 00 80 a9 sethi %hi(0x202a400), %o0
200c858: 92 10 00 18 mov %i0, %o1
200c85c: 90 12 23 e0 or %o0, 0x3e0, %o0
200c860: 40 00 0c d5 call 200fbb4 <_Objects_Get>
200c864: 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 ) {
200c868: c2 07 bf f8 ld [ %fp + -8 ], %g1
200c86c: 80 a0 60 00 cmp %g1, 0
200c870: 12 80 00 40 bne 200c970 <_POSIX_Message_queue_Receive_support+0x120>
200c874: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
200c878: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200c87c: 84 08 60 03 and %g1, 3, %g2
200c880: 80 a0 a0 01 cmp %g2, 1
200c884: 32 80 00 05 bne,a 200c898 <_POSIX_Message_queue_Receive_support+0x48>
200c888: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
_Thread_Enable_dispatch();
200c88c: 40 00 10 a8 call 2010b2c <_Thread_Enable_dispatch>
200c890: 01 00 00 00 nop
200c894: 30 80 00 37 b,a 200c970 <_POSIX_Message_queue_Receive_support+0x120>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
200c898: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
200c89c: 80 a6 80 02 cmp %i2, %g2
200c8a0: 1a 80 00 08 bcc 200c8c0 <_POSIX_Message_queue_Receive_support+0x70>
200c8a4: 84 10 3f ff mov -1, %g2
_Thread_Enable_dispatch();
200c8a8: 40 00 10 a1 call 2010b2c <_Thread_Enable_dispatch>
200c8ac: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EMSGSIZE );
200c8b0: 40 00 28 1f call 201692c <__errno>
200c8b4: 01 00 00 00 nop
200c8b8: 10 80 00 31 b 200c97c <_POSIX_Message_queue_Receive_support+0x12c>
200c8bc: 82 10 20 7a mov 0x7a, %g1 ! 7a <PROM_START+0x7a>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
200c8c0: c4 27 bf fc st %g2, [ %fp + -4 ]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
200c8c4: 80 a7 20 00 cmp %i4, 0
200c8c8: 02 80 00 05 be 200c8dc <_POSIX_Message_queue_Receive_support+0x8c>
200c8cc: 98 10 20 00 clr %o4
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
200c8d0: 99 30 60 0e srl %g1, 0xe, %o4
200c8d4: 98 1b 20 01 xor %o4, 1, %o4
200c8d8: 98 0b 20 01 and %o4, 1, %o4
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
200c8dc: 90 02 20 1c add %o0, 0x1c, %o0
200c8e0: 92 10 00 18 mov %i0, %o1
200c8e4: 94 10 00 19 mov %i1, %o2
200c8e8: 96 07 bf fc add %fp, -4, %o3
200c8ec: 98 0b 20 01 and %o4, 1, %o4
200c8f0: 40 00 08 7e call 200eae8 <_CORE_message_queue_Seize>
200c8f4: 9a 10 00 1d mov %i5, %o5
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
200c8f8: 40 00 10 8d call 2010b2c <_Thread_Enable_dispatch>
200c8fc: 01 00 00 00 nop
if (msg_prio) {
200c900: 80 a6 e0 00 cmp %i3, 0
200c904: 02 80 00 08 be 200c924 <_POSIX_Message_queue_Receive_support+0xd4><== NEVER TAKEN
200c908: 03 00 80 aa sethi %hi(0x202a800), %g1
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
200c90c: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 ! 202a870 <_Per_CPU_Information+0x10>
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);
200c910: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
200c914: 83 38 a0 1f sra %g2, 0x1f, %g1
200c918: 84 18 40 02 xor %g1, %g2, %g2
200c91c: 82 20 80 01 sub %g2, %g1, %g1
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
200c920: c2 26 c0 00 st %g1, [ %i3 ]
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
200c924: 3b 00 80 aa sethi %hi(0x202a800), %i5
200c928: ba 17 60 60 or %i5, 0x60, %i5 ! 202a860 <_Per_CPU_Information>
200c92c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200c930: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
200c934: 80 a0 60 00 cmp %g1, 0
200c938: 12 80 00 05 bne 200c94c <_POSIX_Message_queue_Receive_support+0xfc>
200c93c: 01 00 00 00 nop
return length_out;
200c940: f0 07 bf fc ld [ %fp + -4 ], %i0
200c944: 81 c7 e0 08 ret
200c948: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one(
200c94c: 40 00 27 f8 call 201692c <__errno>
200c950: b0 10 3f ff mov -1, %i0
200c954: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200c958: b8 10 00 08 mov %o0, %i4
200c95c: 40 00 00 96 call 200cbb4 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
200c960: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
200c964: d0 27 00 00 st %o0, [ %i4 ]
200c968: 81 c7 e0 08 ret
200c96c: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
200c970: 40 00 27 ef call 201692c <__errno>
200c974: 01 00 00 00 nop
200c978: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
200c97c: c2 22 00 00 st %g1, [ %o0 ]
200c980: b0 10 3f ff mov -1, %i0
}
200c984: 81 c7 e0 08 ret
200c988: 81 e8 00 00 restore
0200ec78 <_POSIX_Semaphore_Create_support>:
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
200ec78: 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)
200ec7c: 80 a6 a0 00 cmp %i2, 0
200ec80: 22 80 00 06 be,a 200ec98 <_POSIX_Semaphore_Create_support+0x20>
200ec84: 03 00 80 88 sethi %hi(0x2022000), %g1
rtems_set_errno_and_return_minus_one( ENOSYS );
200ec88: 40 00 0a 42 call 2011590 <__errno>
200ec8c: 01 00 00 00 nop
200ec90: 10 80 00 10 b 200ecd0 <_POSIX_Semaphore_Create_support+0x58>
200ec94: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
200ec98: c4 00 60 90 ld [ %g1 + 0x90 ], %g2
++level;
200ec9c: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
200eca0: c4 20 60 90 st %g2, [ %g1 + 0x90 ]
* _POSIX_Semaphore_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
200eca4: 21 00 80 88 sethi %hi(0x2022000), %l0
200eca8: 7f ff ee d9 call 200a80c <_Objects_Allocate>
200ecac: 90 14 23 64 or %l0, 0x364, %o0 ! 2022364 <_POSIX_Semaphore_Information>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
200ecb0: ba 92 20 00 orcc %o0, 0, %i5
200ecb4: 12 80 00 0a bne 200ecdc <_POSIX_Semaphore_Create_support+0x64>
200ecb8: 80 a6 20 00 cmp %i0, 0
_Thread_Enable_dispatch();
200ecbc: 7f ff f4 0b call 200bce8 <_Thread_Enable_dispatch>
200ecc0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSPC );
200ecc4: 40 00 0a 33 call 2011590 <__errno>
200ecc8: 01 00 00 00 nop
200eccc: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c>
200ecd0: c2 22 00 00 st %g1, [ %o0 ]
200ecd4: 81 c7 e0 08 ret
200ecd8: 91 e8 3f ff restore %g0, -1, %o0
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
if ( name_arg != NULL ) {
200ecdc: 02 80 00 10 be 200ed1c <_POSIX_Semaphore_Create_support+0xa4>
200ece0: 90 10 00 18 mov %i0, %o0
name = _Workspace_String_duplicate( name_arg, name_len );
200ece4: 40 00 04 45 call 200fdf8 <_Workspace_String_duplicate>
200ece8: 92 10 00 19 mov %i1, %o1
if ( !name ) {
200ecec: b4 92 20 00 orcc %o0, 0, %i2
200ecf0: 12 80 00 0d bne 200ed24 <_POSIX_Semaphore_Create_support+0xac><== ALWAYS TAKEN
200ecf4: 80 a6 a0 00 cmp %i2, 0
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
200ecf8: 90 14 23 64 or %l0, 0x364, %o0 <== NOT EXECUTED
200ecfc: 7f ff ef a3 call 200ab88 <_Objects_Free> <== NOT EXECUTED
200ed00: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
200ed04: 7f ff f3 f9 call 200bce8 <_Thread_Enable_dispatch> <== NOT EXECUTED
200ed08: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
200ed0c: 40 00 0a 21 call 2011590 <__errno> <== NOT EXECUTED
200ed10: 01 00 00 00 nop <== NOT EXECUTED
200ed14: 10 bf ff ef b 200ecd0 <_POSIX_Semaphore_Create_support+0x58><== NOT EXECUTED
200ed18: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
}
} else {
name = NULL;
200ed1c: b4 10 20 00 clr %i2
}
the_semaphore->process_shared = pshared;
if ( name ) {
200ed20: 80 a6 a0 00 cmp %i2, 0
200ed24: 02 80 00 08 be 200ed44 <_POSIX_Semaphore_Create_support+0xcc>
200ed28: c0 27 60 10 clr [ %i5 + 0x10 ]
the_semaphore->named = true;
200ed2c: 82 10 20 01 mov 1, %g1
200ed30: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
the_semaphore->open_count = 1;
200ed34: 82 10 20 01 mov 1, %g1
200ed38: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
the_semaphore->linked = true;
200ed3c: 10 80 00 05 b 200ed50 <_POSIX_Semaphore_Create_support+0xd8>
200ed40: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
} else {
the_semaphore->named = false;
200ed44: c0 2f 60 14 clrb [ %i5 + 0x14 ]
the_semaphore->open_count = 0;
200ed48: c0 27 60 18 clr [ %i5 + 0x18 ]
the_semaphore->linked = false;
200ed4c: c0 2f 60 15 clrb [ %i5 + 0x15 ]
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
200ed50: 82 10 3f ff mov -1, %g1
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
200ed54: 90 07 60 1c add %i5, 0x1c, %o0
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
200ed58: c2 27 60 5c st %g1, [ %i5 + 0x5c ]
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
200ed5c: 92 07 60 5c add %i5, 0x5c, %o1
200ed60: 94 10 00 1b mov %i3, %o2
200ed64: 7f ff ed 1f call 200a1e0 <_CORE_semaphore_Initialize>
200ed68: c0 27 60 60 clr [ %i5 + 0x60 ]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
200ed6c: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200ed70: 05 00 80 88 sethi %hi(0x2022000), %g2
200ed74: c4 00 a3 80 ld [ %g2 + 0x380 ], %g2 ! 2022380 <_POSIX_Semaphore_Information+0x1c>
200ed78: 83 28 60 02 sll %g1, 2, %g1
200ed7c: 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;
200ed80: f4 27 60 0c st %i2, [ %i5 + 0xc ]
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
200ed84: fa 27 00 00 st %i5, [ %i4 ]
_Thread_Enable_dispatch();
200ed88: 7f ff f3 d8 call 200bce8 <_Thread_Enable_dispatch>
200ed8c: b0 10 20 00 clr %i0
return 0;
}
200ed90: 81 c7 e0 08 ret
200ed94: 81 e8 00 00 restore
0200c75c <_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 ];
200c75c: c2 02 21 5c ld [ %o0 + 0x15c ], %g1
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
200c760: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2
200c764: 80 a0 a0 00 cmp %g2, 0
200c768: 12 80 00 12 bne 200c7b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54><== NEVER TAKEN
200c76c: 01 00 00 00 nop
200c770: c4 00 60 dc ld [ %g1 + 0xdc ], %g2
200c774: 80 a0 a0 01 cmp %g2, 1
200c778: 12 80 00 0e bne 200c7b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54>
200c77c: 01 00 00 00 nop
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
200c780: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1
200c784: 80 a0 60 00 cmp %g1, 0
200c788: 02 80 00 0a be 200c7b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54>
200c78c: 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;
200c790: 03 00 80 76 sethi %hi(0x201d800), %g1
200c794: c4 00 62 30 ld [ %g1 + 0x230 ], %g2 ! 201da30 <_Thread_Dispatch_disable_level>
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
200c798: 92 10 3f ff mov -1, %o1
--level;
200c79c: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
200c7a0: c4 20 62 30 st %g2, [ %g1 + 0x230 ]
200c7a4: 82 13 c0 00 mov %o7, %g1
200c7a8: 40 00 01 b5 call 200ce7c <_POSIX_Thread_Exit>
200c7ac: 9e 10 40 00 mov %g1, %o7
} else
_Thread_Enable_dispatch();
200c7b0: 82 13 c0 00 mov %o7, %g1
200c7b4: 7f ff f6 54 call 200a104 <_Thread_Enable_dispatch>
200c7b8: 9e 10 40 00 mov %g1, %o7
0200db0c <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
200db0c: 9d e3 bf a0 save %sp, -96, %sp
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
200db10: 7f ff ff f4 call 200dae0 <_POSIX_Priority_Is_valid>
200db14: d0 06 40 00 ld [ %i1 ], %o0
200db18: 80 8a 20 ff btst 0xff, %o0
200db1c: 32 80 00 04 bne,a 200db2c <_POSIX_Thread_Translate_sched_param+0x20><== ALWAYS TAKEN
200db20: c0 26 80 00 clr [ %i2 ]
return EINVAL;
200db24: 81 c7 e0 08 ret
200db28: 91 e8 20 16 restore %g0, 0x16, %o0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
200db2c: 80 a6 20 00 cmp %i0, 0
200db30: 12 80 00 06 bne 200db48 <_POSIX_Thread_Translate_sched_param+0x3c>
200db34: c0 26 c0 00 clr [ %i3 ]
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
200db38: 82 10 20 01 mov 1, %g1
200db3c: c2 26 80 00 st %g1, [ %i2 ]
return 0;
200db40: 81 c7 e0 08 ret
200db44: 81 e8 00 00 restore
}
if ( policy == SCHED_FIFO ) {
200db48: 80 a6 20 01 cmp %i0, 1
200db4c: 02 80 00 29 be 200dbf0 <_POSIX_Thread_Translate_sched_param+0xe4>
200db50: 80 a6 20 02 cmp %i0, 2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
200db54: 12 80 00 04 bne 200db64 <_POSIX_Thread_Translate_sched_param+0x58>
200db58: 80 a6 20 04 cmp %i0, 4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
200db5c: 10 80 00 25 b 200dbf0 <_POSIX_Thread_Translate_sched_param+0xe4>
200db60: f0 26 80 00 st %i0, [ %i2 ]
return 0;
}
if ( policy == SCHED_SPORADIC ) {
200db64: 12 bf ff f0 bne 200db24 <_POSIX_Thread_Translate_sched_param+0x18>
200db68: 01 00 00 00 nop
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
200db6c: c2 06 60 08 ld [ %i1 + 8 ], %g1
200db70: 80 a0 60 00 cmp %g1, 0
200db74: 32 80 00 07 bne,a 200db90 <_POSIX_Thread_Translate_sched_param+0x84>
200db78: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200db7c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
200db80: 80 a0 60 00 cmp %g1, 0
200db84: 02 bf ff e8 be 200db24 <_POSIX_Thread_Translate_sched_param+0x18>
200db88: 01 00 00 00 nop
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
200db8c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200db90: 80 a0 60 00 cmp %g1, 0
200db94: 12 80 00 06 bne 200dbac <_POSIX_Thread_Translate_sched_param+0xa0>
200db98: 01 00 00 00 nop
200db9c: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
200dba0: 80 a0 60 00 cmp %g1, 0
200dba4: 02 bf ff e0 be 200db24 <_POSIX_Thread_Translate_sched_param+0x18>
200dba8: 01 00 00 00 nop
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
200dbac: 7f ff f7 6b call 200b958 <_Timespec_To_ticks>
200dbb0: 90 06 60 08 add %i1, 8, %o0
200dbb4: ba 10 00 08 mov %o0, %i5
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
200dbb8: 7f ff f7 68 call 200b958 <_Timespec_To_ticks>
200dbbc: 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 ) <
200dbc0: 80 a7 40 08 cmp %i5, %o0
200dbc4: 0a bf ff d8 bcs 200db24 <_POSIX_Thread_Translate_sched_param+0x18>
200dbc8: 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 ) )
200dbcc: 7f ff ff c5 call 200dae0 <_POSIX_Priority_Is_valid>
200dbd0: d0 06 60 04 ld [ %i1 + 4 ], %o0
200dbd4: 80 8a 20 ff btst 0xff, %o0
200dbd8: 02 bf ff d3 be 200db24 <_POSIX_Thread_Translate_sched_param+0x18>
200dbdc: 82 10 20 03 mov 3, %g1
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
200dbe0: c2 26 80 00 st %g1, [ %i2 ]
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
200dbe4: 03 00 80 1e sethi %hi(0x2007800), %g1
200dbe8: 82 10 63 f4 or %g1, 0x3f4, %g1 ! 2007bf4 <_POSIX_Threads_Sporadic_budget_callout>
200dbec: c2 26 c0 00 st %g1, [ %i3 ]
return 0;
}
return EINVAL;
}
200dbf0: 81 c7 e0 08 ret
200dbf4: 91 e8 20 00 restore %g0, 0, %o0
0200cac8 <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
200cac8: 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 ];
200cacc: f0 06 61 5c ld [ %i1 + 0x15c ], %i0
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
200cad0: 40 00 08 d4 call 200ee20 <_POSIX_Threads_cancel_run>
200cad4: 90 10 00 19 mov %i1, %o0
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
200cad8: 90 10 00 19 mov %i1, %o0
200cadc: 40 00 08 eb call 200ee88 <_POSIX_Keys_Run_destructors>
200cae0: 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 )) )
200cae4: 10 80 00 03 b 200caf0 <_POSIX_Threads_Delete_extension+0x28>
200cae8: f8 06 60 28 ld [ %i1 + 0x28 ], %i4
*(void **)the_thread->Wait.return_argument = value_ptr;
200caec: 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 )) )
200caf0: 7f ff f6 3f call 200a3ec <_Thread_queue_Dequeue>
200caf4: 90 10 00 1d mov %i5, %o0
200caf8: 80 a2 20 00 cmp %o0, 0
200cafc: 32 bf ff fc bne,a 200caec <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN
200cb00: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 <== NOT EXECUTED
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
200cb04: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
200cb08: 80 a0 60 04 cmp %g1, 4
200cb0c: 32 80 00 05 bne,a 200cb20 <_POSIX_Threads_Delete_extension+0x58>
200cb10: c0 26 61 5c clr [ %i1 + 0x15c ]
(void) _Watchdog_Remove( &api->Sporadic_timer );
200cb14: 7f ff f8 cc call 200ae44 <_Watchdog_Remove>
200cb18: 90 06 20 a8 add %i0, 0xa8, %o0
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
200cb1c: c0 26 61 5c clr [ %i1 + 0x15c ]
_Workspace_Free( api );
200cb20: 7f ff f9 6a call 200b0c8 <_Workspace_Free>
200cb24: 81 e8 00 00 restore
02007950 <_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)
{
2007950: 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;
2007954: 03 00 80 85 sethi %hi(0x2021400), %g1
2007958: 82 10 63 74 or %g1, 0x374, %g1 ! 2021774 <Configuration_POSIX_API>
maximum = Configuration_POSIX_API.number_of_initialization_threads;
200795c: f6 00 60 30 ld [ %g1 + 0x30 ], %i3
if ( !user_threads || maximum == 0 )
2007960: 80 a6 e0 00 cmp %i3, 0
2007964: 02 80 00 1d be 20079d8 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
2007968: fa 00 60 34 ld [ %g1 + 0x34 ], %i5
200796c: 80 a7 60 00 cmp %i5, 0
2007970: 02 80 00 1a be 20079d8 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
2007974: 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 );
2007978: 40 00 18 a0 call 200dbf8 <pthread_attr_init>
200797c: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
2007980: 92 10 20 02 mov 2, %o1
2007984: 40 00 18 a9 call 200dc28 <pthread_attr_setinheritsched>
2007988: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
200798c: d2 07 60 04 ld [ %i5 + 4 ], %o1
2007990: 40 00 18 b5 call 200dc64 <pthread_attr_setstacksize>
2007994: 90 07 bf c0 add %fp, -64, %o0
status = pthread_create(
2007998: d4 07 40 00 ld [ %i5 ], %o2
200799c: 90 07 bf bc add %fp, -68, %o0
20079a0: 92 07 bf c0 add %fp, -64, %o1
20079a4: 96 10 20 00 clr %o3
20079a8: 7f ff ff 18 call 2007608 <pthread_create>
20079ac: ba 07 60 08 add %i5, 8, %i5
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
20079b0: 80 a2 20 00 cmp %o0, 0
20079b4: 02 80 00 05 be 20079c8 <_POSIX_Threads_Initialize_user_threads_body+0x78>
20079b8: 94 10 00 08 mov %o0, %o2
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
20079bc: 90 10 20 02 mov 2, %o0
20079c0: 40 00 08 0a call 20099e8 <_Internal_error_Occurred>
20079c4: 92 10 20 01 mov 1, %o1
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
20079c8: b8 07 20 01 inc %i4
20079cc: 80 a7 00 1b cmp %i4, %i3
20079d0: 12 bf ff ea bne 2007978 <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN
20079d4: 01 00 00 00 nop
20079d8: 81 c7 e0 08 ret
20079dc: 81 e8 00 00 restore
0200cc1c <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
200cc1c: 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 ];
200cc20: 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 );
200cc24: 40 00 03 fd call 200dc18 <_Timespec_To_ticks>
200cc28: 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);
200cc2c: 03 00 80 72 sethi %hi(0x201c800), %g1
200cc30: d2 08 61 2c ldub [ %g1 + 0x12c ], %o1 ! 201c92c <rtems_maximum_priority>
200cc34: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
the_thread->cpu_time_budget = ticks;
200cc38: d0 26 60 74 st %o0, [ %i1 + 0x74 ]
200cc3c: 92 22 40 01 sub %o1, %g1, %o1
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
200cc40: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
200cc44: 80 a0 60 00 cmp %g1, 0
200cc48: 12 80 00 09 bne 200cc6c <_POSIX_Threads_Sporadic_budget_TSR+0x50><== NEVER TAKEN
200cc4c: 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 ) {
200cc50: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
200cc54: 80 a0 40 09 cmp %g1, %o1
200cc58: 08 80 00 06 bleu 200cc70 <_POSIX_Threads_Sporadic_budget_TSR+0x54>
200cc5c: 90 07 60 90 add %i5, 0x90, %o0
_Thread_Change_priority( the_thread, new_priority, true );
200cc60: 90 10 00 19 mov %i1, %o0
200cc64: 7f ff f3 c9 call 2009b88 <_Thread_Change_priority>
200cc68: 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 );
200cc6c: 90 07 60 90 add %i5, 0x90, %o0
200cc70: 40 00 03 ea call 200dc18 <_Timespec_To_ticks>
200cc74: 31 00 80 75 sethi %hi(0x201d400), %i0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
200cc78: b0 16 22 6c or %i0, 0x26c, %i0 ! 201d66c <_Watchdog_Ticks_chain>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
200cc7c: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
200cc80: 7f ff f8 19 call 200ace4 <_Watchdog_Insert>
200cc84: 93 ef 60 a8 restore %i5, 0xa8, %o1
0200cc88 <_POSIX_Threads_Sporadic_budget_callout>:
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200cc88: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
200cc8c: 86 10 3f ff mov -1, %g3
200cc90: c4 00 a0 8c ld [ %g2 + 0x8c ], %g2
200cc94: c6 22 20 74 st %g3, [ %o0 + 0x74 ]
200cc98: 07 00 80 72 sethi %hi(0x201c800), %g3
200cc9c: d2 08 e1 2c ldub [ %g3 + 0x12c ], %o1 ! 201c92c <rtems_maximum_priority>
200cca0: 92 22 40 02 sub %o1, %g2, %o1
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
200cca4: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
200cca8: 80 a0 a0 00 cmp %g2, 0
200ccac: 12 80 00 09 bne 200ccd0 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
200ccb0: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
/*
* Make sure we are actually lowering it. If they have lowered it
* to logically lower than sched_ss_low_priority, then we do not want to
* change it.
*/
if ( the_thread->current_priority < new_priority ) {
200ccb4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200ccb8: 80 a0 40 09 cmp %g1, %o1
200ccbc: 1a 80 00 05 bcc 200ccd0 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
200ccc0: 94 10 20 01 mov 1, %o2
_Thread_Change_priority( the_thread, new_priority, true );
200ccc4: 82 13 c0 00 mov %o7, %g1
200ccc8: 7f ff f3 b0 call 2009b88 <_Thread_Change_priority>
200cccc: 9e 10 40 00 mov %g1, %o7
200ccd0: 81 c3 e0 08 retl <== NOT EXECUTED
02007408 <_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)
{
2007408: 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;
200740c: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
2007410: 82 00 60 01 inc %g1
2007414: c2 26 60 68 st %g1, [ %i1 + 0x68 ]
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
2007418: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
200741c: 80 a0 60 00 cmp %g1, 0
2007420: 32 80 00 07 bne,a 200743c <_POSIX_Timer_TSR+0x34>
2007424: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
2007428: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
200742c: 80 a0 60 00 cmp %g1, 0
2007430: 02 80 00 1f be 20074ac <_POSIX_Timer_TSR+0xa4> <== NEVER TAKEN
2007434: 82 10 20 04 mov 4, %g1
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
2007438: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
200743c: d4 06 60 08 ld [ %i1 + 8 ], %o2
2007440: 90 06 60 10 add %i1, 0x10, %o0
2007444: 17 00 80 1d sethi %hi(0x2007400), %o3
2007448: 98 10 00 19 mov %i1, %o4
200744c: 40 00 18 3b call 200d538 <_POSIX_Timer_Insert_helper>
2007450: 96 12 e0 08 or %o3, 8, %o3
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
2007454: 80 8a 20 ff btst 0xff, %o0
2007458: 02 80 00 1a be 20074c0 <_POSIX_Timer_TSR+0xb8> <== NEVER TAKEN
200745c: 90 07 bf f8 add %fp, -8, %o0
2007460: 13 00 80 77 sethi %hi(0x201dc00), %o1
2007464: 40 00 05 ed call 2008c18 <_TOD_Get_with_nanoseconds>
2007468: 92 12 63 68 or %o1, 0x368, %o1 ! 201df68 <_TOD>
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
}
200746c: 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);
2007470: 94 10 20 00 clr %o2
2007474: 90 10 00 1c mov %i4, %o0
2007478: 92 10 00 1d mov %i5, %o1
200747c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007480: 40 00 48 66 call 2019618 <__divdi3>
2007484: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007488: 90 10 00 1c mov %i4, %o0
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
200748c: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007490: 94 10 20 00 clr %o2
2007494: 92 10 00 1d mov %i5, %o1
2007498: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
200749c: 40 00 49 4a call 20199c4 <__moddi3>
20074a0: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
20074a4: 82 10 20 03 mov 3, %g1
20074a8: d2 26 60 70 st %o1, [ %i1 + 0x70 ]
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
20074ac: d0 06 60 38 ld [ %i1 + 0x38 ], %o0
20074b0: d2 06 60 44 ld [ %i1 + 0x44 ], %o1
20074b4: 40 00 17 10 call 200d0f4 <pthread_kill>
20074b8: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
20074bc: c0 26 60 68 clr [ %i1 + 0x68 ]
20074c0: 81 c7 e0 08 ret
20074c4: 81 e8 00 00 restore
0200ef44 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
200ef44: 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,
200ef48: 98 10 20 01 mov 1, %o4
200ef4c: 90 10 00 18 mov %i0, %o0
200ef50: 92 10 00 19 mov %i1, %o1
200ef54: 94 07 bf cc add %fp, -52, %o2
200ef58: 40 00 00 2e call 200f010 <_POSIX_signals_Clear_signals>
200ef5c: 96 10 00 1a mov %i2, %o3
200ef60: 80 8a 20 ff btst 0xff, %o0
200ef64: 02 80 00 28 be 200f004 <_POSIX_signals_Check_signal+0xc0>
200ef68: 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 )
200ef6c: 85 2e 60 02 sll %i1, 2, %g2
200ef70: 35 00 80 76 sethi %hi(0x201d800), %i2
200ef74: b7 2e 60 04 sll %i1, 4, %i3
200ef78: b4 16 a3 50 or %i2, 0x350, %i2
200ef7c: b6 26 c0 02 sub %i3, %g2, %i3
200ef80: 84 06 80 1b add %i2, %i3, %g2
200ef84: fa 00 a0 08 ld [ %g2 + 8 ], %i5
200ef88: 80 a7 60 01 cmp %i5, 1
200ef8c: 02 80 00 1e be 200f004 <_POSIX_signals_Check_signal+0xc0> <== NEVER TAKEN
200ef90: 90 07 bf d8 add %fp, -40, %o0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
200ef94: f8 06 20 d0 ld [ %i0 + 0xd0 ], %i4
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
200ef98: c2 00 a0 04 ld [ %g2 + 4 ], %g1
200ef9c: 82 10 40 1c or %g1, %i4, %g1
200efa0: 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,
200efa4: 03 00 80 76 sethi %hi(0x201d800), %g1
200efa8: d2 00 63 00 ld [ %g1 + 0x300 ], %o1 ! 201db00 <_Per_CPU_Information+0x10>
200efac: 94 10 20 28 mov 0x28, %o2
200efb0: 40 00 04 00 call 200ffb0 <memcpy>
200efb4: 92 02 60 20 add %o1, 0x20, %o1
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
200efb8: c2 06 80 1b ld [ %i2 + %i3 ], %g1
200efbc: 80 a0 60 02 cmp %g1, 2
200efc0: 12 80 00 07 bne 200efdc <_POSIX_signals_Check_signal+0x98>
200efc4: 90 10 00 19 mov %i1, %o0
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
200efc8: 92 07 bf cc add %fp, -52, %o1
200efcc: 9f c7 40 00 call %i5
200efd0: 94 10 20 00 clr %o2
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
200efd4: 10 80 00 05 b 200efe8 <_POSIX_signals_Check_signal+0xa4>
200efd8: 03 00 80 76 sethi %hi(0x201d800), %g1
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
200efdc: 9f c7 40 00 call %i5
200efe0: 01 00 00 00 nop
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
200efe4: 03 00 80 76 sethi %hi(0x201d800), %g1
200efe8: d0 00 63 00 ld [ %g1 + 0x300 ], %o0 ! 201db00 <_Per_CPU_Information+0x10>
200efec: 92 07 bf d8 add %fp, -40, %o1
200eff0: 90 02 20 20 add %o0, 0x20, %o0
200eff4: 40 00 03 ef call 200ffb0 <memcpy>
200eff8: 94 10 20 28 mov 0x28, %o2
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
200effc: 82 10 20 01 mov 1, %g1
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
200f000: f8 26 20 d0 st %i4, [ %i0 + 0xd0 ]
return true;
}
200f004: b0 08 60 01 and %g1, 1, %i0
200f008: 81 c7 e0 08 ret
200f00c: 81 e8 00 00 restore
0200f5c8 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
200f5c8: 9d e3 bf a0 save %sp, -96, %sp
200f5cc: 82 06 3f ff add %i0, -1, %g1
200f5d0: ba 10 20 01 mov 1, %i5
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
200f5d4: 7f ff cb fc call 20025c4 <sparc_disable_interrupts>
200f5d8: bb 2f 40 01 sll %i5, %g1, %i5
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
200f5dc: 05 00 80 76 sethi %hi(0x201d800), %g2
200f5e0: 83 2e 20 02 sll %i0, 2, %g1
200f5e4: 84 10 a3 50 or %g2, 0x350, %g2
200f5e8: b1 2e 20 04 sll %i0, 4, %i0
200f5ec: 82 26 00 01 sub %i0, %g1, %g1
200f5f0: c4 00 80 01 ld [ %g2 + %g1 ], %g2
200f5f4: 80 a0 a0 02 cmp %g2, 2
200f5f8: 32 80 00 0c bne,a 200f628 <_POSIX_signals_Clear_process_signals+0x60>
200f5fc: 03 00 80 77 sethi %hi(0x201dc00), %g1
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
200f600: 05 00 80 77 sethi %hi(0x201dc00), %g2
200f604: 84 10 a1 48 or %g2, 0x148, %g2 ! 201dd48 <_POSIX_signals_Siginfo>
200f608: 86 00 40 02 add %g1, %g2, %g3
200f60c: c2 00 40 02 ld [ %g1 + %g2 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200f610: 86 00 e0 04 add %g3, 4, %g3
200f614: 80 a0 40 03 cmp %g1, %g3
200f618: 02 80 00 04 be 200f628 <_POSIX_signals_Clear_process_signals+0x60><== ALWAYS TAKEN
200f61c: 03 00 80 77 sethi %hi(0x201dc00), %g1
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
200f620: 7f ff cb ed call 20025d4 <sparc_enable_interrupts>
200f624: 91 e8 00 08 restore %g0, %o0, %o0
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
200f628: c4 00 61 44 ld [ %g1 + 0x144 ], %g2
200f62c: ba 28 80 1d andn %g2, %i5, %i5
200f630: 10 bf ff fc b 200f620 <_POSIX_signals_Clear_process_signals+0x58>
200f634: fa 20 61 44 st %i5, [ %g1 + 0x144 ]
02008200 <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
2008200: 82 10 20 1b mov 0x1b, %g1
2008204: 84 10 20 01 mov 1, %g2
#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(
2008208: 86 00 7f ff add %g1, -1, %g3
200820c: 87 28 80 03 sll %g2, %g3, %g3
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
2008210: 80 88 c0 08 btst %g3, %o0
2008214: 12 80 00 11 bne 2008258 <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
2008218: 01 00 00 00 nop
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
200821c: 82 00 60 01 inc %g1
2008220: 80 a0 60 20 cmp %g1, 0x20
2008224: 12 bf ff fa bne 200820c <_POSIX_signals_Get_lowest+0xc>
2008228: 86 00 7f ff add %g1, -1, %g3
200822c: 82 10 20 01 mov 1, %g1
2008230: 84 10 20 01 mov 1, %g2
#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(
2008234: 86 00 7f ff add %g1, -1, %g3
2008238: 87 28 80 03 sll %g2, %g3, %g3
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
200823c: 80 88 c0 08 btst %g3, %o0
2008240: 12 80 00 06 bne 2008258 <_POSIX_signals_Get_lowest+0x58>
2008244: 01 00 00 00 nop
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
2008248: 82 00 60 01 inc %g1
200824c: 80 a0 60 1b cmp %g1, 0x1b
2008250: 12 bf ff fa bne 2008238 <_POSIX_signals_Get_lowest+0x38> <== ALWAYS TAKEN
2008254: 86 00 7f ff add %g1, -1, %g3
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
2008258: 81 c3 e0 08 retl
200825c: 90 10 00 01 mov %g1, %o0
0200c854 <_POSIX_signals_Post_switch_hook>:
*/
static void _POSIX_signals_Post_switch_hook(
Thread_Control *the_thread
)
{
200c854: 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;
200c858: 03 00 80 76 sethi %hi(0x201d800), %g1
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200c85c: fa 06 21 5c ld [ %i0 + 0x15c ], %i5
/*
* 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;
200c860: c2 00 63 00 ld [ %g1 + 0x300 ], %g1
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
200c864: 80 a7 60 00 cmp %i5, 0
200c868: 02 80 00 11 be 200c8ac <_POSIX_signals_Post_switch_hook+0x58><== NEVER TAKEN
200c86c: f6 00 60 34 ld [ %g1 + 0x34 ], %i3
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
200c870: 35 00 80 77 sethi %hi(0x201dc00), %i2
*
* 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 );
200c874: 7f ff d7 54 call 20025c4 <sparc_disable_interrupts>
200c878: 01 00 00 00 nop
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
200c87c: c4 06 a1 44 ld [ %i2 + 0x144 ], %g2
200c880: c2 07 60 d4 ld [ %i5 + 0xd4 ], %g1
200c884: 82 10 80 01 or %g2, %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 &
200c888: c4 07 60 d0 ld [ %i5 + 0xd0 ], %g2
200c88c: 80 a8 40 02 andncc %g1, %g2, %g0
200c890: 12 80 00 09 bne 200c8b4 <_POSIX_signals_Post_switch_hook+0x60>
200c894: 01 00 00 00 nop
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
200c898: 7f ff d7 4f call 20025d4 <sparc_enable_interrupts>
200c89c: 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;
200c8a0: 03 00 80 76 sethi %hi(0x201d800), %g1
200c8a4: c2 00 63 00 ld [ %g1 + 0x300 ], %g1 ! 201db00 <_Per_CPU_Information+0x10>
200c8a8: f6 20 60 34 st %i3, [ %g1 + 0x34 ]
200c8ac: 81 c7 e0 08 ret
200c8b0: 81 e8 00 00 restore
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
200c8b4: 7f ff d7 48 call 20025d4 <sparc_enable_interrupts>
200c8b8: b8 10 20 1b mov 0x1b, %i4
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
200c8bc: 92 10 00 1c mov %i4, %o1
200c8c0: 94 10 20 00 clr %o2
200c8c4: 40 00 09 a0 call 200ef44 <_POSIX_signals_Check_signal>
200c8c8: 90 10 00 1d mov %i5, %o0
_POSIX_signals_Check_signal( api, signo, true );
200c8cc: 92 10 00 1c mov %i4, %o1
200c8d0: 90 10 00 1d mov %i5, %o0
200c8d4: 40 00 09 9c call 200ef44 <_POSIX_signals_Check_signal>
200c8d8: 94 10 20 01 mov 1, %o2
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
200c8dc: b8 07 20 01 inc %i4
200c8e0: 80 a7 20 20 cmp %i4, 0x20
200c8e4: 12 bf ff f7 bne 200c8c0 <_POSIX_signals_Post_switch_hook+0x6c>
200c8e8: 92 10 00 1c mov %i4, %o1
200c8ec: b8 10 20 01 mov 1, %i4
_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 );
200c8f0: 92 10 00 1c mov %i4, %o1
200c8f4: 94 10 20 00 clr %o2
200c8f8: 40 00 09 93 call 200ef44 <_POSIX_signals_Check_signal>
200c8fc: 90 10 00 1d mov %i5, %o0
_POSIX_signals_Check_signal( api, signo, true );
200c900: 92 10 00 1c mov %i4, %o1
200c904: 90 10 00 1d mov %i5, %o0
200c908: 40 00 09 8f call 200ef44 <_POSIX_signals_Check_signal>
200c90c: 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++ ) {
200c910: b8 07 20 01 inc %i4
200c914: 80 a7 20 1b cmp %i4, 0x1b
200c918: 12 bf ff f7 bne 200c8f4 <_POSIX_signals_Post_switch_hook+0xa0>
200c91c: 92 10 00 1c mov %i4, %o1
200c920: 30 bf ff d5 b,a 200c874 <_POSIX_signals_Post_switch_hook+0x20>
0201a2ac <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
201a2ac: 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 ) ) {
201a2b0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
201a2b4: 3b 04 00 20 sethi %hi(0x10008000), %i5
201a2b8: 84 06 7f ff add %i1, -1, %g2
201a2bc: 86 10 20 01 mov 1, %g3
201a2c0: b8 08 40 1d and %g1, %i5, %i4
{
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
201a2c4: c8 06 21 5c ld [ %i0 + 0x15c ], %g4
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
201a2c8: 80 a7 00 1d cmp %i4, %i5
201a2cc: 12 80 00 1e bne 201a344 <_POSIX_signals_Unblock_thread+0x98>
201a2d0: 85 28 c0 02 sll %g3, %g2, %g2
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
201a2d4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
201a2d8: 80 88 80 01 btst %g2, %g1
201a2dc: 12 80 00 08 bne 201a2fc <_POSIX_signals_Unblock_thread+0x50>
201a2e0: 82 10 20 04 mov 4, %g1
201a2e4: c2 01 20 d0 ld [ %g4 + 0xd0 ], %g1
201a2e8: 80 a8 80 01 andncc %g2, %g1, %g0
201a2ec: 32 80 00 04 bne,a 201a2fc <_POSIX_signals_Unblock_thread+0x50>
201a2f0: 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;
201a2f4: 10 80 00 3d b 201a3e8 <_POSIX_signals_Unblock_thread+0x13c>
201a2f8: b0 10 20 00 clr %i0
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
the_thread->Wait.return_code = EINTR;
201a2fc: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
201a300: 80 a6 a0 00 cmp %i2, 0
201a304: 12 80 00 07 bne 201a320 <_POSIX_signals_Unblock_thread+0x74>
201a308: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
201a30c: 82 10 20 01 mov 1, %g1
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
201a310: f2 22 00 00 st %i1, [ %o0 ]
the_info->si_code = SI_USER;
201a314: c2 22 20 04 st %g1, [ %o0 + 4 ]
the_info->si_value.sival_int = 0;
201a318: 10 80 00 05 b 201a32c <_POSIX_signals_Unblock_thread+0x80>
201a31c: c0 22 20 08 clr [ %o0 + 8 ]
} else {
*the_info = *info;
201a320: 92 10 00 1a mov %i2, %o1
201a324: 7f ff d7 23 call 200ffb0 <memcpy>
201a328: 94 10 20 0c mov 0xc, %o2
}
_Thread_queue_Extract_with_proxy( the_thread );
201a32c: 90 10 00 18 mov %i0, %o0
201a330: 7f ff c1 1c call 200a7a0 <_Thread_queue_Extract_with_proxy>
201a334: b0 10 20 01 mov 1, %i0
201a338: b0 0e 20 01 and %i0, 1, %i0
201a33c: 81 c7 e0 08 ret
201a340: 81 e8 00 00 restore
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
201a344: c8 01 20 d0 ld [ %g4 + 0xd0 ], %g4
201a348: 80 a8 80 04 andncc %g2, %g4, %g0
201a34c: 02 80 00 26 be 201a3e4 <_POSIX_signals_Unblock_thread+0x138>
201a350: 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 ) ) {
201a354: 80 88 40 02 btst %g1, %g2
201a358: 02 80 00 17 be 201a3b4 <_POSIX_signals_Unblock_thread+0x108>
201a35c: 80 a0 60 00 cmp %g1, 0
the_thread->Wait.return_code = EINTR;
201a360: 84 10 20 04 mov 4, %g2
201a364: c4 26 20 34 st %g2, [ %i0 + 0x34 ]
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
201a368: 05 00 00 ef sethi %hi(0x3bc00), %g2
201a36c: 84 10 a2 e0 or %g2, 0x2e0, %g2 ! 3bee0 <PROM_START+0x3bee0>
201a370: 80 88 40 02 btst %g1, %g2
201a374: 02 80 00 06 be 201a38c <_POSIX_signals_Unblock_thread+0xe0>
201a378: 80 88 60 08 btst 8, %g1
_Thread_queue_Extract_with_proxy( the_thread );
201a37c: 7f ff c1 09 call 200a7a0 <_Thread_queue_Extract_with_proxy>
201a380: 90 10 00 18 mov %i0, %o0
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
201a384: 10 80 00 19 b 201a3e8 <_POSIX_signals_Unblock_thread+0x13c>
201a388: b0 10 20 00 clr %i0
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
201a38c: 22 80 00 17 be,a 201a3e8 <_POSIX_signals_Unblock_thread+0x13c><== NEVER TAKEN
201a390: b0 10 20 00 clr %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
201a394: 7f ff c2 ac call 200ae44 <_Watchdog_Remove>
201a398: 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 );
201a39c: 90 10 00 18 mov %i0, %o0
201a3a0: 13 04 01 ff sethi %hi(0x1007fc00), %o1
201a3a4: 7f ff be 3d call 2009c98 <_Thread_Clear_state>
201a3a8: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1007fff8 <RAM_END+0xdc7fff8>
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
201a3ac: 10 80 00 0f b 201a3e8 <_POSIX_signals_Unblock_thread+0x13c>
201a3b0: b0 10 20 00 clr %i0
else if ( _States_Is_delaying(the_thread->current_state) ) {
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
201a3b4: 32 80 00 0d bne,a 201a3e8 <_POSIX_signals_Unblock_thread+0x13c><== NEVER TAKEN
201a3b8: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
201a3bc: 03 00 80 76 sethi %hi(0x201d800), %g1
201a3c0: 82 10 62 f0 or %g1, 0x2f0, %g1 ! 201daf0 <_Per_CPU_Information>
201a3c4: c4 00 60 08 ld [ %g1 + 8 ], %g2
201a3c8: 80 a0 a0 00 cmp %g2, 0
201a3cc: 22 80 00 07 be,a 201a3e8 <_POSIX_signals_Unblock_thread+0x13c>
201a3d0: b0 10 20 00 clr %i0
201a3d4: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
201a3d8: 80 a6 00 02 cmp %i0, %g2
201a3dc: 22 80 00 02 be,a 201a3e4 <_POSIX_signals_Unblock_thread+0x138><== ALWAYS TAKEN
201a3e0: c6 28 60 0c stb %g3, [ %g1 + 0xc ]
_Thread_Dispatch_necessary = true;
}
}
return false;
201a3e4: b0 10 20 00 clr %i0
}
201a3e8: b0 0e 20 01 and %i0, 1, %i0
201a3ec: 81 c7 e0 08 ret
201a3f0: 81 e8 00 00 restore
0200a1f0 <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
200a1f0: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
200a1f4: 80 a6 60 00 cmp %i1, 0
200a1f8: 02 80 00 69 be 200a39c <_RBTree_Extract_unprotected+0x1ac>
200a1fc: 01 00 00 00 nop
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
200a200: c2 06 20 08 ld [ %i0 + 8 ], %g1
200a204: 80 a6 40 01 cmp %i1, %g1
200a208: 32 80 00 07 bne,a 200a224 <_RBTree_Extract_unprotected+0x34>
200a20c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_RIGHT );
200a210: 90 10 00 19 mov %i1, %o0
200a214: 40 00 01 31 call 200a6d8 <_RBTree_Next_unprotected>
200a218: 92 10 20 01 mov 1, %o1
RBTree_Node *next;
next = _RBTree_Successor_unprotected(the_node);
the_rbtree->first[RBT_LEFT] = next;
200a21c: d0 26 20 08 st %o0, [ %i0 + 8 ]
}
/* Check if max needs to be updated. min=max for 1 element trees so
* do not use else if here. */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
200a220: c2 06 20 0c ld [ %i0 + 0xc ], %g1
200a224: 80 a6 40 01 cmp %i1, %g1
200a228: 32 80 00 07 bne,a 200a244 <_RBTree_Extract_unprotected+0x54>
200a22c: fa 06 60 04 ld [ %i1 + 4 ], %i5
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_LEFT );
200a230: 90 10 00 19 mov %i1, %o0
200a234: 40 00 01 29 call 200a6d8 <_RBTree_Next_unprotected>
200a238: 92 10 20 00 clr %o1
RBTree_Node *previous;
previous = _RBTree_Predecessor_unprotected(the_node);
the_rbtree->first[RBT_RIGHT] = previous;
200a23c: d0 26 20 0c st %o0, [ %i0 + 0xc ]
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
200a240: fa 06 60 04 ld [ %i1 + 4 ], %i5
200a244: 80 a7 60 00 cmp %i5, 0
200a248: 02 80 00 36 be 200a320 <_RBTree_Extract_unprotected+0x130>
200a24c: f8 06 60 08 ld [ %i1 + 8 ], %i4
200a250: 80 a7 20 00 cmp %i4, 0
200a254: 32 80 00 05 bne,a 200a268 <_RBTree_Extract_unprotected+0x78>
200a258: c2 07 60 08 ld [ %i5 + 8 ], %g1
200a25c: 10 80 00 35 b 200a330 <_RBTree_Extract_unprotected+0x140>
200a260: 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];
200a264: c2 07 60 08 ld [ %i5 + 8 ], %g1
200a268: 80 a0 60 00 cmp %g1, 0
200a26c: 32 bf ff fe bne,a 200a264 <_RBTree_Extract_unprotected+0x74>
200a270: 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];
200a274: f8 07 60 04 ld [ %i5 + 4 ], %i4
if(leaf) {
200a278: 80 a7 20 00 cmp %i4, 0
200a27c: 02 80 00 05 be 200a290 <_RBTree_Extract_unprotected+0xa0>
200a280: 01 00 00 00 nop
leaf->parent = target->parent;
200a284: c2 07 40 00 ld [ %i5 ], %g1
200a288: 10 80 00 04 b 200a298 <_RBTree_Extract_unprotected+0xa8>
200a28c: c2 27 00 00 st %g1, [ %i4 ]
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
200a290: 7f ff ff 73 call 200a05c <_RBTree_Extract_validate_unprotected>
200a294: 90 10 00 1d mov %i5, %o0
}
victim_color = target->color;
dir = target != target->parent->child[0];
200a298: c4 07 40 00 ld [ %i5 ], %g2
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
200a29c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
dir = target != target->parent->child[0];
200a2a0: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a2a4: 86 1f 40 03 xor %i5, %g3, %g3
200a2a8: 80 a0 00 03 cmp %g0, %g3
200a2ac: 86 40 20 00 addx %g0, 0, %g3
target->parent->child[dir] = leaf;
200a2b0: 87 28 e0 02 sll %g3, 2, %g3
200a2b4: 84 00 80 03 add %g2, %g3, %g2
200a2b8: f8 20 a0 04 st %i4, [ %g2 + 4 ]
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
200a2bc: c4 06 40 00 ld [ %i1 ], %g2
200a2c0: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a2c4: 86 1e 40 03 xor %i1, %g3, %g3
200a2c8: 80 a0 00 03 cmp %g0, %g3
200a2cc: 86 40 20 00 addx %g0, 0, %g3
the_node->parent->child[dir] = target;
200a2d0: 87 28 e0 02 sll %g3, 2, %g3
200a2d4: 84 00 80 03 add %g2, %g3, %g2
200a2d8: fa 20 a0 04 st %i5, [ %g2 + 4 ]
/* set target's new children to the original node's children */
target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];
200a2dc: c4 06 60 08 ld [ %i1 + 8 ], %g2
200a2e0: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (the_node->child[RBT_RIGHT])
200a2e4: c4 06 60 08 ld [ %i1 + 8 ], %g2
200a2e8: 80 a0 a0 00 cmp %g2, 0
200a2ec: 32 80 00 02 bne,a 200a2f4 <_RBTree_Extract_unprotected+0x104><== ALWAYS TAKEN
200a2f0: fa 20 80 00 st %i5, [ %g2 ]
the_node->child[RBT_RIGHT]->parent = target;
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
200a2f4: c4 06 60 04 ld [ %i1 + 4 ], %g2
200a2f8: c4 27 60 04 st %g2, [ %i5 + 4 ]
if (the_node->child[RBT_LEFT])
200a2fc: c4 06 60 04 ld [ %i1 + 4 ], %g2
200a300: 80 a0 a0 00 cmp %g2, 0
200a304: 32 80 00 02 bne,a 200a30c <_RBTree_Extract_unprotected+0x11c>
200a308: fa 20 80 00 st %i5, [ %g2 ]
/* finally, update the parent node and recolor. target has completely
* replaced the_node, and target's child has moved up the tree if needed.
* the_node is no longer part of the tree, although it has valid pointers
* still.
*/
target->parent = the_node->parent;
200a30c: c4 06 40 00 ld [ %i1 ], %g2
200a310: c4 27 40 00 st %g2, [ %i5 ]
target->color = the_node->color;
200a314: c4 06 60 0c ld [ %i1 + 0xc ], %g2
200a318: 10 80 00 14 b 200a368 <_RBTree_Extract_unprotected+0x178>
200a31c: c4 27 60 0c st %g2, [ %i5 + 0xc ]
* violated. We will fix it later.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
if( leaf ) {
200a320: 80 a7 20 00 cmp %i4, 0
200a324: 32 80 00 04 bne,a 200a334 <_RBTree_Extract_unprotected+0x144>
200a328: c2 06 40 00 ld [ %i1 ], %g1
200a32c: 30 80 00 04 b,a 200a33c <_RBTree_Extract_unprotected+0x14c>
leaf->parent = the_node->parent;
200a330: c2 06 40 00 ld [ %i1 ], %g1
200a334: 10 80 00 04 b 200a344 <_RBTree_Extract_unprotected+0x154>
200a338: c2 27 00 00 st %g1, [ %i4 ]
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
200a33c: 7f ff ff 48 call 200a05c <_RBTree_Extract_validate_unprotected>
200a340: 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];
200a344: c4 06 40 00 ld [ %i1 ], %g2
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
200a348: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
200a34c: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a350: 86 1e 40 03 xor %i1, %g3, %g3
200a354: 80 a0 00 03 cmp %g0, %g3
200a358: 86 40 20 00 addx %g0, 0, %g3
the_node->parent->child[dir] = leaf;
200a35c: 87 28 e0 02 sll %g3, 2, %g3
200a360: 84 00 80 03 add %g2, %g3, %g2
200a364: f8 20 a0 04 st %i4, [ %g2 + 4 ]
/* fix coloring. leaf has moved up the tree. The color of the deleted
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
200a368: 80 a0 60 00 cmp %g1, 0
200a36c: 32 80 00 06 bne,a 200a384 <_RBTree_Extract_unprotected+0x194>
200a370: c2 06 20 04 ld [ %i0 + 4 ], %g1
if (leaf) {
200a374: 80 a7 20 00 cmp %i4, 0
200a378: 32 80 00 02 bne,a 200a380 <_RBTree_Extract_unprotected+0x190>
200a37c: 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;
200a380: 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;
200a384: c0 26 60 08 clr [ %i1 + 8 ]
200a388: c0 26 60 04 clr [ %i1 + 4 ]
200a38c: 80 a0 60 00 cmp %g1, 0
200a390: 02 80 00 03 be 200a39c <_RBTree_Extract_unprotected+0x1ac>
200a394: c0 26 40 00 clr [ %i1 ]
200a398: c0 20 60 0c clr [ %g1 + 0xc ]
200a39c: 81 c7 e0 08 ret
200a3a0: 81 e8 00 00 restore
0200b3e4 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
200b3e4: 9d e3 bf a0 save %sp, -96, %sp
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
200b3e8: 80 a6 20 00 cmp %i0, 0
200b3ec: 02 80 00 10 be 200b42c <_RBTree_Initialize+0x48> <== NEVER TAKEN
200b3f0: 01 00 00 00 nop
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
200b3f4: c0 26 00 00 clr [ %i0 ]
the_rbtree->root = NULL;
200b3f8: c0 26 20 04 clr [ %i0 + 4 ]
the_rbtree->first[0] = NULL;
200b3fc: c0 26 20 08 clr [ %i0 + 8 ]
the_rbtree->first[1] = NULL;
200b400: c0 26 20 0c clr [ %i0 + 0xc ]
the_rbtree->compare_function = compare_function;
200b404: 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-- ) {
200b408: 10 80 00 06 b 200b420 <_RBTree_Initialize+0x3c>
200b40c: fa 2e 20 14 stb %i5, [ %i0 + 0x14 ]
_RBTree_Insert_unprotected(the_rbtree, next);
200b410: 90 10 00 18 mov %i0, %o0
200b414: 7f ff ff 2e call 200b0cc <_RBTree_Insert_unprotected>
200b418: b4 06 80 1c add %i2, %i4, %i2
200b41c: b6 06 ff ff add %i3, -1, %i3
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
200b420: 80 a6 e0 00 cmp %i3, 0
200b424: 12 bf ff fb bne 200b410 <_RBTree_Initialize+0x2c>
200b428: 92 10 00 1a mov %i2, %o1
200b42c: 81 c7 e0 08 ret
200b430: 81 e8 00 00 restore
0200a444 <_RBTree_Insert_unprotected>:
*/
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
200a444: 9d e3 bf a0 save %sp, -96, %sp
if(!the_node) return (RBTree_Node*)-1;
200a448: 80 a6 60 00 cmp %i1, 0
200a44c: 02 80 00 7c be 200a63c <_RBTree_Insert_unprotected+0x1f8>
200a450: ba 10 00 18 mov %i0, %i5
RBTree_Node *iter_node = the_rbtree->root;
200a454: f0 06 20 04 ld [ %i0 + 4 ], %i0
int compare_result;
if (!iter_node) { /* special case: first node inserted */
200a458: b6 96 20 00 orcc %i0, 0, %i3
200a45c: 32 80 00 0c bne,a 200a48c <_RBTree_Insert_unprotected+0x48>
200a460: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
the_node->color = RBT_BLACK;
200a464: c0 26 60 0c clr [ %i1 + 0xc ]
the_rbtree->root = the_node;
200a468: f2 27 60 04 st %i1, [ %i5 + 4 ]
the_rbtree->first[0] = the_rbtree->first[1] = the_node;
200a46c: f2 27 60 0c st %i1, [ %i5 + 0xc ]
200a470: f2 27 60 08 st %i1, [ %i5 + 8 ]
the_node->parent = (RBTree_Node *) the_rbtree;
200a474: fa 26 40 00 st %i5, [ %i1 ]
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
200a478: c0 26 60 08 clr [ %i1 + 8 ]
200a47c: c0 26 60 04 clr [ %i1 + 4 ]
200a480: 81 c7 e0 08 ret
200a484: 81 e8 00 00 restore
} else {
/* typical binary search tree insert, descend tree to leaf and insert */
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
200a488: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200a48c: 90 10 00 19 mov %i1, %o0
200a490: 9f c0 40 00 call %g1
200a494: 92 10 00 18 mov %i0, %o1
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
200a498: c2 0f 60 14 ldub [ %i5 + 0x14 ], %g1
200a49c: 80 a0 60 00 cmp %g1, 0
200a4a0: 02 80 00 05 be 200a4b4 <_RBTree_Insert_unprotected+0x70>
200a4a4: b8 38 00 08 xnor %g0, %o0, %i4
200a4a8: 80 a2 20 00 cmp %o0, 0
200a4ac: 02 80 00 65 be 200a640 <_RBTree_Insert_unprotected+0x1fc>
200a4b0: 01 00 00 00 nop
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
200a4b4: b9 37 20 1f srl %i4, 0x1f, %i4
if (!iter_node->child[dir]) {
200a4b8: 83 2f 20 02 sll %i4, 2, %g1
200a4bc: 82 06 00 01 add %i0, %g1, %g1
200a4c0: f0 00 60 04 ld [ %g1 + 4 ], %i0
200a4c4: 80 a6 20 00 cmp %i0, 0
200a4c8: 32 bf ff f0 bne,a 200a488 <_RBTree_Insert_unprotected+0x44>
200a4cc: b6 10 00 18 mov %i0, %i3
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
200a4d0: c0 26 60 08 clr [ %i1 + 8 ]
200a4d4: c0 26 60 04 clr [ %i1 + 4 ]
the_node->color = RBT_RED;
200a4d8: 84 10 20 01 mov 1, %g2
iter_node->child[dir] = the_node;
200a4dc: 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;
200a4e0: c4 26 60 0c st %g2, [ %i1 + 0xc ]
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
200a4e4: f6 26 40 00 st %i3, [ %i1 ]
/* update min/max */
compare_result = the_rbtree->compare_function(
200a4e8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
200a4ec: b6 07 20 02 add %i4, 2, %i3
200a4f0: 85 2e e0 02 sll %i3, 2, %g2
200a4f4: d2 07 40 02 ld [ %i5 + %g2 ], %o1
200a4f8: 9f c0 40 00 call %g1
200a4fc: 90 10 00 19 mov %i1, %o0
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
200a500: 80 a7 20 00 cmp %i4, 0
200a504: 12 80 00 06 bne 200a51c <_RBTree_Insert_unprotected+0xd8>
200a508: 80 a2 20 00 cmp %o0, 0
200a50c: 36 80 00 3c bge,a 200a5fc <_RBTree_Insert_unprotected+0x1b8>
200a510: d0 06 40 00 ld [ %i1 ], %o0
(dir && _RBTree_Is_greater(compare_result)) ) {
the_rbtree->first[dir] = the_node;
200a514: 10 80 00 04 b 200a524 <_RBTree_Insert_unprotected+0xe0>
200a518: b7 2e e0 02 sll %i3, 2, %i3
compare_result = the_rbtree->compare_function(
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
(dir && _RBTree_Is_greater(compare_result)) ) {
200a51c: 04 80 00 37 ble 200a5f8 <_RBTree_Insert_unprotected+0x1b4>
200a520: b7 2e e0 02 sll %i3, 2, %i3
the_rbtree->first[dir] = the_node;
200a524: 10 80 00 35 b 200a5f8 <_RBTree_Insert_unprotected+0x1b4>
200a528: f2 27 40 1b st %i1, [ %i5 + %i3 ]
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
200a52c: 02 80 00 13 be 200a578 <_RBTree_Insert_unprotected+0x134> <== NEVER TAKEN
200a530: 82 10 20 00 clr %g1
if(!(the_node->parent->parent->parent)) return NULL;
200a534: c2 07 40 00 ld [ %i5 ], %g1
200a538: 80 a0 60 00 cmp %g1, 0
200a53c: 02 80 00 0f be 200a578 <_RBTree_Insert_unprotected+0x134> <== NEVER TAKEN
200a540: 82 10 20 00 clr %g1
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
200a544: c2 07 60 04 ld [ %i5 + 4 ], %g1
200a548: 80 a2 00 01 cmp %o0, %g1
200a54c: 22 80 00 02 be,a 200a554 <_RBTree_Insert_unprotected+0x110>
200a550: c2 07 60 08 ld [ %i5 + 8 ], %g1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
200a554: 80 a0 60 00 cmp %g1, 0
200a558: 02 80 00 09 be 200a57c <_RBTree_Insert_unprotected+0x138>
200a55c: 84 10 20 00 clr %g2
200a560: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200a564: 80 a0 a0 01 cmp %g2, 1
200a568: 32 80 00 05 bne,a 200a57c <_RBTree_Insert_unprotected+0x138>
200a56c: 84 10 20 00 clr %g2
200a570: 10 80 00 03 b 200a57c <_RBTree_Insert_unprotected+0x138>
200a574: 84 10 20 01 mov 1, %g2
200a578: 84 10 20 00 clr %g2 <== NOT EXECUTED
while (_RBTree_Is_red(_RBTree_Parent(the_node))) {
u = _RBTree_Parent_sibling(the_node);
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
200a57c: 80 a0 a0 00 cmp %g2, 0
200a580: 22 80 00 08 be,a 200a5a0 <_RBTree_Insert_unprotected+0x15c>
200a584: c2 07 60 04 ld [ %i5 + 4 ], %g1
the_node->parent->color = RBT_BLACK;
200a588: c0 22 20 0c clr [ %o0 + 0xc ]
u->color = RBT_BLACK;
200a58c: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
200a590: b2 10 00 1d mov %i5, %i1
200a594: 82 10 20 01 mov 1, %g1
200a598: 10 80 00 18 b 200a5f8 <_RBTree_Insert_unprotected+0x1b4>
200a59c: c2 27 60 0c st %g1, [ %i5 + 0xc ]
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
RBTree_Direction pdir = the_node->parent != g->child[0];
200a5a0: 82 1a 00 01 xor %o0, %g1, %g1
200a5a4: 80 a0 00 01 cmp %g0, %g1
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
200a5a8: c2 02 20 04 ld [ %o0 + 4 ], %g1
RBTree_Direction pdir = the_node->parent != g->child[0];
200a5ac: b8 40 20 00 addx %g0, 0, %i4
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
200a5b0: 82 1e 40 01 xor %i1, %g1, %g1
200a5b4: 80 a0 00 01 cmp %g0, %g1
200a5b8: 82 40 20 00 addx %g0, 0, %g1
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
200a5bc: 80 a0 40 1c cmp %g1, %i4
200a5c0: 22 80 00 08 be,a 200a5e0 <_RBTree_Insert_unprotected+0x19c>
200a5c4: c2 06 40 00 ld [ %i1 ], %g1
_RBTree_Rotate(the_node->parent, pdir);
200a5c8: 7f ff ff 80 call 200a3c8 <_RBTree_Rotate>
200a5cc: 92 10 00 1c mov %i4, %o1
the_node = the_node->child[pdir];
200a5d0: 83 2f 20 02 sll %i4, 2, %g1
200a5d4: b2 06 40 01 add %i1, %g1, %i1
200a5d8: f2 06 60 04 ld [ %i1 + 4 ], %i1
}
the_node->parent->color = RBT_BLACK;
200a5dc: c2 06 40 00 ld [ %i1 ], %g1
g->color = RBT_RED;
200a5e0: 92 10 20 01 mov 1, %o1
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
}
the_node->parent->color = RBT_BLACK;
200a5e4: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
200a5e8: d2 27 60 0c st %o1, [ %i5 + 0xc ]
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
200a5ec: 90 10 00 1d mov %i5, %o0
200a5f0: 7f ff ff 76 call 200a3c8 <_RBTree_Rotate>
200a5f4: 92 22 40 1c sub %o1, %i4, %o1
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
200a5f8: d0 06 40 00 ld [ %i1 ], %o0
200a5fc: fa 02 00 00 ld [ %o0 ], %i5
200a600: 80 a7 60 00 cmp %i5, 0
200a604: 22 80 00 06 be,a 200a61c <_RBTree_Insert_unprotected+0x1d8>
200a608: 82 10 20 00 clr %g1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
200a60c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
200a610: 82 18 60 01 xor %g1, 1, %g1
200a614: 80 a0 00 01 cmp %g0, %g1
200a618: 82 60 3f ff subx %g0, -1, %g1
RBTree_Node *u,*g;
/* note: the insert root case is handled already */
/* if the parent is black, nothing needs to be done
* otherwise may need to loop a few times */
while (_RBTree_Is_red(_RBTree_Parent(the_node))) {
200a61c: 80 a0 60 00 cmp %g1, 0
200a620: 12 bf ff c3 bne 200a52c <_RBTree_Insert_unprotected+0xe8>
200a624: 80 a7 60 00 cmp %i5, 0
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
200a628: 12 80 00 06 bne 200a640 <_RBTree_Insert_unprotected+0x1fc>
200a62c: 01 00 00 00 nop
200a630: c0 26 60 0c clr [ %i1 + 0xc ]
200a634: 81 c7 e0 08 ret
200a638: 81 e8 00 00 restore
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
if(!the_node) return (RBTree_Node*)-1;
200a63c: b0 10 3f ff mov -1, %i0
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
200a640: 81 c7 e0 08 ret
200a644: 81 e8 00 00 restore
0200a678 <_RBTree_Iterate_unprotected>:
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
200a678: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
200a67c: b8 10 20 00 clr %i4
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
200a680: 80 a0 00 19 cmp %g0, %i1
200a684: 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];
200a688: 82 00 60 02 add %g1, 2, %g1
200a68c: 83 28 60 02 sll %g1, 2, %g1
while ( !stop && current != NULL ) {
200a690: 10 80 00 0a b 200a6b8 <_RBTree_Iterate_unprotected+0x40>
200a694: fa 06 00 01 ld [ %i0 + %g1 ], %i5
stop = (*visitor)( current, dir, visitor_arg );
200a698: 92 10 00 19 mov %i1, %o1
200a69c: 9f c6 80 00 call %i2
200a6a0: 94 10 00 1b mov %i3, %o2
current = _RBTree_Next_unprotected( current, dir );
200a6a4: 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 );
200a6a8: b8 10 00 08 mov %o0, %i4
current = _RBTree_Next_unprotected( current, dir );
200a6ac: 40 00 00 0b call 200a6d8 <_RBTree_Next_unprotected>
200a6b0: 90 10 00 1d mov %i5, %o0
200a6b4: ba 10 00 08 mov %o0, %i5
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
200a6b8: 80 a7 60 00 cmp %i5, 0
200a6bc: 02 80 00 05 be 200a6d0 <_RBTree_Iterate_unprotected+0x58>
200a6c0: b8 1f 20 01 xor %i4, 1, %i4
200a6c4: 80 8f 20 ff btst 0xff, %i4
200a6c8: 12 bf ff f4 bne 200a698 <_RBTree_Iterate_unprotected+0x20><== ALWAYS TAKEN
200a6cc: 90 10 00 1d mov %i5, %o0
200a6d0: 81 c7 e0 08 ret
200a6d4: 81 e8 00 00 restore
02009fe0 <_RBTree_Rotate>:
RBTree_Node *the_node,
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
2009fe0: 80 a2 20 00 cmp %o0, 0
2009fe4: 02 80 00 1c be 200a054 <_RBTree_Rotate+0x74> <== NEVER TAKEN
2009fe8: 80 a0 00 09 cmp %g0, %o1
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
2009fec: 86 60 3f ff subx %g0, -1, %g3
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
2009ff0: 87 28 e0 02 sll %g3, 2, %g3
2009ff4: 86 02 00 03 add %o0, %g3, %g3
2009ff8: c2 00 e0 04 ld [ %g3 + 4 ], %g1
2009ffc: 80 a0 60 00 cmp %g1, 0
200a000: 02 80 00 15 be 200a054 <_RBTree_Rotate+0x74> <== NEVER TAKEN
200a004: 93 2a 60 02 sll %o1, 2, %o1
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
200a008: 84 00 40 09 add %g1, %o1, %g2
200a00c: c8 00 a0 04 ld [ %g2 + 4 ], %g4
200a010: c8 20 e0 04 st %g4, [ %g3 + 4 ]
if (c->child[dir])
200a014: c4 00 a0 04 ld [ %g2 + 4 ], %g2
200a018: 80 a0 a0 00 cmp %g2, 0
200a01c: 32 80 00 02 bne,a 200a024 <_RBTree_Rotate+0x44>
200a020: d0 20 80 00 st %o0, [ %g2 ]
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a024: c4 02 00 00 ld [ %o0 ], %g2
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
200a028: 92 00 40 09 add %g1, %o1, %o1
200a02c: d0 22 60 04 st %o0, [ %o1 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a030: c6 00 a0 04 ld [ %g2 + 4 ], %g3
c->parent = the_node->parent;
200a034: 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;
200a038: 86 1a 00 03 xor %o0, %g3, %g3
c->parent = the_node->parent;
the_node->parent = c;
200a03c: c2 22 00 00 st %g1, [ %o0 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a040: 80 a0 00 03 cmp %g0, %g3
200a044: 86 40 20 00 addx %g0, 0, %g3
200a048: 87 28 e0 02 sll %g3, 2, %g3
200a04c: 86 00 80 03 add %g2, %g3, %g3
200a050: c2 20 e0 04 st %g1, [ %g3 + 4 ]
200a054: 81 c3 e0 08 retl
02009f90 <_RBTree_Sibling>:
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
2009f90: 80 a2 20 00 cmp %o0, 0
2009f94: 02 80 00 10 be 2009fd4 <_RBTree_Sibling+0x44> <== NEVER TAKEN
2009f98: 82 10 20 00 clr %g1
if(!(the_node->parent)) return NULL;
2009f9c: c4 02 00 00 ld [ %o0 ], %g2
2009fa0: 80 a0 a0 00 cmp %g2, 0
2009fa4: 22 80 00 0d be,a 2009fd8 <_RBTree_Sibling+0x48> <== NEVER TAKEN
2009fa8: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
if(!(the_node->parent->parent)) return NULL;
2009fac: c2 00 80 00 ld [ %g2 ], %g1
2009fb0: 80 a0 60 00 cmp %g1, 0
2009fb4: 02 80 00 08 be 2009fd4 <_RBTree_Sibling+0x44>
2009fb8: 82 10 20 00 clr %g1
if(the_node == the_node->parent->child[RBT_LEFT])
2009fbc: c2 00 a0 04 ld [ %g2 + 4 ], %g1
2009fc0: 80 a2 00 01 cmp %o0, %g1
2009fc4: 22 80 00 04 be,a 2009fd4 <_RBTree_Sibling+0x44>
2009fc8: c2 00 a0 08 ld [ %g2 + 8 ], %g1
return the_node->parent->child[RBT_RIGHT];
2009fcc: 81 c3 e0 08 retl
2009fd0: 90 10 00 01 mov %g1, %o0
else
return the_node->parent->child[RBT_LEFT];
}
2009fd4: 90 10 00 01 mov %g1, %o0
2009fd8: 81 c3 e0 08 retl
02008820 <_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 )
{
2008820: 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 ];
2008824: fa 06 21 58 ld [ %i0 + 0x158 ], %i5
if ( !api )
2008828: 80 a7 60 00 cmp %i5, 0
200882c: 02 80 00 1c be 200889c <_RTEMS_signal_Post_switch_hook+0x7c><== NEVER TAKEN
2008830: 01 00 00 00 nop
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
2008834: 7f ff eb 45 call 2003548 <sparc_disable_interrupts>
2008838: 01 00 00 00 nop
signal_set = asr->signals_posted;
200883c: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
asr->signals_posted = 0;
2008840: c0 27 60 14 clr [ %i5 + 0x14 ]
_ISR_Enable( level );
2008844: 7f ff eb 45 call 2003558 <sparc_enable_interrupts>
2008848: 01 00 00 00 nop
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
200884c: 80 a7 20 00 cmp %i4, 0
2008850: 02 80 00 13 be 200889c <_RTEMS_signal_Post_switch_hook+0x7c>
2008854: 94 07 bf fc add %fp, -4, %o2
return;
asr->nest_level += 1;
2008858: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
200885c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
2008860: 82 00 60 01 inc %g1
2008864: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
2008868: 37 00 00 3f sethi %hi(0xfc00), %i3
200886c: 40 00 01 03 call 2008c78 <rtems_task_mode>
2008870: 92 16 e3 ff or %i3, 0x3ff, %o1 ! ffff <PROM_START+0xffff>
(*asr->handler)( signal_set );
2008874: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2008878: 9f c0 40 00 call %g1
200887c: 90 10 00 1c mov %i4, %o0
asr->nest_level -= 1;
2008880: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
2008884: 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;
2008888: 82 00 7f ff add %g1, -1, %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
200888c: 92 16 e3 ff or %i3, 0x3ff, %o1
asr->nest_level += 1;
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
(*asr->handler)( signal_set );
asr->nest_level -= 1;
2008890: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
2008894: 40 00 00 f9 call 2008c78 <rtems_task_mode>
2008898: 94 07 bf fc add %fp, -4, %o2
200889c: 81 c7 e0 08 ret
20088a0: 81 e8 00 00 restore
02032df4 <_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
)
{
2032df4: 9d e3 bf 98 save %sp, -104, %sp
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
2032df8: 13 00 81 87 sethi %hi(0x2061c00), %o1
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
#endif
Thread_Control *owning_thread = the_period->owner;
2032dfc: f6 06 20 40 ld [ %i0 + 0x40 ], %i3
2032e00: 90 07 bf f8 add %fp, -8, %o0
2032e04: 7f ff 55 55 call 2008358 <_TOD_Get_with_nanoseconds>
2032e08: 92 12 63 90 or %o1, 0x390, %o1
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
2032e0c: c4 1f bf f8 ldd [ %fp + -8 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2032e10: 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) {
2032e14: 09 00 81 89 sethi %hi(0x2062400), %g4
2032e18: ba a0 c0 1d subcc %g3, %i5, %i5
2032e1c: 88 11 21 60 or %g4, 0x160, %g4
2032e20: b8 60 80 1c subx %g2, %i4, %i4
2032e24: f8 3e 40 00 std %i4, [ %i1 ]
2032e28: fa 01 20 10 ld [ %g4 + 0x10 ], %i5
#endif
/*
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
2032e2c: d8 1e e0 80 ldd [ %i3 + 0x80 ], %o4
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
2032e30: 80 a6 c0 1d cmp %i3, %i5
2032e34: 12 80 00 15 bne 2032e88 <_Rate_monotonic_Get_status+0x94>
2032e38: 82 10 20 01 mov 1, %g1
2032e3c: f8 19 20 20 ldd [ %g4 + 0x20 ], %i4
2032e40: 86 a0 c0 1d subcc %g3, %i5, %g3
2032e44: 84 60 80 1c subx %g2, %i4, %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2032e48: ba 83 40 03 addcc %o5, %g3, %i5
2032e4c: b8 43 00 02 addx %o4, %g2, %i4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2032e50: c4 1e 20 48 ldd [ %i0 + 0x48 ], %g2
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
2032e54: 80 a0 80 1c cmp %g2, %i4
2032e58: 34 80 00 0c bg,a 2032e88 <_Rate_monotonic_Get_status+0x94><== NEVER TAKEN
2032e5c: 82 10 20 00 clr %g1 <== NOT EXECUTED
2032e60: 32 80 00 06 bne,a 2032e78 <_Rate_monotonic_Get_status+0x84>
2032e64: 86 a7 40 03 subcc %i5, %g3, %g3
2032e68: 80 a0 c0 1d cmp %g3, %i5
2032e6c: 18 80 00 06 bgu 2032e84 <_Rate_monotonic_Get_status+0x90>
2032e70: 86 a7 40 03 subcc %i5, %g3, %g3
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
2032e74: 82 10 20 01 mov 1, %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2032e78: 84 67 00 02 subx %i4, %g2, %g2
2032e7c: 10 80 00 03 b 2032e88 <_Rate_monotonic_Get_status+0x94>
2032e80: c4 3e 80 00 std %g2, [ %i2 ]
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
return false;
2032e84: 82 10 20 00 clr %g1
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
}
2032e88: b0 08 60 01 and %g1, 1, %i0
2032e8c: 81 c7 e0 08 ret
2032e90: 81 e8 00 00 restore
020331fc <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
20331fc: 9d e3 bf 98 save %sp, -104, %sp
2033200: 11 00 81 8a sethi %hi(0x2062800), %o0
2033204: 92 10 00 18 mov %i0, %o1
2033208: 90 12 23 24 or %o0, 0x324, %o0
203320c: 7f ff 56 fa call 2008df4 <_Objects_Get>
2033210: 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 ) {
2033214: c2 07 bf fc ld [ %fp + -4 ], %g1
2033218: 80 a0 60 00 cmp %g1, 0
203321c: 12 80 00 24 bne 20332ac <_Rate_monotonic_Timeout+0xb0> <== NEVER TAKEN
2033220: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
the_thread = the_period->owner;
2033224: d0 02 20 40 ld [ %o0 + 0x40 ], %o0
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
2033228: 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);
203322c: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
2033230: 80 88 80 01 btst %g2, %g1
2033234: 22 80 00 0b be,a 2033260 <_Rate_monotonic_Timeout+0x64>
2033238: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
203323c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
2033240: c2 07 60 08 ld [ %i5 + 8 ], %g1
2033244: 80 a0 80 01 cmp %g2, %g1
2033248: 32 80 00 06 bne,a 2033260 <_Rate_monotonic_Timeout+0x64>
203324c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
2033250: 13 04 01 ff sethi %hi(0x1007fc00), %o1
2033254: 7f ff 59 b2 call 200991c <_Thread_Clear_state>
2033258: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1007fff8 <RAM_END+0xdc7fff8>
203325c: 30 80 00 06 b,a 2033274 <_Rate_monotonic_Timeout+0x78>
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
2033260: 80 a0 60 01 cmp %g1, 1
2033264: 12 80 00 0d bne 2033298 <_Rate_monotonic_Timeout+0x9c>
2033268: 82 10 20 04 mov 4, %g1
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
203326c: 82 10 20 03 mov 3, %g1
2033270: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
_Rate_monotonic_Initiate_statistics( the_period );
2033274: 7f ff ff 51 call 2032fb8 <_Rate_monotonic_Initiate_statistics>
2033278: 90 10 00 1d mov %i5, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
203327c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2033280: 11 00 81 88 sethi %hi(0x2062000), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2033284: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2033288: 90 12 20 dc or %o0, 0xdc, %o0
203328c: 7f ff 5d b7 call 200a968 <_Watchdog_Insert>
2033290: 92 07 60 10 add %i5, 0x10, %o1
2033294: 30 80 00 02 b,a 203329c <_Rate_monotonic_Timeout+0xa0>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
2033298: 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;
203329c: 03 00 81 88 sethi %hi(0x2062000), %g1
20332a0: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2062040 <_Thread_Dispatch_disable_level>
--level;
20332a4: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
20332a8: c4 20 60 40 st %g2, [ %g1 + 0x40 ]
20332ac: 81 c7 e0 08 ret
20332b0: 81 e8 00 00 restore
02032e94 <_Rate_monotonic_Update_statistics>:
}
static void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
2032e94: 9d e3 bf 90 save %sp, -112, %sp
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
2032e98: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
2032e9c: 82 00 60 01 inc %g1
2032ea0: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
2032ea4: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
2032ea8: 80 a0 60 04 cmp %g1, 4
2032eac: 12 80 00 05 bne 2032ec0 <_Rate_monotonic_Update_statistics+0x2c>
2032eb0: 90 10 00 18 mov %i0, %o0
stats->missed_count++;
2032eb4: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
2032eb8: 82 00 60 01 inc %g1
2032ebc: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
/*
* Grab status for time statistics.
*/
valid_status =
2032ec0: 92 07 bf f8 add %fp, -8, %o1
2032ec4: 7f ff ff cc call 2032df4 <_Rate_monotonic_Get_status>
2032ec8: 94 07 bf f0 add %fp, -16, %o2
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
2032ecc: 80 8a 20 ff btst 0xff, %o0
2032ed0: 02 80 00 38 be 2032fb0 <_Rate_monotonic_Update_statistics+0x11c>
2032ed4: c4 1f bf f0 ldd [ %fp + -16 ], %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2032ed8: 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 ) )
2032edc: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
2032ee0: b6 87 40 03 addcc %i5, %g3, %i3
2032ee4: b4 47 00 02 addx %i4, %g2, %i2
2032ee8: 80 a0 40 02 cmp %g1, %g2
2032eec: 14 80 00 09 bg 2032f10 <_Rate_monotonic_Update_statistics+0x7c>
2032ef0: f4 3e 20 70 std %i2, [ %i0 + 0x70 ]
2032ef4: 80 a0 40 02 cmp %g1, %g2
2032ef8: 32 80 00 08 bne,a 2032f18 <_Rate_monotonic_Update_statistics+0x84><== NEVER TAKEN
2032efc: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED
2032f00: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
2032f04: 80 a0 40 03 cmp %g1, %g3
2032f08: 28 80 00 04 bleu,a 2032f18 <_Rate_monotonic_Update_statistics+0x84>
2032f0c: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
stats->min_cpu_time = executed;
2032f10: c4 3e 20 60 std %g2, [ %i0 + 0x60 ]
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
2032f14: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
2032f18: 80 a0 40 02 cmp %g1, %g2
2032f1c: 26 80 00 0a bl,a 2032f44 <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN
2032f20: c4 3e 20 68 std %g2, [ %i0 + 0x68 ] <== NOT EXECUTED
2032f24: 80 a0 40 02 cmp %g1, %g2
2032f28: 32 80 00 08 bne,a 2032f48 <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN
2032f2c: c4 1f bf f8 ldd [ %fp + -8 ], %g2 <== NOT EXECUTED
2032f30: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
2032f34: 80 a0 40 03 cmp %g1, %g3
2032f38: 3a 80 00 04 bcc,a 2032f48 <_Rate_monotonic_Update_statistics+0xb4>
2032f3c: c4 1f bf f8 ldd [ %fp + -8 ], %g2
stats->max_cpu_time = executed;
2032f40: c4 3e 20 68 std %g2, [ %i0 + 0x68 ]
/*
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
2032f44: c4 1f bf f8 ldd [ %fp + -8 ], %g2
2032f48: f8 1e 20 88 ldd [ %i0 + 0x88 ], %i4
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
2032f4c: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
2032f50: b6 87 40 03 addcc %i5, %g3, %i3
2032f54: b4 47 00 02 addx %i4, %g2, %i2
2032f58: 80 a0 40 02 cmp %g1, %g2
2032f5c: 14 80 00 09 bg 2032f80 <_Rate_monotonic_Update_statistics+0xec>
2032f60: f4 3e 20 88 std %i2, [ %i0 + 0x88 ]
2032f64: 80 a0 40 02 cmp %g1, %g2
2032f68: 32 80 00 08 bne,a 2032f88 <_Rate_monotonic_Update_statistics+0xf4><== NEVER TAKEN
2032f6c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
2032f70: c2 06 20 7c ld [ %i0 + 0x7c ], %g1
2032f74: 80 a0 40 03 cmp %g1, %g3
2032f78: 28 80 00 04 bleu,a 2032f88 <_Rate_monotonic_Update_statistics+0xf4>
2032f7c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
stats->min_wall_time = since_last_period;
2032f80: c4 3e 20 78 std %g2, [ %i0 + 0x78 ]
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
2032f84: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
2032f88: 80 a0 40 02 cmp %g1, %g2
2032f8c: 26 80 00 09 bl,a 2032fb0 <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
2032f90: c4 3e 20 80 std %g2, [ %i0 + 0x80 ] <== NOT EXECUTED
2032f94: 80 a0 40 02 cmp %g1, %g2
2032f98: 12 80 00 06 bne 2032fb0 <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
2032f9c: 01 00 00 00 nop
2032fa0: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
2032fa4: 80 a0 40 03 cmp %g1, %g3
2032fa8: 2a 80 00 02 bcs,a 2032fb0 <_Rate_monotonic_Update_statistics+0x11c>
2032fac: c4 3e 20 80 std %g2, [ %i0 + 0x80 ]
2032fb0: 81 c7 e0 08 ret
2032fb4: 81 e8 00 00 restore
02009ff8 <_Scheduler_CBS_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_CBS_Allocate(
Thread_Control *the_thread
)
{
2009ff8: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_CBS_Per_thread *schinfo;
sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));
2009ffc: 40 00 06 bb call 200bae8 <_Workspace_Allocate>
200a000: 90 10 20 1c mov 0x1c, %o0
if ( sched ) {
200a004: 80 a2 20 00 cmp %o0, 0
200a008: 02 80 00 06 be 200a020 <_Scheduler_CBS_Allocate+0x28> <== NEVER TAKEN
200a00c: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
200a010: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
schinfo->edf_per_thread.thread = the_thread;
200a014: f0 22 00 00 st %i0, [ %o0 ]
schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
200a018: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
schinfo->cbs_server = NULL;
200a01c: c0 22 20 18 clr [ %o0 + 0x18 ]
}
return sched;
}
200a020: 81 c7 e0 08 ret
200a024: 91 e8 00 08 restore %g0, %o0, %o0
0200b338 <_Scheduler_CBS_Budget_callout>:
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
200b338: 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;
200b33c: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
200b340: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200b344: 80 a0 40 09 cmp %g1, %o1
200b348: 32 80 00 02 bne,a 200b350 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN
200b34c: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
200b350: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200b354: 80 a0 40 09 cmp %g1, %o1
200b358: 02 80 00 04 be 200b368 <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN
200b35c: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
200b360: 40 00 01 83 call 200b96c <_Thread_Change_priority>
200b364: 94 10 20 01 mov 1, %o2
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
200b368: fa 06 20 88 ld [ %i0 + 0x88 ], %i5
if ( sched_info->cbs_server->cbs_budget_overrun ) {
200b36c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200b370: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200b374: 80 a0 a0 00 cmp %g2, 0
200b378: 02 80 00 09 be 200b39c <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN
200b37c: 01 00 00 00 nop
_Scheduler_CBS_Get_server_id(
200b380: d0 00 40 00 ld [ %g1 ], %o0
200b384: 7f ff ff d7 call 200b2e0 <_Scheduler_CBS_Get_server_id>
200b388: 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 );
200b38c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200b390: c2 00 60 0c ld [ %g1 + 0xc ], %g1
200b394: 9f c0 40 00 call %g1
200b398: d0 07 bf fc ld [ %fp + -4 ], %o0
200b39c: 81 c7 e0 08 ret
200b3a0: 81 e8 00 00 restore
0200af40 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
200af40: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
200af44: c2 06 20 04 ld [ %i0 + 4 ], %g1
200af48: 80 a0 60 00 cmp %g1, 0
200af4c: 04 80 00 1d ble 200afc0 <_Scheduler_CBS_Create_server+0x80>
200af50: 01 00 00 00 nop
200af54: c2 06 00 00 ld [ %i0 ], %g1
200af58: 80 a0 60 00 cmp %g1, 0
200af5c: 04 80 00 19 ble 200afc0 <_Scheduler_CBS_Create_server+0x80>
200af60: 03 00 80 80 sethi %hi(0x2020000), %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++ ) {
200af64: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 2020080 <_Scheduler_CBS_Maximum_servers>
if ( !_Scheduler_CBS_Server_list[i] )
200af68: 03 00 80 84 sethi %hi(0x2021000), %g1
200af6c: c6 00 62 68 ld [ %g1 + 0x268 ], %g3 ! 2021268 <_Scheduler_CBS_Server_list>
200af70: 10 80 00 07 b 200af8c <_Scheduler_CBS_Create_server+0x4c>
200af74: 82 10 20 00 clr %g1
200af78: c8 00 c0 1c ld [ %g3 + %i4 ], %g4
200af7c: 80 a1 20 00 cmp %g4, 0
200af80: 02 80 00 14 be 200afd0 <_Scheduler_CBS_Create_server+0x90>
200af84: 3b 00 80 84 sethi %hi(0x2021000), %i5
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
200af88: 82 00 60 01 inc %g1
200af8c: 80 a0 40 02 cmp %g1, %g2
200af90: 12 bf ff fa bne 200af78 <_Scheduler_CBS_Create_server+0x38>
200af94: b9 28 60 02 sll %g1, 2, %i4
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
200af98: 81 c7 e0 08 ret
200af9c: 91 e8 3f e6 restore %g0, -26, %o0
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
200afa0: c4 20 60 04 st %g2, [ %g1 + 4 ]
200afa4: c4 06 20 04 ld [ %i0 + 4 ], %g2
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
200afa8: f2 20 60 0c st %i1, [ %g1 + 0xc ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
200afac: c4 20 60 08 st %g2, [ %g1 + 8 ]
the_server->task_id = -1;
200afb0: 84 10 3f ff mov -1, %g2
200afb4: c4 20 40 00 st %g2, [ %g1 ]
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
200afb8: 81 c7 e0 08 ret
200afbc: 91 e8 20 00 restore %g0, 0, %o0
if ( params->budget <= 0 ||
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
200afc0: 81 c7 e0 08 ret
200afc4: 91 e8 3f ee restore %g0, -18, %o0
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
200afc8: 81 c7 e0 08 ret <== NOT EXECUTED
200afcc: 91 e8 3f ef restore %g0, -17, %o0 <== NOT EXECUTED
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
200afd0: f6 07 62 68 ld [ %i5 + 0x268 ], %i3
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
200afd4: c2 26 80 00 st %g1, [ %i2 ]
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
200afd8: 40 00 07 ad call 200ce8c <_Workspace_Allocate>
200afdc: 90 10 20 10 mov 0x10, %o0
the_server = _Scheduler_CBS_Server_list[*server_id];
200afe0: 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 *)
200afe4: d0 26 c0 1c st %o0, [ %i3 + %i4 ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
200afe8: c4 07 62 68 ld [ %i5 + 0x268 ], %g2
200afec: 83 28 60 02 sll %g1, 2, %g1
200aff0: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( !the_server )
200aff4: 80 a0 60 00 cmp %g1, 0
200aff8: 32 bf ff ea bne,a 200afa0 <_Scheduler_CBS_Create_server+0x60><== ALWAYS TAKEN
200affc: c4 06 00 00 ld [ %i0 ], %g2
200b000: 30 bf ff f2 b,a 200afc8 <_Scheduler_CBS_Create_server+0x88><== NOT EXECUTED
0200b078 <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
200b078: 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);
200b07c: 90 10 00 19 mov %i1, %o0
200b080: 40 00 03 79 call 200be64 <_Thread_Get>
200b084: 92 07 bf fc add %fp, -4, %o1
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
200b088: ba 92 20 00 orcc %o0, 0, %i5
200b08c: 02 80 00 05 be 200b0a0 <_Scheduler_CBS_Detach_thread+0x28>
200b090: 03 00 80 80 sethi %hi(0x2020000), %g1
_Thread_Enable_dispatch();
200b094: 40 00 03 68 call 200be34 <_Thread_Enable_dispatch>
200b098: 01 00 00 00 nop
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
200b09c: 03 00 80 80 sethi %hi(0x2020000), %g1
200b0a0: c2 00 60 80 ld [ %g1 + 0x80 ], %g1 ! 2020080 <_Scheduler_CBS_Maximum_servers>
200b0a4: 80 a6 00 01 cmp %i0, %g1
200b0a8: 1a 80 00 1b bcc 200b114 <_Scheduler_CBS_Detach_thread+0x9c>
200b0ac: 80 a7 60 00 cmp %i5, 0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
200b0b0: 02 80 00 19 be 200b114 <_Scheduler_CBS_Detach_thread+0x9c>
200b0b4: 03 00 80 84 sethi %hi(0x2021000), %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
200b0b8: c2 00 62 68 ld [ %g1 + 0x268 ], %g1 ! 2021268 <_Scheduler_CBS_Server_list>
200b0bc: b1 2e 20 02 sll %i0, 2, %i0
200b0c0: c2 00 40 18 ld [ %g1 + %i0 ], %g1
200b0c4: 80 a0 60 00 cmp %g1, 0
200b0c8: 02 80 00 11 be 200b10c <_Scheduler_CBS_Detach_thread+0x94>
200b0cc: 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 )
200b0d0: c4 00 40 00 ld [ %g1 ], %g2
200b0d4: 80 a0 80 19 cmp %g2, %i1
200b0d8: 12 80 00 0f bne 200b114 <_Scheduler_CBS_Detach_thread+0x9c><== NEVER TAKEN
200b0dc: 84 10 3f ff mov -1, %g2
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
200b0e0: c4 20 40 00 st %g2, [ %g1 ]
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
200b0e4: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
200b0e8: c0 20 60 18 clr [ %g1 + 0x18 ]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
200b0ec: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
200b0f0: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
the_thread->budget_callout = the_thread->Start.budget_callout;
200b0f4: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
200b0f8: c2 27 60 7c st %g1, [ %i5 + 0x7c ]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
200b0fc: c2 0f 60 9c ldub [ %i5 + 0x9c ], %g1
200b100: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ]
return SCHEDULER_CBS_OK;
200b104: 81 c7 e0 08 ret
200b108: 91 e8 20 00 restore %g0, 0, %o0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
200b10c: 81 c7 e0 08 ret
200b110: 91 e8 3f e7 restore %g0, -25, %o0
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
return SCHEDULER_CBS_OK;
}
200b114: 81 c7 e0 08 ret
200b118: 91 e8 3f ee restore %g0, -18, %o0
0200b3a4 <_Scheduler_CBS_Initialize>:
}
}
int _Scheduler_CBS_Initialize(void)
{
200b3a4: 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*) );
200b3a8: 3b 00 80 80 sethi %hi(0x2020000), %i5
200b3ac: d0 07 60 80 ld [ %i5 + 0x80 ], %o0 ! 2020080 <_Scheduler_CBS_Maximum_servers>
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
200b3b0: 40 00 06 b7 call 200ce8c <_Workspace_Allocate>
200b3b4: 91 2a 20 02 sll %o0, 2, %o0
200b3b8: 05 00 80 84 sethi %hi(0x2021000), %g2
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
200b3bc: 80 a2 20 00 cmp %o0, 0
200b3c0: 02 80 00 0d be 200b3f4 <_Scheduler_CBS_Initialize+0x50> <== NEVER TAKEN
200b3c4: d0 20 a2 68 st %o0, [ %g2 + 0x268 ]
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
200b3c8: c6 07 60 80 ld [ %i5 + 0x80 ], %g3
200b3cc: 10 80 00 05 b 200b3e0 <_Scheduler_CBS_Initialize+0x3c>
200b3d0: 82 10 20 00 clr %g1
_Scheduler_CBS_Server_list[i] = NULL;
200b3d4: 89 28 60 02 sll %g1, 2, %g4
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
200b3d8: 82 00 60 01 inc %g1
_Scheduler_CBS_Server_list[i] = NULL;
200b3dc: c0 27 40 04 clr [ %i5 + %g4 ]
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
200b3e0: 80 a0 40 03 cmp %g1, %g3
200b3e4: 12 bf ff fc bne 200b3d4 <_Scheduler_CBS_Initialize+0x30>
200b3e8: fa 00 a2 68 ld [ %g2 + 0x268 ], %i5
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
200b3ec: 81 c7 e0 08 ret
200b3f0: 91 e8 20 00 restore %g0, 0, %o0
}
200b3f4: 81 c7 e0 08 ret <== NOT EXECUTED
200b3f8: 91 e8 3f ef restore %g0, -17, %o0 <== NOT EXECUTED
0200a028 <_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;
200a028: c2 02 20 88 ld [ %o0 + 0x88 ], %g1
if (deadline) {
200a02c: 80 a2 60 00 cmp %o1, 0
200a030: 02 80 00 10 be 200a070 <_Scheduler_CBS_Release_job+0x48>
200a034: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
/* Initializing or shifting deadline. */
if (serv_info)
200a038: 80 a0 60 00 cmp %g1, 0
200a03c: 02 80 00 08 be 200a05c <_Scheduler_CBS_Release_job+0x34>
200a040: 05 00 80 7c sethi %hi(0x201f000), %g2
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
200a044: d2 00 a2 bc ld [ %g2 + 0x2bc ], %o1 ! 201f2bc <_Watchdog_Ticks_since_boot>
200a048: c4 00 60 04 ld [ %g1 + 4 ], %g2
200a04c: 92 02 40 02 add %o1, %g2, %o1
200a050: 05 20 00 00 sethi %hi(0x80000000), %g2
200a054: 10 80 00 0a b 200a07c <_Scheduler_CBS_Release_job+0x54>
200a058: 92 2a 40 02 andn %o1, %g2, %o1
& ~SCHEDULER_EDF_PRIO_MSB;
else
new_priority = (_Watchdog_Ticks_since_boot + deadline)
200a05c: c2 00 a2 bc ld [ %g2 + 0x2bc ], %g1
200a060: 92 02 40 01 add %o1, %g1, %o1
200a064: 03 20 00 00 sethi %hi(0x80000000), %g1
200a068: 10 80 00 07 b 200a084 <_Scheduler_CBS_Release_job+0x5c>
200a06c: 92 2a 40 01 andn %o1, %g1, %o1
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
}
/* Budget replenishment for the next job. */
if (serv_info)
200a070: 80 a0 60 00 cmp %g1, 0
200a074: 02 80 00 04 be 200a084 <_Scheduler_CBS_Release_job+0x5c> <== NEVER TAKEN
200a078: d2 02 20 ac ld [ %o0 + 0xac ], %o1
the_thread->cpu_time_budget = serv_info->parameters.budget;
200a07c: c2 00 60 08 ld [ %g1 + 8 ], %g1
200a080: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
the_thread->real_priority = new_priority;
200a084: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
_Thread_Change_priority(the_thread, new_priority, true);
200a088: 94 10 20 01 mov 1, %o2
200a08c: 82 13 c0 00 mov %o7, %g1
200a090: 40 00 01 26 call 200a528 <_Thread_Change_priority>
200a094: 9e 10 40 00 mov %g1, %o7
0200a098 <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
200a098: 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);
200a09c: 40 00 00 4c call 200a1cc <_Scheduler_EDF_Enqueue>
200a0a0: 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;
200a0a4: c2 06 20 88 ld [ %i0 + 0x88 ], %g1
200a0a8: 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) {
200a0ac: 80 a7 60 00 cmp %i5, 0
200a0b0: 02 80 00 18 be 200a110 <_Scheduler_CBS_Unblock+0x78>
200a0b4: 03 00 80 7c sethi %hi(0x201f000), %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 ) {
200a0b8: 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 -
200a0bc: d0 00 62 bc ld [ %g1 + 0x2bc ], %o0
200a0c0: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
200a0c4: 40 00 3f 36 call 2019d9c <.umul>
200a0c8: 90 27 00 08 sub %i4, %o0, %o0
200a0cc: d2 06 20 74 ld [ %i0 + 0x74 ], %o1
200a0d0: b6 10 00 08 mov %o0, %i3
200a0d4: 40 00 3f 32 call 2019d9c <.umul>
200a0d8: d0 07 60 08 ld [ %i5 + 8 ], %o0
200a0dc: 80 a6 c0 08 cmp %i3, %o0
200a0e0: 24 80 00 0d ble,a 200a114 <_Scheduler_CBS_Unblock+0x7c>
200a0e4: 3b 00 80 7d sethi %hi(0x201f400), %i5
/* Put late unblocked task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
200a0e8: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
200a0ec: 80 a7 00 09 cmp %i4, %o1
200a0f0: 32 80 00 02 bne,a 200a0f8 <_Scheduler_CBS_Unblock+0x60>
200a0f4: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
200a0f8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a0fc: 80 a0 40 09 cmp %g1, %o1
200a100: 02 80 00 04 be 200a110 <_Scheduler_CBS_Unblock+0x78>
200a104: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
200a108: 40 00 01 08 call 200a528 <_Thread_Change_priority>
200a10c: 94 10 20 01 mov 1, %o2
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
200a110: 3b 00 80 7d sethi %hi(0x201f400), %i5
200a114: ba 17 62 f0 or %i5, 0x2f0, %i5 ! 201f6f0 <_Per_CPU_Information>
200a118: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
200a11c: 03 00 80 79 sethi %hi(0x201e400), %g1
200a120: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
200a124: c2 00 61 64 ld [ %g1 + 0x164 ], %g1
200a128: 9f c0 40 00 call %g1
200a12c: d2 00 a0 14 ld [ %g2 + 0x14 ], %o1
200a130: 80 a2 20 00 cmp %o0, 0
200a134: 04 80 00 0f ble 200a170 <_Scheduler_CBS_Unblock+0xd8>
200a138: 01 00 00 00 nop
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
200a13c: 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;
200a140: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
if ( _Thread_Executing->is_preemptible ||
200a144: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
200a148: 80 a0 60 00 cmp %g1, 0
200a14c: 12 80 00 06 bne 200a164 <_Scheduler_CBS_Unblock+0xcc>
200a150: 84 10 20 01 mov 1, %g2
200a154: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a158: 80 a0 60 00 cmp %g1, 0
200a15c: 12 80 00 05 bne 200a170 <_Scheduler_CBS_Unblock+0xd8> <== ALWAYS TAKEN
200a160: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
200a164: 03 00 80 7d sethi %hi(0x201f400), %g1
200a168: 82 10 62 f0 or %g1, 0x2f0, %g1 ! 201f6f0 <_Per_CPU_Information>
200a16c: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
200a170: 81 c7 e0 08 ret
200a174: 81 e8 00 00 restore
02009ff8 <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
2009ff8: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
2009ffc: 40 00 06 90 call 200ba3c <_Workspace_Allocate>
200a000: 90 10 20 18 mov 0x18, %o0
if ( sched ) {
200a004: 80 a2 20 00 cmp %o0, 0
200a008: 02 80 00 05 be 200a01c <_Scheduler_EDF_Allocate+0x24> <== NEVER TAKEN
200a00c: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
200a010: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
200a014: f0 22 00 00 st %i0, [ %o0 ]
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
200a018: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
}
return sched;
}
200a01c: 81 c7 e0 08 ret
200a020: 91 e8 00 08 restore %g0, %o0, %o0
0200a1c0 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
200a1c0: 9d e3 bf a0 save %sp, -96, %sp
_Scheduler_EDF_Enqueue(the_thread);
200a1c4: 7f ff ff ad call 200a078 <_Scheduler_EDF_Enqueue>
200a1c8: 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(
200a1cc: 3b 00 80 7d sethi %hi(0x201f400), %i5
200a1d0: ba 17 62 30 or %i5, 0x230, %i5 ! 201f630 <_Per_CPU_Information>
200a1d4: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
200a1d8: 03 00 80 79 sethi %hi(0x201e400), %g1
200a1dc: d0 00 a0 14 ld [ %g2 + 0x14 ], %o0
200a1e0: c2 00 60 b4 ld [ %g1 + 0xb4 ], %g1
200a1e4: 9f c0 40 00 call %g1
200a1e8: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
200a1ec: 80 a2 20 00 cmp %o0, 0
200a1f0: 16 80 00 0f bge 200a22c <_Scheduler_EDF_Unblock+0x6c>
200a1f4: 01 00 00 00 nop
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
200a1f8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
200a1fc: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
if ( _Thread_Executing->is_preemptible ||
200a200: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
200a204: 80 a0 60 00 cmp %g1, 0
200a208: 12 80 00 06 bne 200a220 <_Scheduler_EDF_Unblock+0x60>
200a20c: 84 10 20 01 mov 1, %g2
200a210: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a214: 80 a0 60 00 cmp %g1, 0
200a218: 12 80 00 05 bne 200a22c <_Scheduler_EDF_Unblock+0x6c> <== ALWAYS TAKEN
200a21c: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
200a220: 03 00 80 7d sethi %hi(0x201f400), %g1
200a224: 82 10 62 30 or %g1, 0x230, %g1 ! 201f630 <_Per_CPU_Information>
200a228: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
200a22c: 81 c7 e0 08 ret
200a230: 81 e8 00 00 restore
020098cc <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
20098cc: 9d e3 bf a0 save %sp, -96, %sp
Thread_Control *executing;
executing = _Thread_Executing;
20098d0: 03 00 80 76 sethi %hi(0x201d800), %g1
20098d4: fa 00 63 00 ld [ %g1 + 0x300 ], %i5 ! 201db00 <_Per_CPU_Information+0x10>
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
20098d8: c2 0f 60 70 ldub [ %i5 + 0x70 ], %g1
20098dc: 80 a0 60 00 cmp %g1, 0
20098e0: 02 80 00 25 be 2009974 <_Scheduler_priority_Tick+0xa8>
20098e4: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
20098e8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
20098ec: 80 a0 60 00 cmp %g1, 0
20098f0: 12 80 00 21 bne 2009974 <_Scheduler_priority_Tick+0xa8>
20098f4: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
20098f8: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
20098fc: 80 a0 60 01 cmp %g1, 1
2009900: 0a 80 00 14 bcs 2009950 <_Scheduler_priority_Tick+0x84>
2009904: 80 a0 60 02 cmp %g1, 2
2009908: 28 80 00 07 bleu,a 2009924 <_Scheduler_priority_Tick+0x58>
200990c: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
2009910: 80 a0 60 03 cmp %g1, 3
2009914: 12 80 00 18 bne 2009974 <_Scheduler_priority_Tick+0xa8> <== NEVER TAKEN
2009918: 01 00 00 00 nop
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
200991c: 10 80 00 0f b 2009958 <_Scheduler_priority_Tick+0x8c>
2009920: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
#endif
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
2009924: 82 00 7f ff add %g1, -1, %g1
2009928: 80 a0 60 00 cmp %g1, 0
200992c: 14 80 00 09 bg 2009950 <_Scheduler_priority_Tick+0x84>
2009930: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
2009934: 03 00 80 72 sethi %hi(0x201c800), %g1
2009938: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 201c9c0 <_Scheduler+0xc>
200993c: 9f c0 40 00 call %g1
2009940: 01 00 00 00 nop
* executing thread's timeslice is reset. Otherwise, the
* currently executing thread is placed at the rear of the
* FIFO for this priority and a new heir is selected.
*/
_Scheduler_Yield();
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
2009944: 03 00 80 75 sethi %hi(0x201d400), %g1
2009948: c2 00 61 30 ld [ %g1 + 0x130 ], %g1 ! 201d530 <_Thread_Ticks_per_timeslice>
200994c: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
2009950: 81 c7 e0 08 ret
2009954: 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 )
2009958: 82 00 7f ff add %g1, -1, %g1
200995c: 80 a0 60 00 cmp %g1, 0
2009960: 12 bf ff fc bne 2009950 <_Scheduler_priority_Tick+0x84>
2009964: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
(*executing->budget_callout)( executing );
2009968: c2 07 60 7c ld [ %i5 + 0x7c ], %g1
200996c: 9f c0 40 00 call %g1
2009970: 90 10 00 1d mov %i5, %o0
2009974: 81 c7 e0 08 ret
2009978: 81 e8 00 00 restore
02008490 <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
2008490: 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 /
2008494: 03 00 80 72 sethi %hi(0x201c800), %g1
2008498: d2 00 61 fc ld [ %g1 + 0x1fc ], %o1 ! 201c9fc <Configuration+0xc>
200849c: 11 00 03 d0 sethi %hi(0xf4000), %o0
20084a0: 40 00 48 86 call 201a6b8 <.udiv>
20084a4: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
20084a8: 80 a6 20 00 cmp %i0, 0
20084ac: 02 80 00 28 be 200854c <_TOD_Validate+0xbc> <== NEVER TAKEN
20084b0: 84 10 20 00 clr %g2
20084b4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
20084b8: 80 a0 40 08 cmp %g1, %o0
20084bc: 3a 80 00 25 bcc,a 2008550 <_TOD_Validate+0xc0>
20084c0: b0 08 a0 01 and %g2, 1, %i0
(the_tod->ticks >= ticks_per_second) ||
20084c4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
20084c8: 80 a0 60 3b cmp %g1, 0x3b
20084cc: 38 80 00 21 bgu,a 2008550 <_TOD_Validate+0xc0>
20084d0: b0 08 a0 01 and %g2, 1, %i0
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
20084d4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
20084d8: 80 a0 60 3b cmp %g1, 0x3b
20084dc: 38 80 00 1d bgu,a 2008550 <_TOD_Validate+0xc0>
20084e0: b0 08 a0 01 and %g2, 1, %i0
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
20084e4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
20084e8: 80 a0 60 17 cmp %g1, 0x17
20084ec: 38 80 00 19 bgu,a 2008550 <_TOD_Validate+0xc0>
20084f0: b0 08 a0 01 and %g2, 1, %i0
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
20084f4: c2 06 20 04 ld [ %i0 + 4 ], %g1
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
20084f8: 80 a0 60 00 cmp %g1, 0
20084fc: 02 80 00 14 be 200854c <_TOD_Validate+0xbc> <== NEVER TAKEN
2008500: 80 a0 60 0c cmp %g1, 0xc
(the_tod->month == 0) ||
2008504: 38 80 00 13 bgu,a 2008550 <_TOD_Validate+0xc0>
2008508: b0 08 a0 01 and %g2, 1, %i0
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
200850c: c8 06 00 00 ld [ %i0 ], %g4
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
2008510: 80 a1 27 c3 cmp %g4, 0x7c3
2008514: 28 80 00 0f bleu,a 2008550 <_TOD_Validate+0xc0>
2008518: b0 08 a0 01 and %g2, 1, %i0
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
200851c: c6 06 20 08 ld [ %i0 + 8 ], %g3
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
2008520: 80 a0 e0 00 cmp %g3, 0
2008524: 02 80 00 0a be 200854c <_TOD_Validate+0xbc> <== NEVER TAKEN
2008528: 80 89 20 03 btst 3, %g4
200852c: 05 00 80 76 sethi %hi(0x201d800), %g2
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
2008530: 12 80 00 03 bne 200853c <_TOD_Validate+0xac>
2008534: 84 10 a3 f0 or %g2, 0x3f0, %g2 ! 201dbf0 <_TOD_Days_per_month>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
2008538: 82 00 60 0d add %g1, 0xd, %g1
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
200853c: 83 28 60 02 sll %g1, 2, %g1
2008540: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( the_tod->day > days_in_month )
2008544: 80 a0 40 03 cmp %g1, %g3
2008548: 84 60 3f ff subx %g0, -1, %g2
return false;
return true;
}
200854c: b0 08 a0 01 and %g2, 1, %i0
2008550: 81 c7 e0 08 ret
2008554: 81 e8 00 00 restore
02009b88 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
2009b88: 9d e3 bf a0 save %sp, -96, %sp
2009b8c: ba 10 00 18 mov %i0, %i5
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
2009b90: f0 06 20 10 ld [ %i0 + 0x10 ], %i0
/*
* Set a transient state for the thread so it is pulled off the Ready chains.
* This will prevent it from being scheduled no matter what happens in an
* ISR.
*/
_Thread_Set_transient( the_thread );
2009b94: 40 00 03 78 call 200a974 <_Thread_Set_transient>
2009b98: 90 10 00 1d mov %i5, %o0
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
2009b9c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2009ba0: 80 a0 40 19 cmp %g1, %i1
2009ba4: 02 80 00 04 be 2009bb4 <_Thread_Change_priority+0x2c>
2009ba8: 90 10 00 1d mov %i5, %o0
_Thread_Set_priority( the_thread, new_priority );
2009bac: 40 00 03 59 call 200a910 <_Thread_Set_priority>
2009bb0: 92 10 00 19 mov %i1, %o1
_ISR_Disable( level );
2009bb4: 7f ff e2 84 call 20025c4 <sparc_disable_interrupts>
2009bb8: 01 00 00 00 nop
2009bbc: b6 10 00 08 mov %o0, %i3
/*
* If the thread has more than STATES_TRANSIENT set, then it is blocked,
* If it is blocked on a thread queue, then we need to requeue it.
*/
state = the_thread->current_state;
2009bc0: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
if ( state != STATES_TRANSIENT ) {
2009bc4: 80 a7 20 04 cmp %i4, 4
2009bc8: 02 80 00 10 be 2009c08 <_Thread_Change_priority+0x80>
2009bcc: 82 0e 20 04 and %i0, 4, %g1
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
2009bd0: 80 a0 60 00 cmp %g1, 0
2009bd4: 12 80 00 03 bne 2009be0 <_Thread_Change_priority+0x58> <== NEVER TAKEN
2009bd8: 82 0f 3f fb and %i4, -5, %g1
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
2009bdc: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
_ISR_Enable( level );
2009be0: 7f ff e2 7d call 20025d4 <sparc_enable_interrupts>
2009be4: 90 10 00 1b mov %i3, %o0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
2009be8: 03 00 00 ef sethi %hi(0x3bc00), %g1
2009bec: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
2009bf0: 80 8f 00 01 btst %i4, %g1
2009bf4: 02 80 00 27 be 2009c90 <_Thread_Change_priority+0x108>
2009bf8: 01 00 00 00 nop
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
2009bfc: f0 07 60 44 ld [ %i5 + 0x44 ], %i0
2009c00: 40 00 03 17 call 200a85c <_Thread_queue_Requeue>
2009c04: 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 ) ) {
2009c08: 80 a0 60 00 cmp %g1, 0
2009c0c: 12 80 00 0b bne 2009c38 <_Thread_Change_priority+0xb0> <== NEVER TAKEN
2009c10: 03 00 80 72 sethi %hi(0x201c800), %g1
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
2009c14: c0 27 60 10 clr [ %i5 + 0x10 ]
if ( prepend_it )
2009c18: 80 a6 a0 00 cmp %i2, 0
2009c1c: 02 80 00 04 be 2009c2c <_Thread_Change_priority+0xa4>
2009c20: 82 10 61 b4 or %g1, 0x1b4, %g1
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
2009c24: 10 80 00 03 b 2009c30 <_Thread_Change_priority+0xa8>
2009c28: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
2009c2c: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
2009c30: 9f c0 40 00 call %g1
2009c34: 90 10 00 1d mov %i5, %o0
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
2009c38: 7f ff e2 67 call 20025d4 <sparc_enable_interrupts>
2009c3c: 90 10 00 1b mov %i3, %o0
2009c40: 7f ff e2 61 call 20025c4 <sparc_disable_interrupts>
2009c44: 01 00 00 00 nop
2009c48: 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();
2009c4c: 03 00 80 72 sethi %hi(0x201c800), %g1
2009c50: c2 00 61 bc ld [ %g1 + 0x1bc ], %g1 ! 201c9bc <_Scheduler+0x8>
2009c54: 9f c0 40 00 call %g1
2009c58: 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 );
2009c5c: 03 00 80 76 sethi %hi(0x201d800), %g1
2009c60: 82 10 62 f0 or %g1, 0x2f0, %g1 ! 201daf0 <_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() &&
2009c64: c4 18 60 10 ldd [ %g1 + 0x10 ], %g2
2009c68: 80 a0 80 03 cmp %g2, %g3
2009c6c: 02 80 00 07 be 2009c88 <_Thread_Change_priority+0x100>
2009c70: 01 00 00 00 nop
2009c74: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
2009c78: 80 a0 a0 00 cmp %g2, 0
2009c7c: 02 80 00 03 be 2009c88 <_Thread_Change_priority+0x100>
2009c80: 84 10 20 01 mov 1, %g2
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
2009c84: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
_ISR_Enable( level );
2009c88: 7f ff e2 53 call 20025d4 <sparc_enable_interrupts>
2009c8c: 81 e8 00 00 restore
2009c90: 81 c7 e0 08 ret
2009c94: 81 e8 00 00 restore
02009e78 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
2009e78: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
2009e7c: 90 10 00 18 mov %i0, %o0
2009e80: 40 00 00 80 call 200a080 <_Thread_Get>
2009e84: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
2009e88: c2 07 bf fc ld [ %fp + -4 ], %g1
2009e8c: 80 a0 60 00 cmp %g1, 0
2009e90: 12 80 00 08 bne 2009eb0 <_Thread_Delay_ended+0x38> <== NEVER TAKEN
2009e94: 13 04 00 00 sethi %hi(0x10000000), %o1
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
2009e98: 7f ff ff 80 call 2009c98 <_Thread_Clear_state>
2009e9c: 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;
2009ea0: 03 00 80 75 sethi %hi(0x201d400), %g1
2009ea4: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 201d5d0 <_Thread_Dispatch_disable_level>
--level;
2009ea8: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
2009eac: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ]
2009eb0: 81 c7 e0 08 ret
2009eb4: 81 e8 00 00 restore
02009eb8 <_Thread_Dispatch>:
#if defined(RTEMS_SMP)
#include <rtems/score/smp.h>
#endif
void _Thread_Dispatch( void )
{
2009eb8: 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;
2009ebc: 35 00 80 76 sethi %hi(0x201d800), %i2
2009ec0: 82 16 a2 f0 or %i2, 0x2f0, %g1 ! 201daf0 <_Per_CPU_Information>
_ISR_Disable( level );
2009ec4: 7f ff e1 c0 call 20025c4 <sparc_disable_interrupts>
2009ec8: f6 00 60 10 ld [ %g1 + 0x10 ], %i3
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
2009ecc: 21 00 80 75 sethi %hi(0x201d400), %l0
{
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 ) {
2009ed0: 27 00 80 72 sethi %hi(0x201c800), %l3
* 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;
2009ed4: 33 00 80 75 sethi %hi(0x201d400), %i1
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
2009ed8: 31 00 80 75 sethi %hi(0x201d400), %i0
2009edc: a0 14 21 20 or %l0, 0x120, %l0
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
2009ee0: 23 00 80 75 sethi %hi(0x201d400), %l1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
2009ee4: 25 00 80 72 sethi %hi(0x201c800), %l2
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
2009ee8: 10 80 00 4b b 200a014 <_Thread_Dispatch+0x15c>
2009eec: a6 14 e3 8c or %l3, 0x38c, %l3
2009ef0: 84 10 20 01 mov 1, %g2
2009ef4: c4 26 61 d0 st %g2, [ %i1 + 0x1d0 ]
heir = _Thread_Heir;
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
2009ef8: c0 28 60 0c clrb [ %g1 + 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 )
2009efc: 80 a5 00 1b cmp %l4, %i3
2009f00: 12 80 00 0a bne 2009f28 <_Thread_Dispatch+0x70>
2009f04: e8 20 60 10 st %l4, [ %g1 + 0x10 ]
2009f08: 03 00 80 75 sethi %hi(0x201d400), %g1
2009f0c: c0 20 61 d0 clr [ %g1 + 0x1d0 ] ! 201d5d0 <_Thread_Dispatch_disable_level>
post_switch:
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 0 );
#endif
_ISR_Enable( level );
2009f10: 7f ff e1 b1 call 20025d4 <sparc_enable_interrupts>
2009f14: 39 00 80 75 sethi %hi(0x201d400), %i4
2009f18: 03 00 80 75 sethi %hi(0x201d400), %g1
2009f1c: fa 00 62 44 ld [ %g1 + 0x244 ], %i5 ! 201d644 <_API_extensions_Post_switch_list>
{
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 ) {
2009f20: 10 80 00 47 b 200a03c <_Thread_Dispatch+0x184>
2009f24: b8 17 22 48 or %i4, 0x248, %i4
*/
#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 )
2009f28: c2 05 20 78 ld [ %l4 + 0x78 ], %g1
2009f2c: 80 a0 60 01 cmp %g1, 1
2009f30: 12 80 00 03 bne 2009f3c <_Thread_Dispatch+0x84>
2009f34: c2 06 21 30 ld [ %i0 + 0x130 ], %g1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
2009f38: c2 25 20 74 st %g1, [ %l4 + 0x74 ]
_ISR_Enable( level );
2009f3c: 7f ff e1 a6 call 20025d4 <sparc_enable_interrupts>
2009f40: 01 00 00 00 nop
2009f44: 90 07 bf f8 add %fp, -8, %o0
2009f48: 7f ff f9 b9 call 200862c <_TOD_Get_with_nanoseconds>
2009f4c: 92 10 00 10 mov %l0, %o1
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
2009f50: c4 1f bf f8 ldd [ %fp + -8 ], %g2
2009f54: 82 16 a2 f0 or %i2, 0x2f0, %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2009f58: f8 18 60 20 ldd [ %g1 + 0x20 ], %i4
2009f5c: 96 a0 c0 1d subcc %g3, %i5, %o3
2009f60: 94 60 80 1c subx %g2, %i4, %o2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2009f64: f8 1e e0 80 ldd [ %i3 + 0x80 ], %i4
2009f68: 9a 87 40 0b addcc %i5, %o3, %o5
2009f6c: 98 47 00 0a addx %i4, %o2, %o4
2009f70: d8 3e e0 80 std %o4, [ %i3 + 0x80 ]
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
2009f74: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
2009f78: c2 04 62 40 ld [ %l1 + 0x240 ], %g1
2009f7c: 80 a0 60 00 cmp %g1, 0
2009f80: 22 80 00 0c be,a 2009fb0 <_Thread_Dispatch+0xf8> <== NEVER TAKEN
2009f84: fa 04 a3 88 ld [ %l2 + 0x388 ], %i5 <== NOT EXECUTED
executing->libc_reent = *_Thread_libc_reent;
2009f88: c4 00 40 00 ld [ %g1 ], %g2
2009f8c: c4 26 e1 54 st %g2, [ %i3 + 0x154 ]
*_Thread_libc_reent = heir->libc_reent;
2009f90: c4 05 21 54 ld [ %l4 + 0x154 ], %g2
2009f94: c4 20 40 00 st %g2, [ %g1 ]
2009f98: 10 80 00 06 b 2009fb0 <_Thread_Dispatch+0xf8>
2009f9c: fa 04 a3 88 ld [ %l2 + 0x388 ], %i5
const User_extensions_Switch_control *extension =
(const User_extensions_Switch_control *) node;
(*extension->thread_switch)( executing, heir );
2009fa0: 90 10 00 1b mov %i3, %o0
2009fa4: 9f c0 40 00 call %g1
2009fa8: 92 10 00 14 mov %l4, %o1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(
const Chain_Node *the_node
)
{
return the_node->next;
2009fac: fa 07 40 00 ld [ %i5 ], %i5
{
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 ) {
2009fb0: 80 a7 40 13 cmp %i5, %l3
2009fb4: 32 bf ff fb bne,a 2009fa0 <_Thread_Dispatch+0xe8>
2009fb8: c2 07 60 08 ld [ %i5 + 8 ], %g1
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
2009fbc: 90 06 e0 c8 add %i3, 0xc8, %o0
2009fc0: 40 00 04 90 call 200b200 <_CPU_Context_switch>
2009fc4: 92 05 20 c8 add %l4, 0xc8, %o1
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
2009fc8: c2 06 e1 50 ld [ %i3 + 0x150 ], %g1
2009fcc: 80 a0 60 00 cmp %g1, 0
2009fd0: 02 80 00 0e be 200a008 <_Thread_Dispatch+0x150>
2009fd4: 03 00 80 75 sethi %hi(0x201d400), %g1
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
2009fd8: d0 00 62 3c ld [ %g1 + 0x23c ], %o0 ! 201d63c <_Thread_Allocated_fp>
2009fdc: 80 a6 c0 08 cmp %i3, %o0
2009fe0: 02 80 00 0a be 200a008 <_Thread_Dispatch+0x150>
2009fe4: 80 a2 20 00 cmp %o0, 0
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
2009fe8: 02 80 00 04 be 2009ff8 <_Thread_Dispatch+0x140>
2009fec: 01 00 00 00 nop
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
2009ff0: 40 00 04 4a call 200b118 <_CPU_Context_save_fp>
2009ff4: 90 02 21 50 add %o0, 0x150, %o0
_Context_Restore_fp( &executing->fp_context );
2009ff8: 40 00 04 65 call 200b18c <_CPU_Context_restore_fp>
2009ffc: 90 06 e1 50 add %i3, 0x150, %o0
_Thread_Allocated_fp = executing;
200a000: 03 00 80 75 sethi %hi(0x201d400), %g1
200a004: f6 20 62 3c st %i3, [ %g1 + 0x23c ] ! 201d63c <_Thread_Allocated_fp>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
200a008: 82 16 a2 f0 or %i2, 0x2f0, %g1
_ISR_Disable( level );
200a00c: 7f ff e1 6e call 20025c4 <sparc_disable_interrupts>
200a010: f6 00 60 10 ld [ %g1 + 0x10 ], %i3
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
200a014: 82 16 a2 f0 or %i2, 0x2f0, %g1
200a018: c4 08 60 0c ldub [ %g1 + 0xc ], %g2
200a01c: 80 a0 a0 00 cmp %g2, 0
200a020: 32 bf ff b4 bne,a 2009ef0 <_Thread_Dispatch+0x38>
200a024: e8 00 60 14 ld [ %g1 + 0x14 ], %l4
* 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;
200a028: 10 bf ff b9 b 2009f0c <_Thread_Dispatch+0x54>
200a02c: 03 00 80 75 sethi %hi(0x201d400), %g1
const API_extensions_Post_switch_control *post_switch =
(const API_extensions_Post_switch_control *) node;
(*post_switch->hook)( executing );
200a030: 9f c0 40 00 call %g1
200a034: 90 10 00 1b mov %i3, %o0
200a038: fa 07 40 00 ld [ %i5 ], %i5
{
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 ) {
200a03c: 80 a7 40 1c cmp %i5, %i4
200a040: 32 bf ff fc bne,a 200a030 <_Thread_Dispatch+0x178>
200a044: c2 07 60 08 ld [ %i5 + 8 ], %g1
#ifdef RTEMS_SMP
_Thread_Unnest_dispatch();
#endif
_API_extensions_Run_post_switch( executing );
}
200a048: 81 c7 e0 08 ret
200a04c: 81 e8 00 00 restore
0200f410 <_Thread_Handler>:
#define INIT_NAME __main
#define EXECUTE_GLOBAL_CONSTRUCTORS
#endif
void _Thread_Handler( void )
{
200f410: 9d e3 bf a0 save %sp, -96, %sp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
200f414: 03 00 80 76 sethi %hi(0x201d800), %g1
200f418: fa 00 63 00 ld [ %g1 + 0x300 ], %i5 ! 201db00 <_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();
200f41c: 3f 00 80 3d sethi %hi(0x200f400), %i7
200f420: be 17 e0 10 or %i7, 0x10, %i7 ! 200f410 <_Thread_Handler>
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
200f424: d0 07 60 a8 ld [ %i5 + 0xa8 ], %o0
_ISR_Set_level(level);
200f428: 7f ff cc 6b call 20025d4 <sparc_enable_interrupts>
200f42c: 91 2a 20 08 sll %o0, 8, %o0
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
200f430: 03 00 80 74 sethi %hi(0x201d000), %g1
doneConstructors = true;
200f434: 84 10 20 01 mov 1, %g2
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
200f438: f8 08 62 d0 ldub [ %g1 + 0x2d0 ], %i4
doneConstructors = true;
200f43c: c4 28 62 d0 stb %g2, [ %g1 + 0x2d0 ]
#endif
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
200f440: c2 07 61 50 ld [ %i5 + 0x150 ], %g1
200f444: 80 a0 60 00 cmp %g1, 0
200f448: 02 80 00 0c be 200f478 <_Thread_Handler+0x68>
200f44c: 03 00 80 75 sethi %hi(0x201d400), %g1
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
200f450: d0 00 62 3c ld [ %g1 + 0x23c ], %o0 ! 201d63c <_Thread_Allocated_fp>
200f454: 80 a7 40 08 cmp %i5, %o0
200f458: 02 80 00 08 be 200f478 <_Thread_Handler+0x68>
200f45c: 80 a2 20 00 cmp %o0, 0
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
200f460: 22 80 00 06 be,a 200f478 <_Thread_Handler+0x68>
200f464: fa 20 62 3c st %i5, [ %g1 + 0x23c ]
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
200f468: 7f ff ef 2c call 200b118 <_CPU_Context_save_fp>
200f46c: 90 02 21 50 add %o0, 0x150, %o0
_Thread_Allocated_fp = executing;
200f470: 03 00 80 75 sethi %hi(0x201d400), %g1
200f474: fa 20 62 3c st %i5, [ %g1 + 0x23c ] ! 201d63c <_Thread_Allocated_fp>
);
}
static inline void _User_extensions_Thread_begin( Thread_Control *executing )
{
_User_extensions_Iterate(
200f478: 90 10 00 1d mov %i5, %o0
200f47c: 13 00 80 2a sethi %hi(0x200a800), %o1
200f480: 7f ff ed d9 call 200abe4 <_User_extensions_Iterate>
200f484: 92 12 63 70 or %o1, 0x370, %o1 ! 200ab70 <_User_extensions_Thread_begin_visitor>
_User_extensions_Thread_begin( executing );
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
200f488: 7f ff ea f2 call 200a050 <_Thread_Enable_dispatch>
200f48c: 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) */ {
200f490: 80 8f 20 ff btst 0xff, %i4
200f494: 32 80 00 05 bne,a 200f4a8 <_Thread_Handler+0x98>
200f498: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
INIT_NAME ();
200f49c: 40 00 35 11 call 201c8e0 <_init>
200f4a0: 01 00 00 00 nop
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
200f4a4: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
200f4a8: 80 a0 60 00 cmp %g1, 0
200f4ac: 12 80 00 05 bne 200f4c0 <_Thread_Handler+0xb0>
200f4b0: 80 a0 60 01 cmp %g1, 1
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
200f4b4: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
200f4b8: 10 80 00 06 b 200f4d0 <_Thread_Handler+0xc0>
200f4bc: d0 07 60 98 ld [ %i5 + 0x98 ], %o0
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
200f4c0: 12 80 00 08 bne 200f4e0 <_Thread_Handler+0xd0> <== NEVER TAKEN
200f4c4: 90 10 00 1d mov %i5, %o0
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
200f4c8: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
200f4cc: d0 07 60 94 ld [ %i5 + 0x94 ], %o0
200f4d0: 9f c0 40 00 call %g1
200f4d4: 01 00 00 00 nop
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
200f4d8: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
}
}
static inline void _User_extensions_Thread_exitted( Thread_Control *executing )
{
_User_extensions_Iterate(
200f4dc: 90 10 00 1d mov %i5, %o0
200f4e0: 13 00 80 2a sethi %hi(0x200a800), %o1
200f4e4: 7f ff ed c0 call 200abe4 <_User_extensions_Iterate>
200f4e8: 92 12 63 94 or %o1, 0x394, %o1 ! 200ab94 <_User_extensions_Thread_exitted_visitor>
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
_Internal_error_Occurred(
200f4ec: 90 10 20 00 clr %o0
200f4f0: 92 10 20 01 mov 1, %o1
200f4f4: 7f ff e5 82 call 2008afc <_Internal_error_Occurred>
200f4f8: 94 10 20 05 mov 5, %o2
0200a33c <_Thread_Handler_initialization>:
#if defined(RTEMS_SMP)
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
200a33c: 9d e3 bf 98 save %sp, -104, %sp
uint32_t ticks_per_timeslice =
200a340: 03 00 80 69 sethi %hi(0x201a400), %g1
200a344: 82 10 63 78 or %g1, 0x378, %g1 ! 201a778 <Configuration>
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
200a348: c6 00 60 28 ld [ %g1 + 0x28 ], %g3
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
uint32_t ticks_per_timeslice =
200a34c: fa 00 60 14 ld [ %g1 + 0x14 ], %i5
rtems_configuration_get_ticks_per_timeslice();
uint32_t maximum_extensions =
200a350: 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 ||
200a354: 80 a0 e0 00 cmp %g3, 0
200a358: 02 80 00 06 be 200a370 <_Thread_Handler_initialization+0x34><== NEVER TAKEN
200a35c: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
200a360: c6 00 60 2c ld [ %g1 + 0x2c ], %g3
200a364: 80 a0 e0 00 cmp %g3, 0
200a368: 12 80 00 06 bne 200a380 <_Thread_Handler_initialization+0x44>
200a36c: 80 a0 a0 00 cmp %g2, 0
rtems_configuration_get_stack_free_hook() == NULL)
_Internal_error_Occurred(
200a370: 90 10 20 00 clr %o0
200a374: 92 10 20 01 mov 1, %o1
200a378: 7f ff f9 e1 call 2008afc <_Internal_error_Occurred>
200a37c: 94 10 20 0e mov 0xe, %o2
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
if ( stack_allocate_init_hook != NULL )
200a380: 22 80 00 05 be,a 200a394 <_Thread_Handler_initialization+0x58>
200a384: 03 00 80 76 sethi %hi(0x201d800), %g1
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
200a388: 9f c0 80 00 call %g2
200a38c: d0 00 60 04 ld [ %g1 + 4 ], %o0 ! 201d804 <_POSIX_Threads_Information+0x20>
_Thread_Dispatch_necessary = false;
200a390: 03 00 80 76 sethi %hi(0x201d800), %g1
200a394: 82 10 62 f0 or %g1, 0x2f0, %g1 ! 201daf0 <_Per_CPU_Information>
200a398: c0 28 60 0c clrb [ %g1 + 0xc ]
_Thread_Executing = NULL;
200a39c: c0 20 60 10 clr [ %g1 + 0x10 ]
_Thread_Heir = NULL;
200a3a0: c0 20 60 14 clr [ %g1 + 0x14 ]
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
200a3a4: 03 00 80 75 sethi %hi(0x201d400), %g1
200a3a8: c0 20 62 3c clr [ %g1 + 0x23c ] ! 201d63c <_Thread_Allocated_fp>
#endif
_Thread_Maximum_extensions = maximum_extensions;
200a3ac: 03 00 80 75 sethi %hi(0x201d400), %g1
200a3b0: f8 20 62 50 st %i4, [ %g1 + 0x250 ] ! 201d650 <_Thread_Maximum_extensions>
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
200a3b4: 03 00 80 75 sethi %hi(0x201d400), %g1
200a3b8: fa 20 61 30 st %i5, [ %g1 + 0x130 ] ! 201d530 <_Thread_Ticks_per_timeslice>
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
200a3bc: 82 10 20 08 mov 8, %g1
200a3c0: 11 00 80 75 sethi %hi(0x201d400), %o0
200a3c4: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
200a3c8: 90 12 22 c4 or %o0, 0x2c4, %o0
200a3cc: 92 10 20 01 mov 1, %o1
200a3d0: 94 10 20 01 mov 1, %o2
200a3d4: 96 10 20 01 mov 1, %o3
200a3d8: 98 10 21 68 mov 0x168, %o4
200a3dc: 7f ff fb 58 call 200913c <_Objects_Initialize_information>
200a3e0: 9a 10 20 00 clr %o5
200a3e4: 81 c7 e0 08 ret
200a3e8: 81 e8 00 00 restore
0200a130 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
200a130: 9d e3 bf 98 save %sp, -104, %sp
200a134: 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;
200a138: c0 26 61 58 clr [ %i1 + 0x158 ]
200a13c: c0 26 61 5c clr [ %i1 + 0x15c ]
extensions_area = NULL;
the_thread->libc_reent = NULL;
200a140: 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
)
{
200a144: e0 07 a0 60 ld [ %fp + 0x60 ], %l0
200a148: 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 ) {
200a14c: 80 a6 a0 00 cmp %i2, 0
200a150: 12 80 00 0d bne 200a184 <_Thread_Initialize+0x54>
200a154: e4 0f a0 5f ldub [ %fp + 0x5f ], %l2
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
200a158: 90 10 00 19 mov %i1, %o0
200a15c: 40 00 02 15 call 200a9b0 <_Thread_Stack_Allocate>
200a160: 92 10 00 1b mov %i3, %o1
if ( !actual_stack_size || actual_stack_size < stack_size )
200a164: 80 a2 00 1b cmp %o0, %i3
200a168: 0a 80 00 71 bcs 200a32c <_Thread_Initialize+0x1fc>
200a16c: 80 a2 20 00 cmp %o0, 0
200a170: 02 80 00 6f be 200a32c <_Thread_Initialize+0x1fc> <== NEVER TAKEN
200a174: 82 10 20 01 mov 1, %g1
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
200a178: f4 06 60 c0 ld [ %i1 + 0xc0 ], %i2
the_thread->Start.core_allocated_stack = true;
200a17c: 10 80 00 04 b 200a18c <_Thread_Initialize+0x5c>
200a180: c2 2e 60 b0 stb %g1, [ %i1 + 0xb0 ]
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
200a184: c0 2e 60 b0 clrb [ %i1 + 0xb0 ]
200a188: 90 10 00 1b mov %i3, %o0
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
200a18c: f4 26 60 b8 st %i2, [ %i1 + 0xb8 ]
the_stack->size = size;
200a190: 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 ) {
200a194: 80 a7 20 00 cmp %i4, 0
200a198: 02 80 00 07 be 200a1b4 <_Thread_Initialize+0x84>
200a19c: b6 10 20 00 clr %i3
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
200a1a0: 40 00 03 c2 call 200b0a8 <_Workspace_Allocate>
200a1a4: 90 10 20 88 mov 0x88, %o0
if ( !fp_area )
200a1a8: b6 92 20 00 orcc %o0, 0, %i3
200a1ac: 22 80 00 51 be,a 200a2f0 <_Thread_Initialize+0x1c0>
200a1b0: b8 10 20 00 clr %i4
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
200a1b4: 03 00 80 75 sethi %hi(0x201d400), %g1
200a1b8: d0 00 62 50 ld [ %g1 + 0x250 ], %o0 ! 201d650 <_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;
200a1bc: f6 26 61 50 st %i3, [ %i1 + 0x150 ]
the_thread->Start.fp_context = fp_area;
200a1c0: f6 26 60 bc st %i3, [ %i1 + 0xbc ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
200a1c4: c0 26 60 50 clr [ %i1 + 0x50 ]
the_watchdog->routine = routine;
200a1c8: c0 26 60 64 clr [ %i1 + 0x64 ]
the_watchdog->id = id;
200a1cc: c0 26 60 68 clr [ %i1 + 0x68 ]
the_watchdog->user_data = user_data;
200a1d0: c0 26 60 6c clr [ %i1 + 0x6c ]
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
200a1d4: 80 a2 20 00 cmp %o0, 0
200a1d8: 02 80 00 08 be 200a1f8 <_Thread_Initialize+0xc8>
200a1dc: b8 10 20 00 clr %i4
extensions_area = _Workspace_Allocate(
200a1e0: 90 02 20 01 inc %o0
200a1e4: 40 00 03 b1 call 200b0a8 <_Workspace_Allocate>
200a1e8: 91 2a 20 02 sll %o0, 2, %o0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
200a1ec: b8 92 20 00 orcc %o0, 0, %i4
200a1f0: 02 80 00 41 be 200a2f4 <_Thread_Initialize+0x1c4>
200a1f4: b4 10 20 00 clr %i2
* if they are linked to the thread. An extension user may
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
200a1f8: 80 a7 20 00 cmp %i4, 0
200a1fc: 12 80 00 0a bne 200a224 <_Thread_Initialize+0xf4>
200a200: f8 26 61 60 st %i4, [ %i1 + 0x160 ]
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
200a204: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
200a208: e4 2e 60 9c stb %l2, [ %i1 + 0x9c ]
the_thread->Start.budget_algorithm = budget_algorithm;
200a20c: e0 26 60 a0 st %l0, [ %i1 + 0xa0 ]
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
200a210: 80 a4 20 02 cmp %l0, 2
200a214: 12 80 00 12 bne 200a25c <_Thread_Initialize+0x12c>
200a218: 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;
200a21c: 10 80 00 0e b 200a254 <_Thread_Initialize+0x124>
200a220: 03 00 80 75 sethi %hi(0x201d400), %g1
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
200a224: 03 00 80 75 sethi %hi(0x201d400), %g1
200a228: c4 00 62 50 ld [ %g1 + 0x250 ], %g2 ! 201d650 <_Thread_Maximum_extensions>
200a22c: 10 80 00 05 b 200a240 <_Thread_Initialize+0x110>
200a230: 82 10 20 00 clr %g1
the_thread->extensions[i] = NULL;
200a234: 87 28 60 02 sll %g1, 2, %g3
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
200a238: 82 00 60 01 inc %g1
the_thread->extensions[i] = NULL;
200a23c: c0 21 00 03 clr [ %g4 + %g3 ]
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
200a240: 80 a0 40 02 cmp %g1, %g2
200a244: 28 bf ff fc bleu,a 200a234 <_Thread_Initialize+0x104>
200a248: c8 06 61 60 ld [ %i1 + 0x160 ], %g4
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
200a24c: 10 bf ff ef b 200a208 <_Thread_Initialize+0xd8>
200a250: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
200a254: c2 00 61 30 ld [ %g1 + 0x130 ], %g1
200a258: c2 26 60 74 st %g1, [ %i1 + 0x74 ]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
200a25c: c2 07 a0 68 ld [ %fp + 0x68 ], %g1
the_thread->current_state = STATES_DORMANT;
200a260: a0 10 20 01 mov 1, %l0
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
200a264: c2 26 60 a8 st %g1, [ %i1 + 0xa8 ]
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
200a268: 03 00 80 72 sethi %hi(0x201c800), %g1
200a26c: c2 00 61 cc ld [ %g1 + 0x1cc ], %g1 ! 201c9cc <_Scheduler+0x18>
the_thread->current_state = STATES_DORMANT;
200a270: e0 26 60 10 st %l0, [ %i1 + 0x10 ]
the_thread->Wait.queue = NULL;
200a274: c0 26 60 44 clr [ %i1 + 0x44 ]
the_thread->resource_count = 0;
200a278: c0 26 60 1c clr [ %i1 + 0x1c ]
the_thread->real_priority = priority;
200a27c: fa 26 60 18 st %i5, [ %i1 + 0x18 ]
the_thread->Start.initial_priority = priority;
200a280: fa 26 60 ac st %i5, [ %i1 + 0xac ]
200a284: 9f c0 40 00 call %g1
200a288: 90 10 00 19 mov %i1, %o0
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
200a28c: b4 92 20 00 orcc %o0, 0, %i2
200a290: 02 80 00 19 be 200a2f4 <_Thread_Initialize+0x1c4>
200a294: 90 10 00 19 mov %i1, %o0
goto failed;
_Thread_Set_priority( the_thread, priority );
200a298: 40 00 01 9e call 200a910 <_Thread_Set_priority>
200a29c: 92 10 00 1d mov %i5, %o1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200a2a0: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
200a2a4: c2 16 60 0a lduh [ %i1 + 0xa ], %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
200a2a8: c0 26 60 80 clr [ %i1 + 0x80 ]
200a2ac: c0 26 60 84 clr [ %i1 + 0x84 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200a2b0: 83 28 60 02 sll %g1, 2, %g1
200a2b4: f2 20 80 01 st %i1, [ %g2 + %g1 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
200a2b8: 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 };
200a2bc: f2 27 bf f8 st %i1, [ %fp + -8 ]
200a2c0: e0 2f bf fc stb %l0, [ %fp + -4 ]
_User_extensions_Iterate( &ctx, _User_extensions_Thread_create_visitor );
200a2c4: 90 07 bf f8 add %fp, -8, %o0
200a2c8: 13 00 80 2a sethi %hi(0x200a800), %o1
200a2cc: 40 00 02 46 call 200abe4 <_User_extensions_Iterate>
200a2d0: 92 12 62 c0 or %o1, 0x2c0, %o1 ! 200aac0 <_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 )
200a2d4: c2 0f bf fc ldub [ %fp + -4 ], %g1
200a2d8: 80 a0 60 00 cmp %g1, 0
200a2dc: 02 80 00 06 be 200a2f4 <_Thread_Initialize+0x1c4>
200a2e0: b0 10 20 01 mov 1, %i0
200a2e4: b0 0e 20 01 and %i0, 1, %i0
200a2e8: 81 c7 e0 08 ret
200a2ec: 81 e8 00 00 restore
size_t actual_stack_size = 0;
void *stack = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
void *fp_area;
#endif
void *sched = NULL;
200a2f0: b4 10 20 00 clr %i2
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
200a2f4: 40 00 03 75 call 200b0c8 <_Workspace_Free>
200a2f8: d0 06 61 54 ld [ %i1 + 0x154 ], %o0
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
200a2fc: 40 00 03 73 call 200b0c8 <_Workspace_Free>
200a300: d0 06 61 58 ld [ %i1 + 0x158 ], %o0
200a304: 40 00 03 71 call 200b0c8 <_Workspace_Free>
200a308: d0 06 61 5c ld [ %i1 + 0x15c ], %o0
_Workspace_Free( extensions_area );
200a30c: 40 00 03 6f call 200b0c8 <_Workspace_Free>
200a310: 90 10 00 1c mov %i4, %o0
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
200a314: 40 00 03 6d call 200b0c8 <_Workspace_Free>
200a318: 90 10 00 1b mov %i3, %o0
#endif
_Workspace_Free( sched );
200a31c: 40 00 03 6b call 200b0c8 <_Workspace_Free>
200a320: 90 10 00 1a mov %i2, %o0
_Thread_Stack_Free( the_thread );
200a324: 40 00 01 b3 call 200a9f0 <_Thread_Stack_Free>
200a328: 90 10 00 19 mov %i1, %o0
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
200a32c: b0 10 20 00 clr %i0
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
200a330: b0 0e 20 01 and %i0, 1, %i0
200a334: 81 c7 e0 08 ret
200a338: 81 e8 00 00 restore
0200a9f0 <_Thread_Stack_Free>:
#include <rtems/config.h>
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
200a9f0: 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 )
200a9f4: c4 0e 20 b0 ldub [ %i0 + 0xb0 ], %g2
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
rtems_stack_free_hook stack_free_hook =
200a9f8: 03 00 80 69 sethi %hi(0x201a400), %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 )
200a9fc: 80 a0 a0 00 cmp %g2, 0
200aa00: 02 80 00 04 be 200aa10 <_Thread_Stack_Free+0x20> <== NEVER TAKEN
200aa04: c2 00 63 a4 ld [ %g1 + 0x3a4 ], %g1
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
(*stack_free_hook)( the_thread->Start.Initial_stack.area );
200aa08: 9f c0 40 00 call %g1
200aa0c: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
200aa10: 81 c7 e0 08 ret
200aa14: 81 e8 00 00 restore
0200a85c <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
200a85c: 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 )
200a860: 80 a6 20 00 cmp %i0, 0
200a864: 02 80 00 19 be 200a8c8 <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
200a868: 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 ) {
200a86c: fa 06 20 34 ld [ %i0 + 0x34 ], %i5
200a870: 80 a7 60 01 cmp %i5, 1
200a874: 12 80 00 15 bne 200a8c8 <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
200a878: 01 00 00 00 nop
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
200a87c: 7f ff df 52 call 20025c4 <sparc_disable_interrupts>
200a880: 01 00 00 00 nop
200a884: b8 10 00 08 mov %o0, %i4
200a888: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
200a88c: 03 00 00 ef sethi %hi(0x3bc00), %g1
200a890: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
200a894: 80 88 80 01 btst %g2, %g1
200a898: 02 80 00 0a be 200a8c0 <_Thread_queue_Requeue+0x64> <== NEVER TAKEN
200a89c: 90 10 00 18 mov %i0, %o0
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
200a8a0: 92 10 00 19 mov %i1, %o1
200a8a4: 94 10 20 01 mov 1, %o2
200a8a8: 40 00 0c 81 call 200daac <_Thread_queue_Extract_priority_helper>
200a8ac: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
200a8b0: 90 10 00 18 mov %i0, %o0
200a8b4: 92 10 00 19 mov %i1, %o1
200a8b8: 7f ff ff 50 call 200a5f8 <_Thread_queue_Enqueue_priority>
200a8bc: 94 07 bf fc add %fp, -4, %o2
}
_ISR_Enable( level );
200a8c0: 7f ff df 45 call 20025d4 <sparc_enable_interrupts>
200a8c4: 90 10 00 1c mov %i4, %o0
200a8c8: 81 c7 e0 08 ret
200a8cc: 81 e8 00 00 restore
0200a8d0 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
200a8d0: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200a8d4: 90 10 00 18 mov %i0, %o0
200a8d8: 7f ff fd ea call 200a080 <_Thread_Get>
200a8dc: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a8e0: c2 07 bf fc ld [ %fp + -4 ], %g1
200a8e4: 80 a0 60 00 cmp %g1, 0
200a8e8: 12 80 00 08 bne 200a908 <_Thread_queue_Timeout+0x38> <== NEVER TAKEN
200a8ec: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
200a8f0: 40 00 0c a6 call 200db88 <_Thread_queue_Process_timeout>
200a8f4: 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;
200a8f8: 03 00 80 75 sethi %hi(0x201d400), %g1
200a8fc: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 201d5d0 <_Thread_Dispatch_disable_level>
--level;
200a900: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
200a904: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ]
200a908: 81 c7 e0 08 ret
200a90c: 81 e8 00 00 restore
020189dc <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
20189dc: 9d e3 bf 88 save %sp, -120, %sp
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
20189e0: 27 00 80 f2 sethi %hi(0x203c800), %l3
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
20189e4: a4 07 bf e8 add %fp, -24, %l2
20189e8: aa 07 bf ec add %fp, -20, %l5
20189ec: b8 07 bf f4 add %fp, -12, %i4
20189f0: b2 07 bf f8 add %fp, -8, %i1
20189f4: ea 27 bf e8 st %l5, [ %fp + -24 ]
head->previous = NULL;
20189f8: c0 27 bf ec clr [ %fp + -20 ]
tail->previous = head;
20189fc: 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;
2018a00: f2 27 bf f4 st %i1, [ %fp + -12 ]
head->previous = NULL;
2018a04: c0 27 bf f8 clr [ %fp + -8 ]
tail->previous = head;
2018a08: f8 27 bf fc st %i4, [ %fp + -4 ]
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
2018a0c: b4 06 20 30 add %i0, 0x30, %i2
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
2018a10: 29 00 80 f2 sethi %hi(0x203c800), %l4
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
2018a14: b6 06 20 68 add %i0, 0x68, %i3
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
2018a18: a2 06 20 08 add %i0, 8, %l1
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
2018a1c: a0 06 20 40 add %i0, 0x40, %l0
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
2018a20: 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;
2018a24: c2 04 e2 9c ld [ %l3 + 0x29c ], %g1
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
2018a28: d2 06 20 3c ld [ %i0 + 0x3c ], %o1
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
2018a2c: 90 10 00 1a mov %i2, %o0
2018a30: 92 20 40 09 sub %g1, %o1, %o1
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
2018a34: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
2018a38: 40 00 11 ce call 201d170 <_Watchdog_Adjust_to_chain>
2018a3c: 94 10 00 1c mov %i4, %o2
2018a40: d0 1d 20 f8 ldd [ %l4 + 0xf8 ], %o0
2018a44: 94 10 20 00 clr %o2
2018a48: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2018a4c: 40 00 4f 4b call 202c778 <__divdi3>
2018a50: 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;
2018a54: 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 ) {
2018a58: 80 a2 40 0a cmp %o1, %o2
2018a5c: 08 80 00 07 bleu 2018a78 <_Timer_server_Body+0x9c>
2018a60: ba 10 00 09 mov %o1, %i5
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
2018a64: 92 22 40 0a sub %o1, %o2, %o1
2018a68: 90 10 00 1b mov %i3, %o0
2018a6c: 40 00 11 c1 call 201d170 <_Watchdog_Adjust_to_chain>
2018a70: 94 10 00 1c mov %i4, %o2
2018a74: 30 80 00 06 b,a 2018a8c <_Timer_server_Body+0xb0>
} else if ( snapshot < last_snapshot ) {
2018a78: 1a 80 00 05 bcc 2018a8c <_Timer_server_Body+0xb0>
2018a7c: 90 10 00 1b mov %i3, %o0
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
2018a80: 92 10 20 01 mov 1, %o1
2018a84: 40 00 11 93 call 201d0d0 <_Watchdog_Adjust>
2018a88: 94 22 80 1d sub %o2, %i5, %o2
}
watchdogs->last_snapshot = snapshot;
2018a8c: fa 26 20 74 st %i5, [ %i0 + 0x74 ]
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
2018a90: d0 06 20 78 ld [ %i0 + 0x78 ], %o0
2018a94: 40 00 02 f4 call 2019664 <_Chain_Get>
2018a98: 01 00 00 00 nop
if ( timer == NULL ) {
2018a9c: 92 92 20 00 orcc %o0, 0, %o1
2018aa0: 02 80 00 0c be 2018ad0 <_Timer_server_Body+0xf4>
2018aa4: 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 ) {
2018aa8: c2 02 60 38 ld [ %o1 + 0x38 ], %g1
2018aac: 80 a0 60 01 cmp %g1, 1
2018ab0: 02 80 00 05 be 2018ac4 <_Timer_server_Body+0xe8>
2018ab4: 90 10 00 1a mov %i2, %o0
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
2018ab8: 80 a0 60 03 cmp %g1, 3
2018abc: 12 bf ff f5 bne 2018a90 <_Timer_server_Body+0xb4> <== NEVER TAKEN
2018ac0: 90 10 00 1b mov %i3, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
2018ac4: 40 00 11 d5 call 201d218 <_Watchdog_Insert>
2018ac8: 92 02 60 10 add %o1, 0x10, %o1
2018acc: 30 bf ff f1 b,a 2018a90 <_Timer_server_Body+0xb4>
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
2018ad0: 7f ff df 18 call 2010730 <sparc_disable_interrupts>
2018ad4: 01 00 00 00 nop
if ( _Chain_Is_empty( insert_chain ) ) {
2018ad8: c2 07 bf e8 ld [ %fp + -24 ], %g1
2018adc: 80 a0 40 15 cmp %g1, %l5
2018ae0: 12 80 00 0a bne 2018b08 <_Timer_server_Body+0x12c> <== NEVER TAKEN
2018ae4: 01 00 00 00 nop
ts->insert_chain = NULL;
2018ae8: c0 26 20 78 clr [ %i0 + 0x78 ]
_ISR_Enable( level );
2018aec: 7f ff df 15 call 2010740 <sparc_enable_interrupts>
2018af0: 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 ) ) {
2018af4: c2 07 bf f4 ld [ %fp + -12 ], %g1
2018af8: 80 a0 40 19 cmp %g1, %i1
2018afc: 12 80 00 06 bne 2018b14 <_Timer_server_Body+0x138>
2018b00: 01 00 00 00 nop
2018b04: 30 80 00 18 b,a 2018b64 <_Timer_server_Body+0x188>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
2018b08: 7f ff df 0e call 2010740 <sparc_enable_interrupts> <== NOT EXECUTED
2018b0c: 01 00 00 00 nop <== NOT EXECUTED
2018b10: 30 bf ff c5 b,a 2018a24 <_Timer_server_Body+0x48> <== NOT EXECUTED
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
2018b14: 7f ff df 07 call 2010730 <sparc_disable_interrupts>
2018b18: 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;
2018b1c: fa 07 bf f4 ld [ %fp + -12 ], %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
2018b20: 80 a7 40 19 cmp %i5, %i1
2018b24: 02 80 00 0d be 2018b58 <_Timer_server_Body+0x17c>
2018b28: 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;
2018b2c: c2 07 40 00 ld [ %i5 ], %g1
head->next = new_first;
new_first->previous = head;
2018b30: 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;
2018b34: c2 27 bf f4 st %g1, [ %fp + -12 ]
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
2018b38: c0 27 60 08 clr [ %i5 + 8 ]
_ISR_Enable( level );
2018b3c: 7f ff df 01 call 2010740 <sparc_enable_interrupts>
2018b40: 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 );
2018b44: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
2018b48: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
2018b4c: 9f c0 40 00 call %g1
2018b50: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
}
2018b54: 30 bf ff f0 b,a 2018b14 <_Timer_server_Body+0x138>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
2018b58: 7f ff de fa call 2010740 <sparc_enable_interrupts>
2018b5c: 01 00 00 00 nop
2018b60: 30 bf ff b0 b,a 2018a20 <_Timer_server_Body+0x44>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
2018b64: 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;
2018b68: 03 00 80 f2 sethi %hi(0x203c800), %g1
2018b6c: c4 00 61 b0 ld [ %g1 + 0x1b0 ], %g2 ! 203c9b0 <_Thread_Dispatch_disable_level>
++level;
2018b70: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2018b74: c4 20 61 b0 st %g2, [ %g1 + 0x1b0 ]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
2018b78: d0 06 00 00 ld [ %i0 ], %o0
2018b7c: 40 00 10 68 call 201cd1c <_Thread_Set_state>
2018b80: 92 10 20 08 mov 8, %o1
_Timer_server_Reset_interval_system_watchdog( ts );
2018b84: 7f ff ff 6e call 201893c <_Timer_server_Reset_interval_system_watchdog>
2018b88: 90 10 00 18 mov %i0, %o0
_Timer_server_Reset_tod_system_watchdog( ts );
2018b8c: 7f ff ff 80 call 201898c <_Timer_server_Reset_tod_system_watchdog>
2018b90: 90 10 00 18 mov %i0, %o0
_Thread_Enable_dispatch();
2018b94: 40 00 0e 05 call 201c3a8 <_Thread_Enable_dispatch>
2018b98: 01 00 00 00 nop
ts->active = true;
2018b9c: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
2018ba0: 90 10 00 11 mov %l1, %o0
_Thread_Set_state( ts->thread, STATES_DELAYING );
_Timer_server_Reset_interval_system_watchdog( ts );
_Timer_server_Reset_tod_system_watchdog( ts );
_Thread_Enable_dispatch();
ts->active = true;
2018ba4: c2 2e 20 7c stb %g1, [ %i0 + 0x7c ]
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
2018ba8: 40 00 11 f4 call 201d378 <_Watchdog_Remove>
2018bac: 01 00 00 00 nop
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
2018bb0: 40 00 11 f2 call 201d378 <_Watchdog_Remove>
2018bb4: 90 10 00 10 mov %l0, %o0
2018bb8: 30 bf ff 9a b,a 2018a20 <_Timer_server_Body+0x44>
02018bbc <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
2018bbc: 9d e3 bf a0 save %sp, -96, %sp
if ( ts->insert_chain == NULL ) {
2018bc0: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
2018bc4: 80 a0 60 00 cmp %g1, 0
2018bc8: 12 80 00 51 bne 2018d0c <_Timer_server_Schedule_operation_method+0x150>
2018bcc: ba 10 00 19 mov %i1, %i5
*
* 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;
2018bd0: 03 00 80 f2 sethi %hi(0x203c800), %g1
2018bd4: c4 00 61 b0 ld [ %g1 + 0x1b0 ], %g2 ! 203c9b0 <_Thread_Dispatch_disable_level>
++level;
2018bd8: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2018bdc: c4 20 61 b0 st %g2, [ %g1 + 0x1b0 ]
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
2018be0: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
2018be4: 80 a0 60 01 cmp %g1, 1
2018be8: 12 80 00 1f bne 2018c64 <_Timer_server_Schedule_operation_method+0xa8>
2018bec: 80 a0 60 03 cmp %g1, 3
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
2018bf0: 7f ff de d0 call 2010730 <sparc_disable_interrupts>
2018bf4: 01 00 00 00 nop
snapshot = _Watchdog_Ticks_since_boot;
2018bf8: 03 00 80 f2 sethi %hi(0x203c800), %g1
2018bfc: c4 00 62 9c ld [ %g1 + 0x29c ], %g2 ! 203ca9c <_Watchdog_Ticks_since_boot>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
2018c00: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
last_snapshot = ts->Interval_watchdogs.last_snapshot;
2018c04: 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 );
2018c08: 86 06 20 34 add %i0, 0x34, %g3
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
2018c0c: 80 a0 40 03 cmp %g1, %g3
2018c10: 02 80 00 08 be 2018c30 <_Timer_server_Schedule_operation_method+0x74>
2018c14: 88 20 80 04 sub %g2, %g4, %g4
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
2018c18: f8 00 60 10 ld [ %g1 + 0x10 ], %i4
if (delta_interval > delta) {
2018c1c: 80 a7 00 04 cmp %i4, %g4
2018c20: 08 80 00 03 bleu 2018c2c <_Timer_server_Schedule_operation_method+0x70>
2018c24: 86 10 20 00 clr %g3
delta_interval -= delta;
2018c28: 86 27 00 04 sub %i4, %g4, %g3
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
2018c2c: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
}
ts->Interval_watchdogs.last_snapshot = snapshot;
2018c30: c4 26 20 3c st %g2, [ %i0 + 0x3c ]
_ISR_Enable( level );
2018c34: 7f ff de c3 call 2010740 <sparc_enable_interrupts>
2018c38: 01 00 00 00 nop
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
2018c3c: 90 06 20 30 add %i0, 0x30, %o0
2018c40: 40 00 11 76 call 201d218 <_Watchdog_Insert>
2018c44: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
2018c48: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
2018c4c: 80 a0 60 00 cmp %g1, 0
2018c50: 12 80 00 2d bne 2018d04 <_Timer_server_Schedule_operation_method+0x148>
2018c54: 01 00 00 00 nop
_Timer_server_Reset_interval_system_watchdog( ts );
2018c58: 7f ff ff 39 call 201893c <_Timer_server_Reset_interval_system_watchdog>
2018c5c: 90 10 00 18 mov %i0, %o0
2018c60: 30 80 00 29 b,a 2018d04 <_Timer_server_Schedule_operation_method+0x148>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
2018c64: 12 80 00 28 bne 2018d04 <_Timer_server_Schedule_operation_method+0x148>
2018c68: 01 00 00 00 nop
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
2018c6c: 7f ff de b1 call 2010730 <sparc_disable_interrupts>
2018c70: 01 00 00 00 nop
2018c74: b8 10 00 08 mov %o0, %i4
2018c78: 03 00 80 f2 sethi %hi(0x203c800), %g1
2018c7c: d0 18 60 f8 ldd [ %g1 + 0xf8 ], %o0 ! 203c8f8 <_TOD>
2018c80: 94 10 20 00 clr %o2
2018c84: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2018c88: 40 00 4e bc call 202c778 <__divdi3>
2018c8c: 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;
2018c90: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
2018c94: 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 );
2018c98: 86 06 20 6c add %i0, 0x6c, %g3
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
2018c9c: 80 a0 40 03 cmp %g1, %g3
2018ca0: 02 80 00 0d be 2018cd4 <_Timer_server_Schedule_operation_method+0x118>
2018ca4: 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 ) {
2018ca8: 08 80 00 08 bleu 2018cc8 <_Timer_server_Schedule_operation_method+0x10c>
2018cac: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
2018cb0: 88 22 40 02 sub %o1, %g2, %g4
if (delta_interval > delta) {
2018cb4: 80 a0 c0 04 cmp %g3, %g4
2018cb8: 08 80 00 06 bleu 2018cd0 <_Timer_server_Schedule_operation_method+0x114><== NEVER TAKEN
2018cbc: 84 10 20 00 clr %g2
delta_interval -= delta;
2018cc0: 10 80 00 04 b 2018cd0 <_Timer_server_Schedule_operation_method+0x114>
2018cc4: 84 20 c0 04 sub %g3, %g4, %g2
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
2018cc8: 84 00 c0 02 add %g3, %g2, %g2
delta_interval += delta;
2018ccc: 84 20 80 09 sub %g2, %o1, %g2
}
first_watchdog->delta_interval = delta_interval;
2018cd0: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
}
ts->TOD_watchdogs.last_snapshot = snapshot;
2018cd4: d2 26 20 74 st %o1, [ %i0 + 0x74 ]
_ISR_Enable( level );
2018cd8: 7f ff de 9a call 2010740 <sparc_enable_interrupts>
2018cdc: 90 10 00 1c mov %i4, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
2018ce0: 90 06 20 68 add %i0, 0x68, %o0
2018ce4: 40 00 11 4d call 201d218 <_Watchdog_Insert>
2018ce8: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
2018cec: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
2018cf0: 80 a0 60 00 cmp %g1, 0
2018cf4: 12 80 00 04 bne 2018d04 <_Timer_server_Schedule_operation_method+0x148>
2018cf8: 01 00 00 00 nop
_Timer_server_Reset_tod_system_watchdog( ts );
2018cfc: 7f ff ff 24 call 201898c <_Timer_server_Reset_tod_system_watchdog>
2018d00: 90 10 00 18 mov %i0, %o0
}
}
_Thread_Enable_dispatch();
2018d04: 40 00 0d a9 call 201c3a8 <_Thread_Enable_dispatch>
2018d08: 81 e8 00 00 restore
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
2018d0c: f0 06 20 78 ld [ %i0 + 0x78 ], %i0
2018d10: 40 00 02 49 call 2019634 <_Chain_Append>
2018d14: 81 e8 00 00 restore
0200c3b4 <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
200c3b4: 9d e3 bf a0 save %sp, -96, %sp
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
200c3b8: d4 1e 40 00 ldd [ %i1 ], %o2
200c3bc: 80 92 80 0b orcc %o2, %o3, %g0
200c3c0: 32 80 00 06 bne,a 200c3d8 <_Timestamp64_Divide+0x24> <== ALWAYS TAKEN
200c3c4: d8 1e 00 00 ldd [ %i0 ], %o4
*_ival_percentage = 0;
200c3c8: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
*_fval_percentage = 0;
200c3cc: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
return;
200c3d0: 81 c7 e0 08 ret <== NOT EXECUTED
200c3d4: 81 e8 00 00 restore <== NOT EXECUTED
* This looks odd but gives the results the proper precision.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
200c3d8: 83 2b 20 02 sll %o4, 2, %g1
200c3dc: 87 2b 60 02 sll %o5, 2, %g3
200c3e0: 89 33 60 1e srl %o5, 0x1e, %g4
200c3e4: bb 28 e0 05 sll %g3, 5, %i5
200c3e8: 84 11 00 01 or %g4, %g1, %g2
200c3ec: 83 30 e0 1b srl %g3, 0x1b, %g1
200c3f0: b9 28 a0 05 sll %g2, 5, %i4
200c3f4: 86 a7 40 03 subcc %i5, %g3, %g3
200c3f8: b8 10 40 1c or %g1, %i4, %i4
200c3fc: 84 67 00 02 subx %i4, %g2, %g2
200c400: b2 80 c0 0d addcc %g3, %o5, %i1
200c404: b0 40 80 0c addx %g2, %o4, %i0
200c408: 83 36 60 1e srl %i1, 0x1e, %g1
200c40c: 87 2e 60 02 sll %i1, 2, %g3
200c410: 85 2e 20 02 sll %i0, 2, %g2
200c414: 84 10 40 02 or %g1, %g2, %g2
200c418: ba 86 40 03 addcc %i1, %g3, %i5
200c41c: b8 46 00 02 addx %i0, %g2, %i4
200c420: 83 37 60 1e srl %i5, 0x1e, %g1
200c424: 87 2f 60 02 sll %i5, 2, %g3
200c428: 85 2f 20 02 sll %i4, 2, %g2
200c42c: 84 10 40 02 or %g1, %g2, %g2
200c430: 92 87 40 03 addcc %i5, %g3, %o1
200c434: 90 47 00 02 addx %i4, %g2, %o0
200c438: 87 32 60 1b srl %o1, 0x1b, %g3
200c43c: 85 2a 20 05 sll %o0, 5, %g2
200c440: 83 2a 60 05 sll %o1, 5, %g1
200c444: 90 10 c0 02 or %g3, %g2, %o0
200c448: 40 00 39 f4 call 201ac18 <__divdi3>
200c44c: 92 10 00 01 mov %g1, %o1
*_ival_percentage = answer / 1000;
200c450: 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;
200c454: b8 10 00 08 mov %o0, %i4
200c458: ba 10 00 09 mov %o1, %i5
*_ival_percentage = answer / 1000;
200c45c: 40 00 39 ef call 201ac18 <__divdi3>
200c460: 96 10 23 e8 mov 0x3e8, %o3
*_fval_percentage = answer % 1000;
200c464: 90 10 00 1c mov %i4, %o0
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
200c468: d2 26 80 00 st %o1, [ %i2 ]
*_fval_percentage = answer % 1000;
200c46c: 94 10 20 00 clr %o2
200c470: 92 10 00 1d mov %i5, %o1
200c474: 40 00 3a d4 call 201afc4 <__moddi3>
200c478: 96 10 23 e8 mov 0x3e8, %o3
200c47c: d2 26 c0 00 st %o1, [ %i3 ]
200c480: 81 c7 e0 08 ret
200c484: 81 e8 00 00 restore
0200aca4 <_User_extensions_Handler_initialization>:
}
}
void _User_extensions_Handler_initialization(void)
{
200aca4: 9d e3 bf 98 save %sp, -104, %sp
uint32_t number_of_initial_extensions =
200aca8: 03 00 80 69 sethi %hi(0x201a400), %g1
200acac: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 201a7b8 <Configuration+0x40>
rtems_configuration_get_number_of_initial_extensions();
if ( number_of_initial_extensions > 0 ) {
200acb0: 80 a0 60 00 cmp %g1, 0
200acb4: 02 80 00 0a be 200acdc <_User_extensions_Handler_initialization+0x38><== NEVER TAKEN
200acb8: 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 )
200acbc: 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 =
200acc0: 40 00 01 08 call 200b0e0 <_Workspace_Allocate_or_fatal_error>
200acc4: 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 );
200acc8: 13 00 80 2b sethi %hi(0x200ac00), %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 };
200accc: d0 27 bf fc st %o0, [ %fp + -4 ]
_User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
200acd0: 92 12 60 60 or %o1, 0x60, %o1
200acd4: 7f ff ff c4 call 200abe4 <_User_extensions_Iterate>
200acd8: 90 07 bf fc add %fp, -4, %o0
200acdc: 81 c7 e0 08 ret
200ace0: 81 e8 00 00 restore
0200c6ec <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
200c6ec: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
_ISR_Disable( level );
200c6f0: 7f ff db 47 call 200340c <sparc_disable_interrupts>
200c6f4: 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;
200c6f8: 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 );
200c6fc: 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 ) ) {
200c700: 80 a0 40 1c cmp %g1, %i4
200c704: 02 80 00 20 be 200c784 <_Watchdog_Adjust+0x98>
200c708: 80 a6 60 00 cmp %i1, 0
switch ( direction ) {
200c70c: 02 80 00 1b be 200c778 <_Watchdog_Adjust+0x8c>
200c710: b6 10 20 01 mov 1, %i3
200c714: 80 a6 60 01 cmp %i1, 1
200c718: 12 80 00 1b bne 200c784 <_Watchdog_Adjust+0x98> <== NEVER TAKEN
200c71c: 01 00 00 00 nop
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
200c720: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200c724: 10 80 00 07 b 200c740 <_Watchdog_Adjust+0x54>
200c728: b4 00 80 1a add %g2, %i2, %i2
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
200c72c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200c730: 80 a6 80 02 cmp %i2, %g2
200c734: 3a 80 00 05 bcc,a 200c748 <_Watchdog_Adjust+0x5c>
200c738: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
_Watchdog_First( header )->delta_interval -= units;
200c73c: b4 20 80 1a sub %g2, %i2, %i2
break;
200c740: 10 80 00 11 b 200c784 <_Watchdog_Adjust+0x98>
200c744: f4 20 60 10 st %i2, [ %g1 + 0x10 ]
} else {
units -= _Watchdog_First( header )->delta_interval;
200c748: b4 26 80 02 sub %i2, %g2, %i2
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
200c74c: 7f ff db 34 call 200341c <sparc_enable_interrupts>
200c750: 01 00 00 00 nop
_Watchdog_Tickle( header );
200c754: 40 00 00 90 call 200c994 <_Watchdog_Tickle>
200c758: 90 10 00 18 mov %i0, %o0
_ISR_Disable( level );
200c75c: 7f ff db 2c call 200340c <sparc_disable_interrupts>
200c760: 01 00 00 00 nop
if ( _Chain_Is_empty( header ) )
200c764: c2 06 00 00 ld [ %i0 ], %g1
200c768: 80 a0 40 1c cmp %g1, %i4
200c76c: 12 80 00 04 bne 200c77c <_Watchdog_Adjust+0x90>
200c770: 80 a6 a0 00 cmp %i2, 0
200c774: 30 80 00 04 b,a 200c784 <_Watchdog_Adjust+0x98>
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
200c778: 80 a6 a0 00 cmp %i2, 0
200c77c: 32 bf ff ec bne,a 200c72c <_Watchdog_Adjust+0x40> <== ALWAYS TAKEN
200c780: c2 06 00 00 ld [ %i0 ], %g1
}
break;
}
}
_ISR_Enable( level );
200c784: 7f ff db 26 call 200341c <sparc_enable_interrupts>
200c788: 91 e8 00 08 restore %g0, %o0, %o0
0200ae44 <_Watchdog_Remove>:
#include <rtems/score/watchdog.h>
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
200ae44: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
200ae48: 7f ff dd df call 20025c4 <sparc_disable_interrupts>
200ae4c: ba 10 00 18 mov %i0, %i5
previous_state = the_watchdog->state;
200ae50: f0 06 20 08 ld [ %i0 + 8 ], %i0
switch ( previous_state ) {
200ae54: 80 a6 20 01 cmp %i0, 1
200ae58: 22 80 00 1e be,a 200aed0 <_Watchdog_Remove+0x8c>
200ae5c: c0 27 60 08 clr [ %i5 + 8 ]
200ae60: 0a 80 00 1d bcs 200aed4 <_Watchdog_Remove+0x90>
200ae64: 03 00 80 75 sethi %hi(0x201d400), %g1
200ae68: 80 a6 20 03 cmp %i0, 3
200ae6c: 18 80 00 1a bgu 200aed4 <_Watchdog_Remove+0x90> <== NEVER TAKEN
200ae70: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
Watchdog_Control *the_watchdog
)
{
return ( (Watchdog_Control *) the_watchdog->Node.next );
200ae74: 10 80 00 02 b 200ae7c <_Watchdog_Remove+0x38>
200ae78: c2 07 40 00 ld [ %i5 ], %g1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
200ae7c: c0 27 60 08 clr [ %i5 + 8 ]
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
200ae80: c4 00 40 00 ld [ %g1 ], %g2
200ae84: 80 a0 a0 00 cmp %g2, 0
200ae88: 02 80 00 07 be 200aea4 <_Watchdog_Remove+0x60>
200ae8c: 05 00 80 75 sethi %hi(0x201d400), %g2
next_watchdog->delta_interval += the_watchdog->delta_interval;
200ae90: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
200ae94: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200ae98: 84 00 c0 02 add %g3, %g2, %g2
200ae9c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if ( _Watchdog_Sync_count )
200aea0: 05 00 80 75 sethi %hi(0x201d400), %g2
200aea4: c4 00 a2 b8 ld [ %g2 + 0x2b8 ], %g2 ! 201d6b8 <_Watchdog_Sync_count>
200aea8: 80 a0 a0 00 cmp %g2, 0
200aeac: 22 80 00 07 be,a 200aec8 <_Watchdog_Remove+0x84>
200aeb0: c4 07 60 04 ld [ %i5 + 4 ], %g2
_Watchdog_Sync_level = _ISR_Nest_level;
200aeb4: 05 00 80 76 sethi %hi(0x201d800), %g2
200aeb8: c6 00 a2 f8 ld [ %g2 + 0x2f8 ], %g3 ! 201daf8 <_Per_CPU_Information+0x8>
200aebc: 05 00 80 75 sethi %hi(0x201d400), %g2
200aec0: c6 20 a2 58 st %g3, [ %g2 + 0x258 ] ! 201d658 <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200aec4: c4 07 60 04 ld [ %i5 + 4 ], %g2
next->previous = previous;
200aec8: c4 20 60 04 st %g2, [ %g1 + 4 ]
previous->next = next;
200aecc: c2 20 80 00 st %g1, [ %g2 ]
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
200aed0: 03 00 80 75 sethi %hi(0x201d400), %g1
200aed4: c2 00 62 bc ld [ %g1 + 0x2bc ], %g1 ! 201d6bc <_Watchdog_Ticks_since_boot>
200aed8: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
_ISR_Enable( level );
200aedc: 7f ff dd be call 20025d4 <sparc_enable_interrupts>
200aee0: 01 00 00 00 nop
return( previous_state );
}
200aee4: 81 c7 e0 08 ret
200aee8: 81 e8 00 00 restore
0200c098 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
200c098: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
200c09c: 7f ff db b9 call 2002f80 <sparc_disable_interrupts>
200c0a0: b8 10 00 18 mov %i0, %i4
200c0a4: b0 10 00 08 mov %o0, %i0
printk( "Watchdog Chain: %s %p\n", name, header );
200c0a8: 11 00 80 75 sethi %hi(0x201d400), %o0
200c0ac: 94 10 00 19 mov %i1, %o2
200c0b0: 90 12 20 68 or %o0, 0x68, %o0
200c0b4: 7f ff e3 3c call 2004da4 <printk>
200c0b8: 92 10 00 1c mov %i4, %o1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200c0bc: 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 );
200c0c0: b2 06 60 04 add %i1, 4, %i1
if ( !_Chain_Is_empty( header ) ) {
200c0c4: 80 a7 40 19 cmp %i5, %i1
200c0c8: 12 80 00 04 bne 200c0d8 <_Watchdog_Report_chain+0x40>
200c0cc: 92 10 00 1d mov %i5, %o1
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
200c0d0: 10 80 00 0d b 200c104 <_Watchdog_Report_chain+0x6c>
200c0d4: 11 00 80 75 sethi %hi(0x201d400), %o0
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
200c0d8: 40 00 00 0f call 200c114 <_Watchdog_Report>
200c0dc: 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 )
200c0e0: 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 ) ;
200c0e4: 80 a7 40 19 cmp %i5, %i1
200c0e8: 12 bf ff fc bne 200c0d8 <_Watchdog_Report_chain+0x40> <== NEVER TAKEN
200c0ec: 92 10 00 1d mov %i5, %o1
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
200c0f0: 11 00 80 75 sethi %hi(0x201d400), %o0
200c0f4: 92 10 00 1c mov %i4, %o1
200c0f8: 7f ff e3 2b call 2004da4 <printk>
200c0fc: 90 12 20 80 or %o0, 0x80, %o0
200c100: 30 80 00 03 b,a 200c10c <_Watchdog_Report_chain+0x74>
} else {
printk( "Chain is empty\n" );
200c104: 7f ff e3 28 call 2004da4 <printk>
200c108: 90 12 20 90 or %o0, 0x90, %o0
}
_ISR_Enable( level );
200c10c: 7f ff db a1 call 2002f90 <sparc_enable_interrupts>
200c110: 81 e8 00 00 restore
0200aeec <_Watchdog_Tickle>:
#include <rtems/score/watchdog.h>
void _Watchdog_Tickle(
Chain_Control *header
)
{
200aeec: 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 );
200aef0: 7f ff dd b5 call 20025c4 <sparc_disable_interrupts>
200aef4: b8 10 00 18 mov %i0, %i4
200aef8: b0 10 00 08 mov %o0, %i0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200aefc: fa 07 00 00 ld [ %i4 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200af00: b6 07 20 04 add %i4, 4, %i3
if ( _Chain_Is_empty( header ) )
200af04: 80 a7 40 1b cmp %i5, %i3
200af08: 02 80 00 1f be 200af84 <_Watchdog_Tickle+0x98>
200af0c: 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) {
200af10: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200af14: 80 a0 60 00 cmp %g1, 0
200af18: 02 80 00 06 be 200af30 <_Watchdog_Tickle+0x44> <== NEVER TAKEN
200af1c: 82 00 7f ff add %g1, -1, %g1
the_watchdog->delta_interval--;
200af20: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
if ( the_watchdog->delta_interval != 0 )
200af24: 80 a0 60 00 cmp %g1, 0
200af28: 12 80 00 17 bne 200af84 <_Watchdog_Tickle+0x98>
200af2c: 01 00 00 00 nop
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
200af30: 7f ff ff c5 call 200ae44 <_Watchdog_Remove>
200af34: 90 10 00 1d mov %i5, %o0
200af38: b4 10 00 08 mov %o0, %i2
_ISR_Enable( level );
200af3c: 7f ff dd a6 call 20025d4 <sparc_enable_interrupts>
200af40: 90 10 00 18 mov %i0, %o0
switch( watchdog_state ) {
200af44: 80 a6 a0 02 cmp %i2, 2
200af48: 12 80 00 06 bne 200af60 <_Watchdog_Tickle+0x74>
200af4c: 01 00 00 00 nop
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
200af50: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200af54: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200af58: 9f c0 40 00 call %g1
200af5c: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
200af60: 7f ff dd 99 call 20025c4 <sparc_disable_interrupts>
200af64: 01 00 00 00 nop
200af68: b0 10 00 08 mov %o0, %i0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200af6c: fa 07 00 00 ld [ %i4 ], %i5
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
200af70: 80 a7 40 1b cmp %i5, %i3
200af74: 02 80 00 04 be 200af84 <_Watchdog_Tickle+0x98>
200af78: 01 00 00 00 nop
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
200af7c: 10 bf ff ea b 200af24 <_Watchdog_Tickle+0x38>
200af80: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
200af84: 7f ff dd 94 call 20025d4 <sparc_enable_interrupts>
200af88: 81 e8 00 00 restore
0200af8c <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
200af8c: 9d e3 bf a0 save %sp, -96, %sp
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t remaining = rtems_configuration_get_work_space_size();
200af90: 05 00 80 69 sethi %hi(0x201a400), %g2
200af94: 82 10 a3 78 or %g2, 0x378, %g1 ! 201a778 <Configuration>
200af98: c6 08 60 32 ldub [ %g1 + 0x32 ], %g3
200af9c: fa 00 a3 78 ld [ %g2 + 0x378 ], %i5
200afa0: 80 a0 e0 00 cmp %g3, 0
200afa4: 12 80 00 03 bne 200afb0 <_Workspace_Handler_initialization+0x24>
200afa8: 84 10 20 00 clr %g2
200afac: c4 00 60 04 ld [ %g1 + 4 ], %g2
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
200afb0: 21 00 80 22 sethi %hi(0x2008800), %l0
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
200afb4: 27 00 80 75 sethi %hi(0x201d400), %l3
size_t area_count,
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();
200afb8: ba 00 80 1d add %g2, %i5, %i5
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) {
200afbc: b6 10 20 00 clr %i3
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
200afc0: a0 14 20 b0 or %l0, 0xb0, %l0
size_t i;
for (i = 0; i < area_count; ++i) {
Heap_Area *area = &areas [i];
if ( do_zero ) {
200afc4: e2 08 60 30 ldub [ %g1 + 0x30 ], %l1
if ( area->size > overhead ) {
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
200afc8: e4 08 60 31 ldub [ %g1 + 0x31 ], %l2
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) {
200afcc: 10 80 00 2c b 200b07c <_Workspace_Handler_initialization+0xf0>
200afd0: a6 14 e1 e0 or %l3, 0x1e0, %l3
Heap_Area *area = &areas [i];
if ( do_zero ) {
200afd4: 22 80 00 07 be,a 200aff0 <_Workspace_Handler_initialization+0x64>
200afd8: f8 06 20 04 ld [ %i0 + 4 ], %i4
memset( area->begin, 0, area->size );
200afdc: d0 06 00 00 ld [ %i0 ], %o0
200afe0: d4 06 20 04 ld [ %i0 + 4 ], %o2
200afe4: 40 00 14 30 call 20100a4 <memset>
200afe8: 92 10 20 00 clr %o1
}
if ( area->size > overhead ) {
200afec: f8 06 20 04 ld [ %i0 + 4 ], %i4
200aff0: 80 a7 20 16 cmp %i4, 0x16
200aff4: 28 80 00 21 bleu,a 200b078 <_Workspace_Handler_initialization+0xec>
200aff8: b6 06 e0 01 inc %i3
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
200affc: 80 a4 a0 00 cmp %l2, 0
200b000: 32 80 00 0c bne,a 200b030 <_Workspace_Handler_initialization+0xa4>
200b004: d2 06 00 00 ld [ %i0 ], %o1
size = area->size;
} else {
if ( remaining > 0 ) {
200b008: 80 a7 60 00 cmp %i5, 0
200b00c: 22 80 00 08 be,a 200b02c <_Workspace_Handler_initialization+0xa0><== NEVER TAKEN
200b010: b8 10 20 00 clr %i4 <== NOT EXECUTED
size = remaining < area->size - overhead ?
200b014: 82 07 3f ea add %i4, -22, %g1
remaining + overhead : area->size;
200b018: 80 a7 40 01 cmp %i5, %g1
200b01c: 2a 80 00 04 bcs,a 200b02c <_Workspace_Handler_initialization+0xa0><== ALWAYS TAKEN
200b020: b8 07 60 16 add %i5, 0x16, %i4
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
200b024: 10 80 00 03 b 200b030 <_Workspace_Handler_initialization+0xa4><== NOT EXECUTED
200b028: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
200b02c: d2 06 00 00 ld [ %i0 ], %o1
200b030: 94 10 00 1c mov %i4, %o2
200b034: 90 10 00 13 mov %l3, %o0
200b038: 9f c4 00 00 call %l0
200b03c: 96 10 20 08 mov 8, %o3
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
200b040: c2 06 00 00 ld [ %i0 ], %g1
area->size -= size;
if ( space_available < remaining ) {
200b044: 80 a2 00 1d cmp %o0, %i5
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
200b048: 82 00 40 1c add %g1, %i4, %g1
200b04c: c2 26 00 00 st %g1, [ %i0 ]
area->size -= size;
200b050: c2 06 20 04 ld [ %i0 + 4 ], %g1
200b054: b8 20 40 1c sub %g1, %i4, %i4
if ( space_available < remaining ) {
200b058: 1a 80 00 05 bcc 200b06c <_Workspace_Handler_initialization+0xe0><== ALWAYS TAKEN
200b05c: f8 26 20 04 st %i4, [ %i0 + 4 ]
remaining -= space_available;
200b060: ba 27 40 08 sub %i5, %o0, %i5 <== NOT EXECUTED
} else {
remaining = 0;
}
init_or_extend = extend;
200b064: 10 80 00 04 b 200b074 <_Workspace_Handler_initialization+0xe8><== NOT EXECUTED
200b068: a0 10 00 1a mov %i2, %l0 <== NOT EXECUTED
200b06c: a0 10 00 1a mov %i2, %l0
area->size -= size;
if ( space_available < remaining ) {
remaining -= space_available;
} else {
remaining = 0;
200b070: ba 10 20 00 clr %i5
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) {
200b074: b6 06 e0 01 inc %i3
200b078: b0 06 20 08 add %i0, 8, %i0
200b07c: 80 a6 c0 19 cmp %i3, %i1
200b080: 12 bf ff d5 bne 200afd4 <_Workspace_Handler_initialization+0x48>
200b084: 80 a4 60 00 cmp %l1, 0
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
200b088: 80 a7 60 00 cmp %i5, 0
200b08c: 02 80 00 05 be 200b0a0 <_Workspace_Handler_initialization+0x114>
200b090: 90 10 20 00 clr %o0
_Internal_error_Occurred(
200b094: 92 10 20 01 mov 1, %o1
200b098: 7f ff f6 99 call 2008afc <_Internal_error_Occurred>
200b09c: 94 10 20 02 mov 2, %o2
200b0a0: 81 c7 e0 08 ret
200b0a4: 81 e8 00 00 restore
02013000 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
2013000: 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)
2013004: 10 80 00 17 b 2013060 <_fat_block_read+0x60>
2013008: ba 10 20 00 clr %i5
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
201300c: 92 10 00 19 mov %i1, %o1
2013010: 94 10 20 01 mov 1, %o2
2013014: 7f ff ff cc call 2012f44 <fat_buf_access>
2013018: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
201301c: 80 a2 20 00 cmp %o0, 0
2013020: 32 80 00 15 bne,a 2013074 <_fat_block_read+0x74> <== NEVER TAKEN
2013024: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
2013028: e0 16 00 00 lduh [ %i0 ], %l0
201302c: a0 24 00 1a sub %l0, %i2, %l0
2013030: 80 a4 00 1b cmp %l0, %i3
2013034: 38 80 00 02 bgu,a 201303c <_fat_block_read+0x3c>
2013038: a0 10 00 1b mov %i3, %l0
memcpy((buff + cmpltd), (sec_buf + ofs), c);
201303c: d2 07 bf fc ld [ %fp + -4 ], %o1
2013040: 90 07 00 1d add %i4, %i5, %o0
2013044: 92 02 40 1a add %o1, %i2, %o1
2013048: 94 10 00 10 mov %l0, %o2
201304c: 40 00 24 17 call 201c0a8 <memcpy>
2013050: b6 26 c0 10 sub %i3, %l0, %i3
count -= c;
cmpltd += c;
2013054: ba 04 00 1d add %l0, %i5, %i5
sec_num++;
2013058: b2 06 60 01 inc %i1
ofs = 0;
201305c: b4 10 20 00 clr %i2
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
2013060: 80 a6 e0 00 cmp %i3, 0
2013064: 12 bf ff ea bne 201300c <_fat_block_read+0xc>
2013068: 90 10 00 18 mov %i0, %o0
cmpltd += c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
201306c: 81 c7 e0 08 ret
2013070: 91 e8 00 1d restore %g0, %i5, %o0
2013074: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
2013078: 81 c7 e0 08 ret <== NOT EXECUTED
201307c: 81 e8 00 00 restore <== NOT EXECUTED
02003d60 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
2003d60: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
2003d64: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
2003d68: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2003d6c: 7f ff ff e9 call 2003d10 <lstat> <== NOT EXECUTED
2003d70: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
020045a4 <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
20045a4: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
20045a8: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
20045ac: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
20045b0: 7f ff ff e9 call 2004554 <stat> <== NOT EXECUTED
20045b4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02007750 <aio_cancel>:
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
2007750: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
2007754: 3b 00 80 7e sethi %hi(0x201f800), %i5
2007758: 40 00 04 68 call 20088f8 <pthread_mutex_lock>
200775c: 90 17 61 bc or %i5, 0x1bc, %o0 ! 201f9bc <aio_request_queue>
if (fcntl (fildes, F_GETFD) < 0) {
2007760: 90 10 00 18 mov %i0, %o0
2007764: 40 00 1a d6 call 200e2bc <fcntl>
2007768: 92 10 20 01 mov 1, %o1
200776c: 80 a2 20 00 cmp %o0, 0
2007770: 16 80 00 08 bge 2007790 <aio_cancel+0x40>
2007774: 80 a6 60 00 cmp %i1, 0
pthread_mutex_unlock(&aio_request_queue.mutex);
2007778: 40 00 04 81 call 200897c <pthread_mutex_unlock>
200777c: 90 17 61 bc or %i5, 0x1bc, %o0
rtems_set_errno_and_return_minus_one (EBADF);
2007780: 40 00 28 84 call 2011990 <__errno>
2007784: 01 00 00 00 nop
2007788: 10 80 00 54 b 20078d8 <aio_cancel+0x188>
200778c: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
2007790: 32 80 00 35 bne,a 2007864 <aio_cancel+0x114>
2007794: f8 06 40 00 ld [ %i1 ], %i4
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
2007798: 11 00 80 7e sethi %hi(0x201f800), %o0
200779c: 92 10 00 18 mov %i0, %o1
20077a0: 90 12 22 04 or %o0, 0x204, %o0
20077a4: 40 00 01 71 call 2007d68 <rtems_aio_search_fd>
20077a8: 94 10 20 00 clr %o2
if (r_chain == NULL) {
20077ac: b8 92 20 00 orcc %o0, 0, %i4
20077b0: 12 80 00 20 bne 2007830 <aio_cancel+0xe0>
20077b4: b6 07 20 1c add %i4, 0x1c, %i3
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
20077b8: ba 17 61 bc or %i5, 0x1bc, %i5
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
20077bc: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
20077c0: 82 07 60 58 add %i5, 0x58, %g1
20077c4: 80 a0 80 01 cmp %g2, %g1
20077c8: 02 80 00 08 be 20077e8 <aio_cancel+0x98> <== NEVER TAKEN
20077cc: 92 10 00 18 mov %i0, %o1
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
20077d0: 90 07 60 54 add %i5, 0x54, %o0
20077d4: 40 00 01 65 call 2007d68 <rtems_aio_search_fd>
20077d8: 94 10 20 00 clr %o2
if (r_chain == NULL) {
20077dc: b8 92 20 00 orcc %o0, 0, %i4
20077e0: 12 80 00 08 bne 2007800 <aio_cancel+0xb0>
20077e4: 01 00 00 00 nop
pthread_mutex_unlock(&aio_request_queue.mutex);
20077e8: 11 00 80 7e sethi %hi(0x201f800), %o0
return AIO_ALLDONE;
20077ec: b0 10 20 02 mov 2, %i0
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock(&aio_request_queue.mutex);
20077f0: 40 00 04 63 call 200897c <pthread_mutex_unlock>
20077f4: 90 12 21 bc or %o0, 0x1bc, %o0
return AIO_ALLDONE;
20077f8: 81 c7 e0 08 ret
20077fc: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2007800: 40 00 0a e1 call 200a384 <_Chain_Extract>
2007804: b6 07 20 1c add %i4, 0x1c, %i3
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
2007808: 40 00 01 80 call 2007e08 <rtems_aio_remove_fd>
200780c: 90 10 00 1c mov %i4, %o0
pthread_mutex_destroy (&r_chain->mutex);
2007810: 40 00 03 8d call 2008644 <pthread_mutex_destroy>
2007814: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->mutex);
2007818: 40 00 02 ae call 20082d0 <pthread_cond_destroy>
200781c: 90 10 00 1b mov %i3, %o0
free (r_chain);
2007820: 7f ff f0 c5 call 2003b34 <free>
2007824: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007828: 10 80 00 0b b 2007854 <aio_cancel+0x104>
200782c: 90 10 00 1d mov %i5, %o0
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
2007830: 40 00 04 32 call 20088f8 <pthread_mutex_lock>
2007834: 90 10 00 1b mov %i3, %o0
2007838: 40 00 0a d3 call 200a384 <_Chain_Extract>
200783c: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
2007840: 40 00 01 72 call 2007e08 <rtems_aio_remove_fd>
2007844: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&r_chain->mutex);
2007848: 40 00 04 4d call 200897c <pthread_mutex_unlock>
200784c: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007850: 90 17 61 bc or %i5, 0x1bc, %o0
2007854: 40 00 04 4a call 200897c <pthread_mutex_unlock>
2007858: b0 10 20 00 clr %i0
return AIO_CANCELED;
200785c: 81 c7 e0 08 ret
2007860: 81 e8 00 00 restore
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
2007864: 80 a7 00 18 cmp %i4, %i0
2007868: 12 80 00 17 bne 20078c4 <aio_cancel+0x174>
200786c: 90 17 61 bc or %i5, 0x1bc, %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);
2007870: 11 00 80 7e sethi %hi(0x201f800), %o0
2007874: 92 10 00 1c mov %i4, %o1
2007878: 90 12 22 04 or %o0, 0x204, %o0
200787c: 40 00 01 3b call 2007d68 <rtems_aio_search_fd>
2007880: 94 10 20 00 clr %o2
if (r_chain == NULL) {
2007884: b6 92 20 00 orcc %o0, 0, %i3
2007888: 32 80 00 1c bne,a 20078f8 <aio_cancel+0x1a8>
200788c: b8 06 e0 1c add %i3, 0x1c, %i4
2007890: ba 17 61 bc or %i5, 0x1bc, %i5
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
2007894: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
2007898: 82 07 60 58 add %i5, 0x58, %g1
200789c: 80 a0 80 01 cmp %g2, %g1
20078a0: 02 bf ff d2 be 20077e8 <aio_cancel+0x98> <== NEVER TAKEN
20078a4: 92 10 00 1c mov %i4, %o1
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
20078a8: 90 07 60 54 add %i5, 0x54, %o0
20078ac: 40 00 01 2f call 2007d68 <rtems_aio_search_fd>
20078b0: 94 10 20 00 clr %o2
if (r_chain == NULL) {
20078b4: 80 a2 20 00 cmp %o0, 0
20078b8: 12 80 00 0b bne 20078e4 <aio_cancel+0x194>
20078bc: 90 02 20 08 add %o0, 8, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
20078c0: 90 10 00 1d mov %i5, %o0
20078c4: 40 00 04 2e call 200897c <pthread_mutex_unlock>
20078c8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one (EINVAL);
20078cc: 40 00 28 31 call 2011990 <__errno>
20078d0: 01 00 00 00 nop
20078d4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
20078d8: c2 22 00 00 st %g1, [ %o0 ]
20078dc: 81 c7 e0 08 ret
20078e0: 91 e8 3f ff restore %g0, -1, %o0
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
20078e4: 40 00 01 5d call 2007e58 <rtems_aio_remove_req>
20078e8: 92 10 00 19 mov %i1, %o1
20078ec: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&aio_request_queue.mutex);
20078f0: 10 80 00 0b b 200791c <aio_cancel+0x1cc>
20078f4: 90 10 00 1d mov %i5, %o0
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
20078f8: 40 00 04 00 call 20088f8 <pthread_mutex_lock>
20078fc: 90 10 00 1c mov %i4, %o0
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
2007900: 92 10 00 19 mov %i1, %o1
2007904: 40 00 01 55 call 2007e58 <rtems_aio_remove_req>
2007908: 90 06 e0 08 add %i3, 8, %o0
200790c: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&r_chain->mutex);
2007910: 40 00 04 1b call 200897c <pthread_mutex_unlock>
2007914: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007918: 90 17 61 bc or %i5, 0x1bc, %o0
200791c: 40 00 04 18 call 200897c <pthread_mutex_unlock>
2007920: 01 00 00 00 nop
return result;
}
return AIO_ALLDONE;
}
2007924: 81 c7 e0 08 ret
2007928: 81 e8 00 00 restore
02007934 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
2007934: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
2007938: 03 00 00 08 sethi %hi(0x2000), %g1
200793c: 80 a6 00 01 cmp %i0, %g1
2007940: 12 80 00 10 bne 2007980 <aio_fsync+0x4c>
2007944: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
2007948: d0 06 40 00 ld [ %i1 ], %o0
200794c: 40 00 1a 5c call 200e2bc <fcntl>
2007950: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
2007954: 90 0a 20 03 and %o0, 3, %o0
2007958: 90 02 3f ff add %o0, -1, %o0
200795c: 80 a2 20 01 cmp %o0, 1
2007960: 18 80 00 08 bgu 2007980 <aio_fsync+0x4c>
2007964: ba 10 20 09 mov 9, %i5
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
2007968: 7f ff f1 93 call 2003fb4 <malloc>
200796c: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
2007970: b0 92 20 00 orcc %o0, 0, %i0
2007974: 32 80 00 09 bne,a 2007998 <aio_fsync+0x64> <== ALWAYS TAKEN
2007978: f2 26 20 14 st %i1, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
200797c: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
2007980: 82 10 3f ff mov -1, %g1
2007984: fa 26 60 34 st %i5, [ %i1 + 0x34 ]
2007988: 40 00 28 02 call 2011990 <__errno>
200798c: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
2007990: 10 80 00 06 b 20079a8 <aio_fsync+0x74>
2007994: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
2007998: 82 10 20 03 mov 3, %g1
200799c: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
return rtems_aio_enqueue (req);
20079a0: 40 00 01 4e call 2007ed8 <rtems_aio_enqueue>
20079a4: 81 e8 00 00 restore
}
20079a8: 81 c7 e0 08 ret
20079ac: 91 e8 3f ff restore %g0, -1, %o0
020080f0 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
20080f0: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
20080f4: d0 06 00 00 ld [ %i0 ], %o0
20080f8: 92 10 20 03 mov 3, %o1
20080fc: 40 00 18 70 call 200e2bc <fcntl>
2008100: ba 10 00 18 mov %i0, %i5
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
2008104: 80 8a 20 01 btst 1, %o0
2008108: 12 80 00 11 bne 200814c <aio_read+0x5c>
200810c: b8 10 20 09 mov 9, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
2008110: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
2008114: 80 a0 60 00 cmp %g1, 0
2008118: 22 80 00 04 be,a 2008128 <aio_read+0x38>
200811c: c2 06 20 08 ld [ %i0 + 8 ], %g1
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
2008120: 10 80 00 0b b 200814c <aio_read+0x5c>
2008124: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
2008128: 80 a0 60 00 cmp %g1, 0
200812c: 06 80 00 08 bl 200814c <aio_read+0x5c>
2008130: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
2008134: 7f ff ef a0 call 2003fb4 <malloc>
2008138: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
200813c: b0 92 20 00 orcc %o0, 0, %i0
2008140: 32 80 00 09 bne,a 2008164 <aio_read+0x74> <== ALWAYS TAKEN
2008144: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
2008148: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
200814c: 82 10 3f ff mov -1, %g1
2008150: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
2008154: 40 00 26 0f call 2011990 <__errno>
2008158: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
200815c: 10 80 00 06 b 2008174 <aio_read+0x84>
2008160: f8 22 00 00 st %i4, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
2008164: 82 10 20 01 mov 1, %g1
2008168: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
return rtems_aio_enqueue (req);
200816c: 7f ff ff 5b call 2007ed8 <rtems_aio_enqueue>
2008170: 81 e8 00 00 restore
}
2008174: 81 c7 e0 08 ret
2008178: 91 e8 3f ff restore %g0, -1, %o0
02008184 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
2008184: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
2008188: d0 06 00 00 ld [ %i0 ], %o0
200818c: 40 00 18 4c call 200e2bc <fcntl>
2008190: 92 10 20 03 mov 3, %o1
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
2008194: ba 10 00 18 mov %i0, %i5
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
2008198: 90 0a 20 03 and %o0, 3, %o0
200819c: 90 02 3f ff add %o0, -1, %o0
20081a0: 80 a2 20 01 cmp %o0, 1
20081a4: 18 80 00 11 bgu 20081e8 <aio_write+0x64>
20081a8: b8 10 20 09 mov 9, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
20081ac: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
20081b0: 80 a0 60 00 cmp %g1, 0
20081b4: 22 80 00 04 be,a 20081c4 <aio_write+0x40>
20081b8: c2 06 20 08 ld [ %i0 + 8 ], %g1
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
20081bc: 10 80 00 0b b 20081e8 <aio_write+0x64>
20081c0: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
20081c4: 80 a0 60 00 cmp %g1, 0
20081c8: 06 80 00 08 bl 20081e8 <aio_write+0x64>
20081cc: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
20081d0: 7f ff ef 79 call 2003fb4 <malloc>
20081d4: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
20081d8: b0 92 20 00 orcc %o0, 0, %i0
20081dc: 32 80 00 09 bne,a 2008200 <aio_write+0x7c> <== ALWAYS TAKEN
20081e0: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
20081e4: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
20081e8: 82 10 3f ff mov -1, %g1
20081ec: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
20081f0: 40 00 25 e8 call 2011990 <__errno>
20081f4: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
20081f8: 10 80 00 06 b 2008210 <aio_write+0x8c>
20081fc: f8 22 00 00 st %i4, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
2008200: 82 10 20 02 mov 2, %g1
2008204: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
return rtems_aio_enqueue (req);
2008208: 7f ff ff 34 call 2007ed8 <rtems_aio_enqueue>
200820c: 81 e8 00 00 restore
}
2008210: 81 c7 e0 08 ret
2008214: 91 e8 3f ff restore %g0, -1, %o0
02003990 <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
2003990: 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(
2003994: 94 10 20 19 mov 0x19, %o2
2003998: 92 10 00 18 mov %i0, %o1
200399c: 90 07 bf c8 add %fp, -56, %o0
20039a0: 17 00 80 48 sethi %hi(0x2012000), %o3
20039a4: 96 12 e1 e4 or %o3, 0x1e4, %o3 ! 20121e4 <rtems_global_user_env+0x4>
20039a8: 40 00 04 c3 call 2004cb4 <rtems_filesystem_eval_path_start_with_root_and_current>
20039ac: 98 02 ff fc add %o3, -4, %o4
20039b0: 90 07 bf b0 add %fp, -80, %o0
20039b4: 40 00 05 da call 200511c <rtems_filesystem_location_copy_and_detach>
20039b8: 92 07 bf e0 add %fp, -32, %o1
&rtems_global_user_env.root_directory,
&rtems_global_user_env.current_directory
);
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
20039bc: 40 00 06 50 call 20052fc <rtems_filesystem_location_transform_to_global>
20039c0: 90 07 bf b0 add %fp, -80, %o0
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
20039c4: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
20039c8: 39 00 80 46 sethi %hi(0x2011800), %i4
20039cc: b8 17 22 b4 or %i4, 0x2b4, %i4 ! 2011ab4 <rtems_filesystem_null_handlers>
20039d0: 80 a0 40 1c cmp %g1, %i4
20039d4: 02 80 00 29 be 2003a78 <chroot+0xe8>
20039d8: d0 27 bf ac st %o0, [ %fp + -84 ]
rtems_filesystem_global_location_t *new_root_loc =
20039dc: 40 00 06 16 call 2005234 <rtems_filesystem_global_location_obtain>
20039e0: 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)(
20039e4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
20039e8: 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 =
20039ec: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
20039f0: 9f c0 40 00 call %g1
20039f4: 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 ) {
20039f8: 80 a2 20 00 cmp %o0, 0
20039fc: 32 80 00 17 bne,a 2003a58 <chroot+0xc8>
2003a00: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
sc = rtems_libio_set_private_env();
2003a04: 40 00 03 1d call 2004678 <rtems_libio_set_private_env>
2003a08: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
2003a0c: 80 a2 20 00 cmp %o0, 0
2003a10: 12 80 00 0c bne 2003a40 <chroot+0xb0>
2003a14: 80 a2 20 0d cmp %o0, 0xd
rtems_filesystem_global_location_assign(
2003a18: 39 00 80 48 sethi %hi(0x2012000), %i4
2003a1c: d0 07 21 dc ld [ %i4 + 0x1dc ], %o0 ! 20121dc <rtems_current_user_env>
2003a20: 92 10 00 1d mov %i5, %o1
2003a24: 40 00 05 fb call 2005210 <rtems_filesystem_global_location_assign>
2003a28: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_root_loc
);
rtems_filesystem_global_location_assign(
2003a2c: d0 07 21 dc ld [ %i4 + 0x1dc ], %o0
2003a30: d2 07 bf ac ld [ %fp + -84 ], %o1
2003a34: 40 00 05 f7 call 2005210 <rtems_filesystem_global_location_assign>
2003a38: b0 10 20 00 clr %i0
2003a3c: 30 80 00 10 b,a 2003a7c <chroot+0xec>
&rtems_filesystem_current,
new_current_loc
);
} else {
if (sc != RTEMS_UNSATISFIED) {
2003a40: 02 80 00 18 be 2003aa0 <chroot+0x110> <== NEVER TAKEN
2003a44: 01 00 00 00 nop
errno = ENOMEM;
2003a48: 40 00 1f f5 call 200ba1c <__errno>
2003a4c: 01 00 00 00 nop
2003a50: 10 80 00 08 b 2003a70 <chroot+0xe0>
2003a54: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
static inline void rtems_filesystem_location_error(
const rtems_filesystem_location_info_t *loc,
int eno
)
{
if ( !rtems_filesystem_location_is_null( loc ) ) {
2003a58: 80 a0 40 1c cmp %g1, %i4
2003a5c: 02 80 00 11 be 2003aa0 <chroot+0x110> <== NEVER TAKEN
2003a60: 01 00 00 00 nop
errno = eno;
2003a64: 40 00 1f ee call 200ba1c <__errno>
2003a68: 01 00 00 00 nop
2003a6c: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
2003a70: 10 80 00 0c b 2003aa0 <chroot+0x110>
2003a74: c2 22 00 00 st %g1, [ %o0 ]
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_root_loc );
}
} else {
rv = -1;
2003a78: b0 10 3f ff mov -1, %i0
}
rtems_filesystem_eval_path_cleanup( &ctx );
2003a7c: 40 00 04 d4 call 2004dcc <rtems_filesystem_eval_path_cleanup>
2003a80: 90 07 bf c8 add %fp, -56, %o0
if ( rv != 0 ) {
2003a84: 80 a6 20 00 cmp %i0, 0
2003a88: 02 80 00 0a be 2003ab0 <chroot+0x120>
2003a8c: 01 00 00 00 nop
rtems_filesystem_global_location_release( new_current_loc );
2003a90: 40 00 05 c8 call 20051b0 <rtems_filesystem_global_location_release>
2003a94: d0 07 bf ac ld [ %fp + -84 ], %o0
2003a98: 81 c7 e0 08 ret
2003a9c: 81 e8 00 00 restore
rtems_filesystem_location_error( &new_root_loc->location, ENOTDIR );
rv = -1;
}
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_root_loc );
2003aa0: 40 00 05 c4 call 20051b0 <rtems_filesystem_global_location_release>
2003aa4: 90 10 00 1d mov %i5, %o0
}
} else {
rv = -1;
2003aa8: 10 bf ff f5 b 2003a7c <chroot+0xec>
2003aac: b0 10 3f ff mov -1, %i0
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc );
}
return rv;
}
2003ab0: 81 c7 e0 08 ret
2003ab4: 81 e8 00 00 restore
0200736c <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
200736c: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
2007370: 80 a6 60 00 cmp %i1, 0
2007374: 02 80 00 26 be 200740c <clock_gettime+0xa0>
2007378: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
200737c: 12 80 00 16 bne 20073d4 <clock_gettime+0x68>
2007380: 80 a6 20 04 cmp %i0, 4
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
2007384: 90 07 bf f8 add %fp, -8, %o0
2007388: 13 00 80 82 sethi %hi(0x2020800), %o1
200738c: 40 00 08 2f call 2009448 <_TOD_Get_with_nanoseconds>
2007390: 92 12 62 88 or %o1, 0x288, %o1 ! 2020a88 <_TOD>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
2007394: 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);
2007398: 94 10 20 00 clr %o2
200739c: 90 10 00 1c mov %i4, %o0
20073a0: 92 10 00 1d mov %i5, %o1
20073a4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20073a8: 40 00 53 1c call 201c018 <__divdi3>
20073ac: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20073b0: 90 10 00 1c mov %i4, %o0
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
20073b4: d2 26 40 00 st %o1, [ %i1 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20073b8: 94 10 20 00 clr %o2
20073bc: 92 10 00 1d mov %i5, %o1
20073c0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20073c4: 40 00 54 00 call 201c3c4 <__moddi3>
20073c8: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
20073cc: 10 80 00 06 b 20073e4 <clock_gettime+0x78>
20073d0: d2 26 60 04 st %o1, [ %i1 + 4 ]
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
20073d4: 12 80 00 06 bne 20073ec <clock_gettime+0x80> <== ALWAYS TAKEN
20073d8: 80 a6 20 02 cmp %i0, 2
_TOD_Get_uptime_as_timespec( tp );
20073dc: 40 00 08 2c call 200948c <_TOD_Get_uptime_as_timespec>
20073e0: 90 10 00 19 mov %i1, %o0
return 0;
20073e4: 81 c7 e0 08 ret
20073e8: 91 e8 20 00 restore %g0, 0, %o0
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
20073ec: 02 bf ff fc be 20073dc <clock_gettime+0x70>
20073f0: 80 a6 20 03 cmp %i0, 3
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
20073f4: 12 80 00 06 bne 200740c <clock_gettime+0xa0>
20073f8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
20073fc: 40 00 24 d8 call 201075c <__errno>
2007400: 01 00 00 00 nop
2007404: 10 80 00 05 b 2007418 <clock_gettime+0xac>
2007408: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
200740c: 40 00 24 d4 call 201075c <__errno>
2007410: 01 00 00 00 nop
2007414: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007418: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
200741c: 81 c7 e0 08 ret
2007420: 91 e8 3f ff restore %g0, -1, %o0
02025890 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
2025890: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
2025894: 82 96 60 00 orcc %i1, 0, %g1
2025898: 02 80 00 4b be 20259c4 <clock_settime+0x134> <== NEVER TAKEN
202589c: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
20258a0: 12 80 00 41 bne 20259a4 <clock_settime+0x114>
20258a4: 80 a6 20 02 cmp %i0, 2
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
20258a8: c6 00 40 00 ld [ %g1 ], %g3
20258ac: 05 08 76 b9 sethi %hi(0x21dae400), %g2
20258b0: 84 10 a0 ff or %g2, 0xff, %g2 ! 21dae4ff <RAM_END+0x1f9ae4ff>
20258b4: 80 a0 c0 02 cmp %g3, %g2
20258b8: 08 80 00 43 bleu 20259c4 <clock_settime+0x134>
20258bc: 05 00 81 88 sethi %hi(0x2062000), %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;
20258c0: c6 00 a0 40 ld [ %g2 + 0x40 ], %g3 ! 2062040 <_Thread_Dispatch_disable_level>
++level;
20258c4: 86 00 e0 01 inc %g3
_Thread_Dispatch_disable_level = level;
20258c8: c6 20 a0 40 st %g3, [ %g2 + 0x40 ]
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
20258cc: c6 00 40 00 ld [ %g1 ], %g3
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
20258d0: 90 07 bf f8 add %fp, -8, %o0
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
20258d4: 85 38 e0 1f sra %g3, 0x1f, %g2
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
20258d8: 89 28 a0 03 sll %g2, 3, %g4
20258dc: bb 28 e0 03 sll %g3, 3, %i5
20258e0: b7 30 e0 1d srl %g3, 0x1d, %i3
20258e4: b8 16 c0 04 or %i3, %g4, %i4
20258e8: 89 37 60 1b srl %i5, 0x1b, %g4
20258ec: b5 2f 20 05 sll %i4, 5, %i2
20258f0: b7 2f 60 05 sll %i5, 5, %i3
20258f4: b4 11 00 1a or %g4, %i2, %i2
20258f8: ba a6 c0 1d subcc %i3, %i5, %i5
20258fc: 89 37 60 1a srl %i5, 0x1a, %g4
2025900: b8 66 80 1c subx %i2, %i4, %i4
2025904: b7 2f 60 06 sll %i5, 6, %i3
2025908: b5 2f 20 06 sll %i4, 6, %i2
202590c: b6 a6 c0 1d subcc %i3, %i5, %i3
2025910: b4 11 00 1a or %g4, %i2, %i2
2025914: b4 66 80 1c subx %i2, %i4, %i2
2025918: b2 86 c0 03 addcc %i3, %g3, %i1
202591c: b0 46 80 02 addx %i2, %g2, %i0
2025920: 89 36 60 1e srl %i1, 0x1e, %g4
2025924: 85 2e 20 02 sll %i0, 2, %g2
2025928: 84 11 00 02 or %g4, %g2, %g2
202592c: 87 2e 60 02 sll %i1, 2, %g3
2025930: ba 86 40 03 addcc %i1, %g3, %i5
2025934: b8 46 00 02 addx %i0, %g2, %i4
2025938: 89 37 60 1e srl %i5, 0x1e, %g4
202593c: 85 2f 20 02 sll %i4, 2, %g2
2025940: 84 11 00 02 or %g4, %g2, %g2
2025944: 87 2f 60 02 sll %i5, 2, %g3
2025948: b6 87 40 03 addcc %i5, %g3, %i3
202594c: b4 47 00 02 addx %i4, %g2, %i2
2025950: bb 2e e0 02 sll %i3, 2, %i5
2025954: 85 36 e0 1e srl %i3, 0x1e, %g2
2025958: 86 86 c0 1d addcc %i3, %i5, %g3
202595c: b9 2e a0 02 sll %i2, 2, %i4
2025960: b8 10 80 1c or %g2, %i4, %i4
2025964: 84 46 80 1c addx %i2, %i4, %g2
2025968: bb 28 a0 09 sll %g2, 9, %i5
202596c: b9 30 e0 17 srl %g3, 0x17, %i4
2025970: 84 17 00 1d or %i4, %i5, %g2
2025974: fa 00 60 04 ld [ %g1 + 4 ], %i5
2025978: 89 28 e0 09 sll %g3, 9, %g4
202597c: b6 81 00 1d addcc %g4, %i5, %i3
2025980: b9 3f 60 1f sra %i5, 0x1f, %i4
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
2025984: b0 10 20 00 clr %i0
2025988: b4 40 80 1c addx %g2, %i4, %i2
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
202598c: 40 00 04 3b call 2026a78 <_TOD_Set_with_timestamp>
2025990: f4 3f bf f8 std %i2, [ %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();
2025994: 7f ff 90 d0 call 2009cd4 <_Thread_Enable_dispatch>
2025998: 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;
202599c: 81 c7 e0 08 ret
20259a0: 81 e8 00 00 restore
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
20259a4: 02 80 00 04 be 20259b4 <clock_settime+0x124>
20259a8: 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 )
20259ac: 12 80 00 06 bne 20259c4 <clock_settime+0x134>
20259b0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
20259b4: 40 00 44 28 call 2036a54 <__errno>
20259b8: 01 00 00 00 nop
20259bc: 10 80 00 05 b 20259d0 <clock_settime+0x140>
20259c0: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
20259c4: 40 00 44 24 call 2036a54 <__errno>
20259c8: 01 00 00 00 nop
20259cc: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
20259d0: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
20259d4: 81 c7 e0 08 ret
20259d8: 91 e8 3f ff restore %g0, -1, %o0
02003624 <create_disk>:
dev_t dev,
const char *name,
rtems_disk_device **dd_ptr,
char **alloc_name_ptr
)
{
2003624: 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) {
2003628: 03 00 80 85 sethi %hi(0x2021400), %g1
200362c: e0 00 61 30 ld [ %g1 + 0x130 ], %l0 ! 2021530 <disktab_size>
2003630: 80 a6 00 10 cmp %i0, %l0
2003634: 0a 80 00 16 bcs 200368c <create_disk+0x68>
2003638: 03 00 80 85 sethi %hi(0x2021400), %g1
rtems_disk_device_table *table = disktab;
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
200363c: bb 2c 20 01 sll %l0, 1, %i5
if (major >= new_size) {
2003640: 80 a6 00 1d cmp %i0, %i5
2003644: 0a 80 00 03 bcs 2003650 <create_disk+0x2c> <== NEVER TAKEN
2003648: d0 00 61 34 ld [ %g1 + 0x134 ], %o0
new_size = major + 1;
200364c: ba 06 20 01 add %i0, 1, %i5
}
table = realloc(table, new_size * sizeof(*table));
2003650: 40 00 08 7a call 2005838 <realloc>
2003654: 93 2f 60 03 sll %i5, 3, %o1
if (table == NULL) {
2003658: a2 92 20 00 orcc %o0, 0, %l1
200365c: 02 80 00 58 be 20037bc <create_disk+0x198> <== ALWAYS TAKEN
2003660: 94 27 40 10 sub %i5, %l0, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2003664: 91 2c 20 03 sll %l0, 3, %o0 <== NOT EXECUTED
2003668: 92 10 20 00 clr %o1 <== NOT EXECUTED
200366c: 90 04 40 08 add %l1, %o0, %o0 <== NOT EXECUTED
2003670: 40 00 43 6e call 2014428 <memset> <== NOT EXECUTED
2003674: 95 2a a0 03 sll %o2, 3, %o2 <== NOT EXECUTED
disktab = table;
2003678: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
200367c: e2 20 61 34 st %l1, [ %g1 + 0x134 ] ! 2021534 <disktab> <== NOT EXECUTED
disktab_size = new_size;
2003680: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
2003684: fa 20 61 30 st %i5, [ %g1 + 0x130 ] ! 2021530 <disktab_size><== NOT EXECUTED
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
2003688: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
200368c: e4 00 61 34 ld [ %g1 + 0x134 ], %l2 ! 2021534 <disktab>
2003690: a3 2e 20 03 sll %i0, 3, %l1
2003694: d0 04 80 11 ld [ %l2 + %l1 ], %o0
2003698: a8 04 80 11 add %l2, %l1, %l4
200369c: 80 a2 20 00 cmp %o0, 0
20036a0: 02 80 00 05 be 20036b4 <create_disk+0x90>
20036a4: e0 05 20 04 ld [ %l4 + 4 ], %l0
20036a8: 80 a6 40 10 cmp %i1, %l0
20036ac: 2a 80 00 16 bcs,a 2003704 <create_disk+0xe0>
20036b0: e2 04 80 11 ld [ %l2 + %l1 ], %l1
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
20036b4: 80 a4 20 00 cmp %l0, 0
20036b8: 02 80 00 03 be 20036c4 <create_disk+0xa0>
20036bc: ba 10 20 08 mov 8, %i5
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
20036c0: bb 2c 20 01 sll %l0, 1, %i5
}
if (minor >= new_size) {
20036c4: 80 a6 40 1d cmp %i1, %i5
20036c8: 3a 80 00 02 bcc,a 20036d0 <create_disk+0xac>
20036cc: ba 06 60 01 add %i1, 1, %i5
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
20036d0: 40 00 08 5a call 2005838 <realloc>
20036d4: 93 2f 60 02 sll %i5, 2, %o1
if (table == NULL) {
20036d8: a6 92 20 00 orcc %o0, 0, %l3
20036dc: 02 80 00 38 be 20037bc <create_disk+0x198>
20036e0: 94 27 40 10 sub %i5, %l0, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
20036e4: 91 2c 20 02 sll %l0, 2, %o0
20036e8: 92 10 20 00 clr %o1
20036ec: 90 04 c0 08 add %l3, %o0, %o0
20036f0: 40 00 43 4e call 2014428 <memset>
20036f4: 95 2a a0 02 sll %o2, 2, %o2
disktab [major].minor = table;
20036f8: e6 24 80 11 st %l3, [ %l2 + %l1 ]
disktab [major].size = new_size;
20036fc: fa 25 20 04 st %i5, [ %l4 + 4 ]
}
return disktab [major].minor + minor;
2003700: e2 04 80 11 ld [ %l2 + %l1 ], %l1
2003704: a1 2e 60 02 sll %i1, 2, %l0
2003708: 82 04 40 10 add %l1, %l0, %g1
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
200370c: 80 a0 60 00 cmp %g1, 0
2003710: 32 80 00 04 bne,a 2003720 <create_disk+0xfc> <== ALWAYS TAKEN
2003714: c4 04 40 10 ld [ %l1 + %l0 ], %g2
return RTEMS_NO_MEMORY;
2003718: 10 80 00 2a b 20037c0 <create_disk+0x19c> <== NOT EXECUTED
200371c: 82 10 20 1a mov 0x1a, %g1 <== NOT EXECUTED
}
if (*dd_entry != NULL) {
2003720: 80 a0 a0 00 cmp %g2, 0
2003724: 12 80 00 27 bne 20037c0 <create_disk+0x19c>
2003728: 82 10 20 0c mov 0xc, %g1
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
200372c: 40 00 05 7d call 2004d20 <malloc>
2003730: 90 10 20 78 mov 0x78, %o0
if (dd == NULL) {
2003734: ba 92 20 00 orcc %o0, 0, %i5
2003738: 02 80 00 21 be 20037bc <create_disk+0x198> <== NEVER TAKEN
200373c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
2003740: 02 80 00 11 be 2003784 <create_disk+0x160>
2003744: a4 10 20 00 clr %l2
alloc_name = strdup(name);
2003748: 40 00 44 91 call 201498c <strdup>
200374c: 90 10 00 1a mov %i2, %o0
if (alloc_name == NULL) {
2003750: a4 92 20 00 orcc %o0, 0, %l2
2003754: 12 80 00 11 bne 2003798 <create_disk+0x174> <== ALWAYS TAKEN
2003758: b4 10 00 08 mov %o0, %i2
free(dd);
200375c: 40 00 04 30 call 200481c <free> <== NOT EXECUTED
2003760: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
2003764: 10 80 00 17 b 20037c0 <create_disk+0x19c> <== NOT EXECUTED
2003768: 82 10 20 1a mov 0x1a, %g1 <== NOT EXECUTED
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
200376c: 40 00 04 2c call 200481c <free> <== NOT EXECUTED
2003770: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
free(dd);
2003774: 40 00 04 2a call 200481c <free> <== NOT EXECUTED
2003778: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
200377c: 10 80 00 11 b 20037c0 <create_disk+0x19c> <== NOT EXECUTED
2003780: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
}
}
*dd_entry = dd;
2003784: fa 24 40 10 st %i5, [ %l1 + %l0 ]
*dd_ptr = dd;
2003788: fa 26 c0 00 st %i5, [ %i3 ]
*alloc_name_ptr = alloc_name;
200378c: e4 27 00 00 st %l2, [ %i4 ]
return RTEMS_SUCCESSFUL;
2003790: 10 80 00 0c b 20037c0 <create_disk+0x19c>
2003794: 82 10 20 00 clr %g1
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
2003798: 13 00 00 18 sethi %hi(0x6000), %o1
200379c: 94 10 00 18 mov %i0, %o2
20037a0: 92 12 61 ff or %o1, 0x1ff, %o1
20037a4: 40 00 05 cf call 2004ee0 <mknod>
20037a8: 96 10 00 19 mov %i1, %o3
20037ac: 80 a2 20 00 cmp %o0, 0
20037b0: 36 bf ff f6 bge,a 2003788 <create_disk+0x164> <== ALWAYS TAKEN
20037b4: fa 24 40 10 st %i5, [ %l1 + %l0 ]
20037b8: 30 bf ff ed b,a 200376c <create_disk+0x148> <== NOT EXECUTED
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
20037bc: 82 10 20 1a mov 0x1a, %g1
*dd_entry = dd;
*dd_ptr = dd;
*alloc_name_ptr = alloc_name;
return RTEMS_SUCCESSFUL;
}
20037c0: 81 c7 e0 08 ret
20037c4: 91 e8 00 01 restore %g0, %g1, %o0
0200490c <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)
200490c: 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)
2004910: 90 10 20 01 mov 1, %o0
* RTEMS_SUCCESSFUL, if success;
* RTEMS_NO_MEMOTY, if cannot allocate memory for part_desc_t strucure;
* RTEMS_INTERNAL_ERROR, if other error occurs.
*/
static rtems_status_code
data_to_part_desc(uint8_t *data, rtems_part_desc_t **new_part_desc)
2004914: b8 10 00 18 mov %i0, %i4
if (new_part_desc == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
*new_part_desc = NULL;
2004918: c0 26 40 00 clr [ %i1 ]
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
200491c: 92 10 20 28 mov 0x28, %o1
2004920: 40 00 03 06 call 2005538 <calloc>
2004924: b0 10 20 1a mov 0x1a, %i0
2004928: 80 a2 20 00 cmp %o0, 0
200492c: 02 80 00 27 be 20049c8 <data_to_part_desc.part.1+0xbc> <== NEVER TAKEN
2004930: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
2004934: c2 0f 00 00 ldub [ %i4 ], %g1
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
2004938: 92 07 20 08 add %i4, 8, %o1
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
200493c: c2 2a 00 00 stb %g1, [ %o0 ]
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
2004940: f6 0f 20 04 ldub [ %i4 + 4 ], %i3
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
2004944: 94 10 20 04 mov 4, %o2
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
2004948: f6 2a 20 01 stb %i3, [ %o0 + 1 ]
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
200494c: 40 00 43 49 call 2015670 <memcpy>
2004950: 90 07 bf fc add %fp, -4, %o0
part_desc->start = LE_TO_CPU_U32(temp);
2004954: 7f ff ff ac call 2004804 <CPU_swap_u32>
2004958: d0 07 bf fc ld [ %fp + -4 ], %o0
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
200495c: 92 07 20 0c add %i4, 0xc, %o1
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
part_desc->start = LE_TO_CPU_U32(temp);
2004960: d0 27 60 04 st %o0, [ %i5 + 4 ]
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
2004964: 94 10 20 04 mov 4, %o2
2004968: 40 00 43 42 call 2015670 <memcpy>
200496c: 90 07 bf fc add %fp, -4, %o0
part_desc->size = LE_TO_CPU_U32(temp);
2004970: 7f ff ff a5 call 2004804 <CPU_swap_u32>
2004974: d0 07 bf fc ld [ %fp + -4 ], %o0
2004978: d0 27 60 08 st %o0, [ %i5 + 8 ]
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
200497c: 82 0e e0 7f and %i3, 0x7f, %g1
2004980: 80 a0 60 05 cmp %g1, 5
2004984: 02 80 00 0c be 20049b4 <data_to_part_desc.part.1+0xa8>
2004988: b8 10 00 08 mov %o0, %i4
DOS_P32MB_PARTITION,
FAT32_PARTITION ,FAT32_LBA_PARTITION,
FAT16_LBA_PARTITION
};
return (NULL != memchr(fat_part_types,type,sizeof(fat_part_types)));
200498c: 11 00 80 90 sethi %hi(0x2024000), %o0
2004990: 92 0e e0 ff and %i3, 0xff, %o1
2004994: 90 12 23 38 or %o0, 0x338, %o0
2004998: 40 00 42 c8 call 20154b8 <memchr>
200499c: 94 10 20 06 mov 6, %o2
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
20049a0: 80 a2 20 00 cmp %o0, 0
20049a4: 02 80 00 06 be 20049bc <data_to_part_desc.part.1+0xb0>
20049a8: 80 a7 20 00 cmp %i4, 0
((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
20049ac: 02 80 00 04 be 20049bc <data_to_part_desc.part.1+0xb0> <== NEVER TAKEN
20049b0: 01 00 00 00 nop
*new_part_desc = part_desc;
20049b4: 10 80 00 04 b 20049c4 <data_to_part_desc.part.1+0xb8>
20049b8: fa 26 40 00 st %i5, [ %i1 ]
}
else {
/* empty partition */
free(part_desc);
20049bc: 40 00 03 b3 call 2005888 <free>
20049c0: 90 10 00 1d mov %i5, %o0
}
return RTEMS_SUCCESSFUL;
20049c4: b0 10 20 00 clr %i0
}
20049c8: 81 c7 e0 08 ret
20049cc: 81 e8 00 00 restore
02002a3c <devFS_Show>:
#endif
#include "devfs.h"
void devFS_Show(void)
{
2002a3c: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
2002a40: 03 00 80 68 sethi %hi(0x201a000), %g1
2002a44: c2 00 60 84 ld [ %g1 + 0x84 ], %g1 ! 201a084 <rtems_current_user_env>
if (rootloc->mt_entry->ops == &devFS_ops) {
2002a48: 05 00 80 61 sethi %hi(0x2018400), %g2
2002a4c: c2 00 60 04 ld [ %g1 + 4 ], %g1
2002a50: 84 10 a0 ec or %g2, 0xec, %g2
2002a54: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
2002a58: c6 00 60 0c ld [ %g1 + 0xc ], %g3
2002a5c: 80 a0 c0 02 cmp %g3, %g2
2002a60: 12 80 00 25 bne 2002af4 <devFS_Show+0xb8> <== NEVER TAKEN
2002a64: 33 00 80 61 sethi %hi(0x2018400), %i1
static inline const devFS_data *devFS_get_data(
const rtems_filesystem_location_info_t *loc
)
{
return (const devFS_data *) loc->mt_entry->immutable_fs_info;
2002a68: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
size_t j = 0;
size_t m = current->namelen;
printk("/");
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
2002a6c: 31 00 80 61 sethi %hi(0x2018400), %i0
}
printk(
2002a70: 21 00 80 61 sethi %hi(0x2018400), %l0
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
if (rootloc->mt_entry->ops == &devFS_ops) {
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
2002a74: f4 00 60 04 ld [ %g1 + 4 ], %i2
2002a78: fa 00 40 00 ld [ %g1 ], %i5
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
2002a7c: b6 10 20 00 clr %i3
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
2002a80: b2 16 61 40 or %i1, 0x140, %i1
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
2002a84: b0 16 21 48 or %i0, 0x148, %i0
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
2002a88: 10 80 00 18 b 2002ae8 <devFS_Show+0xac>
2002a8c: a0 14 21 50 or %l0, 0x150, %l0
devFS_node *current = nodes + i;
if (current->name != NULL) {
2002a90: 80 a0 60 00 cmp %g1, 0
2002a94: 22 80 00 14 be,a 2002ae4 <devFS_Show+0xa8>
2002a98: b6 06 e0 01 inc %i3
size_t j = 0;
size_t m = current->namelen;
2002a9c: e2 07 60 04 ld [ %i5 + 4 ], %l1
printk("/");
2002aa0: 90 10 00 19 mov %i1, %o0
2002aa4: 40 00 04 94 call 2003cf4 <printk>
2002aa8: b8 10 20 00 clr %i4
for (j = 0; j < m; ++j) {
2002aac: 10 80 00 07 b 2002ac8 <devFS_Show+0x8c>
2002ab0: 80 a7 00 11 cmp %i4, %l1
printk("%c", current->name [j]);
2002ab4: 90 10 00 18 mov %i0, %o0
2002ab8: d2 48 40 1c ldsb [ %g1 + %i4 ], %o1
2002abc: 40 00 04 8e call 2003cf4 <printk>
2002ac0: b8 07 20 01 inc %i4
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
for (j = 0; j < m; ++j) {
2002ac4: 80 a7 00 11 cmp %i4, %l1
2002ac8: 32 bf ff fb bne,a 2002ab4 <devFS_Show+0x78>
2002acc: c2 07 40 00 ld [ %i5 ], %g1
printk("%c", current->name [j]);
}
printk(
2002ad0: d2 07 60 08 ld [ %i5 + 8 ], %o1
2002ad4: d4 07 60 0c ld [ %i5 + 0xc ], %o2
2002ad8: 40 00 04 87 call 2003cf4 <printk>
2002adc: 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) {
2002ae0: b6 06 e0 01 inc %i3
2002ae4: ba 07 60 14 add %i5, 0x14, %i5
2002ae8: 80 a6 c0 1a cmp %i3, %i2
2002aec: 32 bf ff e9 bne,a 2002a90 <devFS_Show+0x54>
2002af0: c2 07 40 00 ld [ %i5 ], %g1
2002af4: 81 c7 e0 08 ret
2002af8: 81 e8 00 00 restore
0200bbec <devFS_eval_path>:
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
200bbec: 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;
200bbf0: 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;
200bbf4: f2 06 00 00 ld [ %i0 ], %i1
200bbf8: 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;
200bbfc: f6 06 20 04 ld [ %i0 + 4 ], %i3
size_t pathlen,
devFS_node **free_node_ptr
)
{
size_t i = 0;
size_t n = data->count;
200bc00: e2 00 60 04 ld [ %g1 + 4 ], %l1
200bc04: fa 00 40 00 ld [ %g1 ], %i5
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
200bc08: b8 10 20 00 clr %i4
devFS_node *free_node = NULL;
200bc0c: 82 10 20 00 clr %g1
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
200bc10: 10 80 00 12 b 200bc58 <devFS_eval_path+0x6c>
200bc14: b4 10 20 00 clr %i2
devFS_node *current = nodes + i;
if (current->name != NULL) {
200bc18: 80 a2 20 00 cmp %o0, 0
200bc1c: 02 80 00 0c be 200bc4c <devFS_eval_path+0x60>
200bc20: a0 10 00 1d mov %i5, %l0
if (
200bc24: c4 07 60 04 ld [ %i5 + 4 ], %g2
200bc28: 80 a0 80 1b cmp %g2, %i3
200bc2c: 12 80 00 08 bne 200bc4c <devFS_eval_path+0x60>
200bc30: a0 10 00 01 mov %g1, %l0
current->namelen == pathlen
&& memcmp(current->name, path, pathlen) == 0
200bc34: 92 10 00 19 mov %i1, %o1
200bc38: 40 00 0d 82 call 200f240 <memcmp>
200bc3c: 94 10 00 1b mov %i3, %o2
200bc40: 80 a2 20 00 cmp %o0, 0
200bc44: 22 80 00 02 be,a 200bc4c <devFS_eval_path+0x60>
200bc48: b8 10 00 1d mov %i5, %i4
size_t n = data->count;
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
devFS_node *free_node = NULL;
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
200bc4c: b4 06 a0 01 inc %i2
200bc50: ba 07 60 14 add %i5, 0x14, %i5
200bc54: 82 10 00 10 mov %l0, %g1
200bc58: 80 a7 20 00 cmp %i4, 0
200bc5c: 02 80 00 0a be 200bc84 <devFS_eval_path+0x98>
200bc60: 80 a6 80 11 cmp %i2, %l1
200bc64: 80 a0 60 00 cmp %g1, 0
200bc68: 02 80 00 07 be 200bc84 <devFS_eval_path+0x98>
200bc6c: 80 a6 80 11 cmp %i2, %l1
rtems_filesystem_eval_path_get_pathlen(ctx),
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
200bc70: 80 a7 20 00 cmp %i4, 0
200bc74: 12 80 00 08 bne 200bc94 <devFS_eval_path+0xa8>
200bc78: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
}
} else {
if ((eval_flags & RTEMS_FS_MAKE) != 0) {
200bc7c: 10 80 00 0b b 200bca8 <devFS_eval_path+0xbc>
200bc80: 80 88 a0 20 btst 0x20, %g2
size_t n = data->count;
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
devFS_node *free_node = NULL;
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
200bc84: 32 bf ff e5 bne,a 200bc18 <devFS_eval_path+0x2c>
200bc88: d0 07 40 00 ld [ %i5 ], %o0
rtems_filesystem_eval_path_get_pathlen(ctx),
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
200bc8c: 10 bf ff fa b 200bc74 <devFS_eval_path+0x88>
200bc90: 80 a7 20 00 cmp %i4, 0
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
200bc94: 80 88 a0 40 btst 0x40, %g2
200bc98: 12 80 00 12 bne 200bce0 <devFS_eval_path+0xf4>
200bc9c: b2 10 20 11 mov 0x11, %i1
currentloc->node_access = node;
200bca0: 10 80 00 0a b 200bcc8 <devFS_eval_path+0xdc>
200bca4: f8 26 20 20 st %i4, [ %i0 + 0x20 ]
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
}
} else {
if ((eval_flags & RTEMS_FS_MAKE) != 0) {
200bca8: 02 80 00 0d be 200bcdc <devFS_eval_path+0xf0> <== NEVER TAKEN
200bcac: 80 a0 60 00 cmp %g1, 0
if (free_node != NULL) {
200bcb0: 02 80 00 09 be 200bcd4 <devFS_eval_path+0xe8>
200bcb4: 84 10 21 ff mov 0x1ff, %g2
free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;
200bcb8: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
currentloc->node_access = free_node;
200bcbc: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
rtems_filesystem_eval_path_context_t *ctx,
const char *token,
size_t tokenlen
)
{
ctx->token = token;
200bcc0: f2 26 20 08 st %i1, [ %i0 + 8 ]
ctx->tokenlen = tokenlen;
200bcc4: f6 26 20 0c st %i3, [ %i0 + 0xc ]
static inline void rtems_filesystem_eval_path_clear_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->pathlen = 0;
200bcc8: c0 26 20 04 clr [ %i0 + 4 ]
200bccc: 81 c7 e0 08 ret
200bcd0: 81 e8 00 00 restore
rtems_filesystem_eval_path_get_path(ctx),
rtems_filesystem_eval_path_get_pathlen(ctx)
);
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, ENOSPC);
200bcd4: 10 80 00 03 b 200bce0 <devFS_eval_path+0xf4>
200bcd8: b2 10 20 1c mov 0x1c, %i1
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
200bcdc: b2 10 20 02 mov 2, %i1 <== NOT EXECUTED
200bce0: 7f ff e3 de call 2004c58 <rtems_filesystem_eval_path_error>
200bce4: 81 e8 00 00 restore
020035fc <devFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
20035fc: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
2003600: 80 a6 a0 03 cmp %i2, 3
2003604: 12 80 00 0e bne 200363c <devFS_mknod+0x40>
2003608: 05 00 00 2c sethi %hi(0xb000), %g2
200360c: c2 4e 40 00 ldsb [ %i1 ], %g1
2003610: 80 a0 60 64 cmp %g1, 0x64
2003614: 12 80 00 0b bne 2003640 <devFS_mknod+0x44> <== NEVER TAKEN
2003618: 03 00 00 08 sethi %hi(0x2000), %g1
200361c: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1
2003620: 80 a0 60 65 cmp %g1, 0x65
2003624: 12 80 00 07 bne 2003640 <devFS_mknod+0x44> <== NEVER TAKEN
2003628: 03 00 00 08 sethi %hi(0x2000), %g1
200362c: c2 4e 60 02 ldsb [ %i1 + 2 ], %g1
2003630: 80 a0 60 76 cmp %g1, 0x76
2003634: 02 80 00 1b be 20036a0 <devFS_mknod+0xa4> <== ALWAYS TAKEN
2003638: 03 00 00 3c sethi %hi(0xf000), %g1
if (S_ISBLK(mode) || S_ISCHR(mode)) {
200363c: 03 00 00 08 sethi %hi(0x2000), %g1
2003640: 84 0e c0 02 and %i3, %g2, %g2
2003644: 80 a0 80 01 cmp %g2, %g1
2003648: 12 80 00 1b bne 20036b4 <devFS_mknod+0xb8>
200364c: 01 00 00 00 nop
char *dupname = malloc(namelen);
2003650: 40 00 01 e6 call 2003de8 <malloc>
2003654: 90 10 00 1a mov %i2, %o0
if (dupname != NULL) {
2003658: 84 92 20 00 orcc %o0, 0, %g2
200365c: 02 80 00 0d be 2003690 <devFS_mknod+0x94>
2003660: 92 10 00 19 mov %i1, %o1
devFS_node *node = parentloc->node_access;
2003664: c2 06 20 08 ld [ %i0 + 8 ], %g1
node->name = dupname;
2003668: c4 20 40 00 st %g2, [ %g1 ]
node->namelen = namelen;
200366c: f4 20 60 04 st %i2, [ %g1 + 4 ]
node->major = rtems_filesystem_dev_major_t(dev);
2003670: f8 20 60 08 st %i4, [ %g1 + 8 ]
node->minor = rtems_filesystem_dev_minor_t(dev);
2003674: fa 20 60 0c st %i5, [ %g1 + 0xc ]
node->mode = mode;
2003678: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
memcpy(dupname, name, namelen);
200367c: 94 10 00 1a mov %i2, %o2
2003680: 40 00 2f 1a call 200f2e8 <memcpy>
2003684: b0 10 20 00 clr %i0
2003688: 81 c7 e0 08 ret
200368c: 81 e8 00 00 restore
} else {
errno = ENOMEM;
2003690: 40 00 2b 11 call 200e2d4 <__errno>
2003694: 01 00 00 00 nop
2003698: 10 80 00 0a b 20036c0 <devFS_mknod+0xc4>
200369c: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
} else {
errno = ENOTSUP;
rv = -1;
}
} else {
if (!S_ISDIR(mode)) {
20036a0: b6 0e c0 01 and %i3, %g1, %i3
20036a4: 03 00 00 10 sethi %hi(0x4000), %g1
20036a8: 80 a6 c0 01 cmp %i3, %g1
20036ac: 02 bf ff f7 be 2003688 <devFS_mknod+0x8c> <== ALWAYS TAKEN
20036b0: b0 10 20 00 clr %i0
errno = ENOTSUP;
20036b4: 40 00 2b 08 call 200e2d4 <__errno>
20036b8: 01 00 00 00 nop
20036bc: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
20036c0: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
20036c4: b0 10 3f ff mov -1, %i0
}
}
return rv;
}
20036c8: 81 c7 e0 08 ret
20036cc: 81 e8 00 00 restore
020035b4 <disk_lock>:
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
20035b4: 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);
20035b8: 03 00 80 85 sethi %hi(0x2021400), %g1
20035bc: d0 00 61 2c ld [ %g1 + 0x12c ], %o0 ! 202152c <diskdevs_mutex>
20035c0: 92 10 20 00 clr %o1
20035c4: 94 10 20 00 clr %o2
20035c8: 40 00 15 4c call 2008af8 <rtems_semaphore_obtain>
20035cc: b0 10 20 16 mov 0x16, %i0
if (sc == RTEMS_SUCCESSFUL) {
20035d0: 80 a2 20 00 cmp %o0, 0
20035d4: 12 80 00 05 bne 20035e8 <disk_lock+0x34> <== NEVER TAKEN
20035d8: 84 10 20 01 mov 1, %g2
diskdevs_protected = true;
20035dc: 03 00 80 85 sethi %hi(0x2021400), %g1
return RTEMS_SUCCESSFUL;
20035e0: 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;
20035e4: c4 28 61 28 stb %g2, [ %g1 + 0x128 ]
return RTEMS_SUCCESSFUL;
} else {
return RTEMS_NOT_CONFIGURED;
}
}
20035e8: 81 c7 e0 08 ret
20035ec: 81 e8 00 00 restore
020035f0 <disk_unlock>:
static void
disk_unlock(void)
{
20035f0: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
20035f4: 03 00 80 85 sethi %hi(0x2021400), %g1
20035f8: c0 28 61 28 clrb [ %g1 + 0x128 ] ! 2021528 <diskdevs_protected>
sc = rtems_semaphore_release(diskdevs_mutex);
20035fc: 03 00 80 85 sethi %hi(0x2021400), %g1
2003600: 40 00 15 87 call 2008c1c <rtems_semaphore_release>
2003604: d0 00 61 2c ld [ %g1 + 0x12c ], %o0 ! 202152c <diskdevs_mutex>
if (sc != RTEMS_SUCCESSFUL) {
2003608: 80 a2 20 00 cmp %o0, 0
200360c: 02 80 00 04 be 200361c <disk_unlock+0x2c> <== ALWAYS TAKEN
2003610: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
2003614: 40 00 16 fe call 200920c <rtems_fatal_error_occurred> <== NOT EXECUTED
2003618: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
200361c: 81 c7 e0 08 ret
2003620: 81 e8 00 00 restore
02005124 <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
2005124: 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);
2005128: 7f ff f5 27 call 20025c4 <sparc_disable_interrupts>
200512c: 01 00 00 00 nop
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
2005130: 10 80 00 0f b 200516c <drainOutput.part.0+0x48>
2005134: b8 10 20 02 mov 2, %i4 ! 2 <PROM_START+0x2>
rtems_interrupt_enable (level);
2005138: 7f ff f5 27 call 20025d4 <sparc_enable_interrupts> <== NOT EXECUTED
200513c: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain(
2005140: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED
2005144: 92 10 20 00 clr %o1 <== NOT EXECUTED
2005148: 40 00 09 5f call 20076c4 <rtems_semaphore_obtain> <== NOT EXECUTED
200514c: 94 10 20 00 clr %o2 <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2005150: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2005154: 02 80 00 04 be 2005164 <drainOutput.part.0+0x40> <== NOT EXECUTED
2005158: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
200515c: 40 00 0b 37 call 2007e38 <rtems_fatal_error_occurred> <== NOT EXECUTED
2005160: 01 00 00 00 nop <== NOT EXECUTED
rtems_interrupt_disable (level);
2005164: 7f ff f5 18 call 20025c4 <sparc_disable_interrupts> <== NOT EXECUTED
2005168: 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) {
200516c: c4 06 20 84 ld [ %i0 + 0x84 ], %g2
2005170: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
2005174: 80 a0 80 01 cmp %g2, %g1
2005178: 32 bf ff f0 bne,a 2005138 <drainOutput.part.0+0x14> <== NEVER TAKEN
200517c: 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);
2005180: 7f ff f5 15 call 20025d4 <sparc_enable_interrupts>
2005184: 91 e8 00 08 restore %g0, %o0, %o0
02003a40 <dup2>:
*/
int dup2(
int fildes,
int fildes2
)
{
2003a40: 9d e3 bf 58 save %sp, -168, %sp
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
2003a44: 90 10 00 18 mov %i0, %o0
2003a48: 40 00 01 e2 call 20041d0 <fstat>
2003a4c: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
2003a50: 80 a2 3f ff cmp %o0, -1
2003a54: 12 80 00 04 bne 2003a64 <dup2+0x24>
2003a58: 90 10 00 19 mov %i1, %o0
return -1;
2003a5c: 81 c7 e0 08 ret
2003a60: 91 e8 3f ff restore %g0, -1, %o0
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
2003a64: 40 00 01 db call 20041d0 <fstat>
2003a68: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
2003a6c: 80 a2 3f ff cmp %o0, -1
2003a70: 02 bf ff fb be 2003a5c <dup2+0x1c> <== NEVER TAKEN
2003a74: 90 10 00 18 mov %i0, %o0
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
2003a78: 92 10 20 00 clr %o1
2003a7c: 40 00 00 af call 2003d38 <fcntl>
2003a80: 94 10 00 19 mov %i1, %o2
}
2003a84: 81 c7 e0 08 ret
2003a88: 91 e8 00 08 restore %g0, %o0, %o0
02005f10 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
2005f10: 9d e3 bf 98 save %sp, -104, %sp
if ((tty->termios.c_lflag & ECHOCTL) &&
2005f14: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
2005f18: 80 88 62 00 btst 0x200, %g1
2005f1c: 02 80 00 19 be 2005f80 <echo+0x70> <== NEVER TAKEN
2005f20: 03 00 80 73 sethi %hi(0x201cc00), %g1
iscntrl(c) && (c != '\t') && (c != '\n')) {
2005f24: c2 00 60 58 ld [ %g1 + 0x58 ], %g1 ! 201cc58 <__ctype_ptr__>
2005f28: 82 00 40 18 add %g1, %i0, %g1
2005f2c: 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) &&
2005f30: 80 88 60 20 btst 0x20, %g1
2005f34: 02 80 00 14 be 2005f84 <echo+0x74>
2005f38: 90 10 00 18 mov %i0, %o0
iscntrl(c) && (c != '\t') && (c != '\n')) {
2005f3c: 82 06 3f f7 add %i0, -9, %g1
2005f40: 82 08 60 ff and %g1, 0xff, %g1
2005f44: 80 a0 60 01 cmp %g1, 1
2005f48: 08 80 00 0f bleu 2005f84 <echo+0x74>
2005f4c: 82 10 20 5e mov 0x5e, %g1
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
2005f50: 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] = '^';
2005f54: c2 2f bf f8 stb %g1, [ %fp + -8 ]
echobuf[1] = c ^ 0x40;
2005f58: f0 2f bf f9 stb %i0, [ %fp + -7 ]
rtems_termios_puts (echobuf, 2, tty);
2005f5c: 90 07 bf f8 add %fp, -8, %o0
2005f60: 92 10 20 02 mov 2, %o1
2005f64: 7f ff ff 43 call 2005c70 <rtems_termios_puts>
2005f68: 94 10 00 19 mov %i1, %o2
tty->column += 2;
2005f6c: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
2005f70: 82 00 60 02 add %g1, 2, %g1
2005f74: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
2005f78: 81 c7 e0 08 ret
2005f7c: 81 e8 00 00 restore
} else {
oproc (c, tty);
2005f80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2005f84: 7f ff ff 84 call 2005d94 <oproc>
2005f88: 92 10 00 19 mov %i1, %o1
2005f8c: 81 c7 e0 08 ret
2005f90: 81 e8 00 00 restore
02024824 <endgrent>:
}
void endgrent(void)
{
if (group_fp != NULL)
2024824: 03 00 81 86 sethi %hi(0x2061800), %g1
2024828: d0 00 62 88 ld [ %g1 + 0x288 ], %o0 ! 2061a88 <group_fp>
202482c: 80 a2 20 00 cmp %o0, 0
2024830: 02 80 00 05 be 2024844 <endgrent+0x20> <== NEVER TAKEN
2024834: 01 00 00 00 nop
fclose(group_fp);
2024838: 82 13 c0 00 mov %o7, %g1
202483c: 40 00 48 d8 call 2036b9c <fclose>
2024840: 9e 10 40 00 mov %g1, %o7
2024844: 81 c3 e0 08 retl <== NOT EXECUTED
02024680 <endpwent>:
}
void endpwent(void)
{
if (passwd_fp != NULL)
2024680: 03 00 81 86 sethi %hi(0x2061800), %g1
2024684: d0 00 61 a8 ld [ %g1 + 0x1a8 ], %o0 ! 20619a8 <passwd_fp>
2024688: 80 a2 20 00 cmp %o0, 0
202468c: 02 80 00 05 be 20246a0 <endpwent+0x20> <== NEVER TAKEN
2024690: 01 00 00 00 nop
fclose(passwd_fp);
2024694: 82 13 c0 00 mov %o7, %g1
2024698: 40 00 49 41 call 2036b9c <fclose>
202469c: 9e 10 40 00 mov %g1, %o7
20246a0: 81 c3 e0 08 retl <== NOT EXECUTED
02005f94 <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)
2005f94: 9d e3 bf a0 save %sp, -96, %sp
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
2005f98: 35 00 80 6c sethi %hi(0x201b000), %i2
* Erase a character or line
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
2005f9c: ba 10 00 18 mov %i0, %i5
2005fa0: 37 00 80 73 sethi %hi(0x201cc00), %i3
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
2005fa4: 31 00 80 6c sethi %hi(0x201b000), %i0
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
2005fa8: b4 16 a3 b8 or %i2, 0x3b8, %i2
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
2005fac: 10 80 00 62 b 2006134 <erase.part.2+0x1a0>
2005fb0: b0 16 23 b0 or %i0, 0x3b0, %i0
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
2005fb4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
2005fb8: 86 00 ff ff add %g3, -1, %g3
2005fbc: c6 27 60 20 st %g3, [ %i5 + 0x20 ]
if (tty->termios.c_lflag & ECHO) {
2005fc0: 80 88 60 08 btst 8, %g1
2005fc4: 02 80 00 59 be 2006128 <erase.part.2+0x194> <== NEVER TAKEN
2005fc8: f8 09 00 03 ldub [ %g4 + %g3 ], %i4
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
2005fcc: 80 a6 60 00 cmp %i1, 0
2005fd0: 32 80 00 08 bne,a 2005ff0 <erase.part.2+0x5c>
2005fd4: b8 0f 20 ff and %i4, 0xff, %i4
2005fd8: 80 88 60 10 btst 0x10, %g1
2005fdc: 32 80 00 05 bne,a 2005ff0 <erase.part.2+0x5c> <== ALWAYS TAKEN
2005fe0: b8 0f 20 ff and %i4, 0xff, %i4
echo (tty->termios.c_cc[VERASE], tty);
2005fe4: f0 0f 60 43 ldub [ %i5 + 0x43 ], %i0 <== NOT EXECUTED
2005fe8: 7f ff ff ca call 2005f10 <echo> <== NOT EXECUTED
2005fec: 93 e8 00 1d restore %g0, %i5, %o1 <== NOT EXECUTED
} else if (c == '\t') {
2005ff0: 80 a7 20 09 cmp %i4, 9
2005ff4: 32 80 00 28 bne,a 2006094 <erase.part.2+0x100>
2005ff8: c4 06 e0 58 ld [ %i3 + 0x58 ], %g2
int col = tty->read_start_column;
2005ffc: f8 07 60 2c ld [ %i5 + 0x2c ], %i4
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
2006000: da 06 e0 58 ld [ %i3 + 0x58 ], %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;
2006004: 84 10 20 00 clr %g2
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
2006008: 10 80 00 12 b 2006050 <erase.part.2+0xbc>
200600c: 82 08 62 00 and %g1, 0x200, %g1
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
2006010: 80 a3 e0 09 cmp %o7, 9
2006014: 12 80 00 04 bne 2006024 <erase.part.2+0x90>
2006018: 84 00 a0 01 inc %g2
col = (col | 7) + 1;
200601c: 10 80 00 0c b 200604c <erase.part.2+0xb8>
2006020: b8 17 20 07 or %i4, 7, %i4
} else if (iscntrl (c)) {
2006024: 9e 03 40 0f add %o5, %o7, %o7
2006028: de 0b e0 01 ldub [ %o7 + 1 ], %o7
200602c: 80 8b e0 20 btst 0x20, %o7
2006030: 22 80 00 08 be,a 2006050 <erase.part.2+0xbc> <== ALWAYS TAKEN
2006034: b8 07 20 01 inc %i4
if (tty->termios.c_lflag & ECHOCTL)
2006038: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200603c: 32 80 00 05 bne,a 2006050 <erase.part.2+0xbc> <== NOT EXECUTED
2006040: b8 07 20 02 add %i4, 2, %i4 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
2006044: 10 80 00 04 b 2006054 <erase.part.2+0xc0> <== NOT EXECUTED
2006048: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
200604c: b8 07 20 01 inc %i4
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
2006050: 80 a0 80 03 cmp %g2, %g3
2006054: 32 bf ff ef bne,a 2006010 <erase.part.2+0x7c>
2006058: de 09 00 02 ldub [ %g4 + %g2 ], %o7
}
/*
* Back up over the tab
*/
while (tty->column > col) {
200605c: 10 80 00 09 b 2006080 <erase.part.2+0xec>
2006060: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
rtems_termios_puts ("\b", 1, tty);
2006064: 92 10 20 01 mov 1, %o1
2006068: 7f ff ff 02 call 2005c70 <rtems_termios_puts>
200606c: 94 10 00 1d mov %i5, %o2
tty->column--;
2006070: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006074: 82 00 7f ff add %g1, -1, %g1
2006078: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
/*
* Back up over the tab
*/
while (tty->column > col) {
200607c: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006080: 80 a0 40 1c cmp %g1, %i4
2006084: 14 bf ff f8 bg 2006064 <erase.part.2+0xd0>
2006088: 90 10 00 18 mov %i0, %o0
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
200608c: 10 80 00 28 b 200612c <erase.part.2+0x198>
2006090: 80 a6 60 00 cmp %i1, 0
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
2006094: b8 07 20 01 inc %i4
2006098: c4 08 80 1c ldub [ %g2 + %i4 ], %g2
200609c: 80 88 a0 20 btst 0x20, %g2
20060a0: 22 80 00 10 be,a 20060e0 <erase.part.2+0x14c> <== ALWAYS TAKEN
20060a4: c2 06 e0 58 ld [ %i3 + 0x58 ], %g1
20060a8: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
20060ac: 02 80 00 0d be 20060e0 <erase.part.2+0x14c> <== NOT EXECUTED
20060b0: c2 06 e0 58 ld [ %i3 + 0x58 ], %g1 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
20060b4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
20060b8: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
20060bc: 7f ff fe ed call 2005c70 <rtems_termios_puts> <== NOT EXECUTED
20060c0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
if (tty->column)
20060c4: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
20060c8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20060cc: 22 80 00 05 be,a 20060e0 <erase.part.2+0x14c> <== NOT EXECUTED
20060d0: c2 06 e0 58 ld [ %i3 + 0x58 ], %g1 <== NOT EXECUTED
tty->column--;
20060d4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
20060d8: c2 27 60 28 st %g1, [ %i5 + 0x28 ] <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
20060dc: c2 06 e0 58 ld [ %i3 + 0x58 ], %g1 <== NOT EXECUTED
20060e0: c2 08 40 1c ldub [ %g1 + %i4 ], %g1
20060e4: 80 88 60 20 btst 0x20, %g1
20060e8: 02 80 00 07 be 2006104 <erase.part.2+0x170> <== ALWAYS TAKEN
20060ec: 90 10 00 1a mov %i2, %o0
20060f0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
20060f4: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
20060f8: 02 80 00 0d be 200612c <erase.part.2+0x198> <== NOT EXECUTED
20060fc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
2006100: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2006104: 92 10 20 03 mov 3, %o1
2006108: 7f ff fe da call 2005c70 <rtems_termios_puts>
200610c: 94 10 00 1d mov %i5, %o2
if (tty->column)
2006110: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006114: 80 a0 60 00 cmp %g1, 0
2006118: 02 80 00 05 be 200612c <erase.part.2+0x198> <== NEVER TAKEN
200611c: 80 a6 60 00 cmp %i1, 0
tty->column--;
2006120: 82 00 7f ff add %g1, -1, %g1
2006124: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
}
}
if (!lineFlag)
2006128: 80 a6 60 00 cmp %i1, 0
200612c: 02 80 00 06 be 2006144 <erase.part.2+0x1b0>
2006130: 01 00 00 00 nop
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
2006134: c6 07 60 20 ld [ %i5 + 0x20 ], %g3
2006138: 80 a0 e0 00 cmp %g3, 0
200613c: 32 bf ff 9e bne,a 2005fb4 <erase.part.2+0x20>
2006140: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
2006144: 81 c7 e0 08 ret
2006148: 81 e8 00 00 restore
02004740 <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
)
{
2004740: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
2004744: 92 10 20 00 clr %o1
2004748: 90 10 00 18 mov %i0, %o0
200474c: 40 00 2e 56 call 20100a4 <memset>
2004750: 94 10 20 38 mov 0x38, %o2
ctx->path = path;
2004754: f2 26 00 00 st %i1, [ %i0 ]
ctx->pathlen = pathlen;
2004758: 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) {
200475c: 80 a6 a0 00 cmp %i2, 0
2004760: 02 80 00 19 be 20047c4 <eval_path_start+0x84>
2004764: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
2004768: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
200476c: 40 00 01 79 call 2004d50 <rtems_filesystem_global_location_obtain>
2004770: 90 10 00 1c mov %i4, %o0
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
2004774: 83 2e e0 18 sll %i3, 0x18, %g1
2004778: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
200477c: 80 a0 60 5c cmp %g1, 0x5c
2004780: 02 80 00 05 be 2004794 <eval_path_start+0x54> <== NEVER TAKEN
2004784: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
2004788: 80 a0 60 2f cmp %g1, 0x2f
200478c: 12 80 00 0a bne 20047b4 <eval_path_start+0x74>
2004790: 90 10 00 1d mov %i5, %o0
++ctx->path;
2004794: c2 06 00 00 ld [ %i0 ], %g1
--ctx->pathlen;
ctx->startloc = rtems_filesystem_global_location_obtain(
2004798: 90 06 20 30 add %i0, 0x30, %o0
char c = ctx->path [0];
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
if (rtems_filesystem_is_delimiter(c)) {
++ctx->path;
200479c: 82 00 60 01 inc %g1
20047a0: c2 26 00 00 st %g1, [ %i0 ]
--ctx->pathlen;
20047a4: c2 06 20 04 ld [ %i0 + 4 ], %g1
20047a8: 82 00 7f ff add %g1, -1, %g1
20047ac: 10 80 00 02 b 20047b4 <eval_path_start+0x74>
20047b0: c2 26 20 04 st %g1, [ %i0 + 4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
&ctx->rootloc
);
} else {
ctx->startloc = rtems_filesystem_global_location_obtain(
20047b4: 40 00 01 67 call 2004d50 <rtems_filesystem_global_location_obtain>
20047b8: 01 00 00 00 nop
20047bc: 10 80 00 0d b 20047f0 <eval_path_start+0xb0>
20047c0: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
);
static inline rtems_filesystem_global_location_t *
rtems_filesystem_global_location_obtain_null(void)
{
rtems_filesystem_global_location_t *global_loc = NULL;
20047c4: c0 27 bf fc clr [ %fp + -4 ]
return rtems_filesystem_global_location_obtain( &global_loc );
20047c8: 40 00 01 62 call 2004d50 <rtems_filesystem_global_location_obtain>
20047cc: 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;
20047d0: c0 27 bf fc clr [ %fp + -4 ]
global_current_ptr
);
}
} else {
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
20047d4: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
return rtems_filesystem_global_location_obtain( &global_loc );
20047d8: 40 00 01 5e call 2004d50 <rtems_filesystem_global_location_obtain>
20047dc: 90 07 bf fc add %fp, -4, %o0
ctx->startloc = rtems_filesystem_global_location_obtain_null();
errno = ENOENT;
20047e0: 40 00 2b a3 call 200f66c <__errno>
20047e4: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
20047e8: 82 10 20 02 mov 2, %g1
20047ec: c2 22 00 00 st %g1, [ %o0 ]
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
20047f0: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
20047f4: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
20047f8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
20047fc: c2 00 40 00 ld [ %g1 ], %g1
2004800: 9f c0 40 00 call %g1
2004804: 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(
2004808: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
200480c: 40 00 1d 77 call 200bde8 <rtems_filesystem_location_clone>
2004810: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
2004814: 90 10 00 18 mov %i0, %o0
2004818: 7f ff ff b0 call 20046d8 <rtems_filesystem_eval_path_continue>
200481c: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
2004820: 81 c7 e0 08 ret
2004824: 81 e8 00 00 restore
02012f44 <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)
{
2012f44: 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);
2012f48: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
2012f4c: c4 0e 20 0c ldub [ %i0 + 0xc ], %g2
2012f50: 84 20 80 01 sub %g2, %g1, %g2
2012f54: 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);
2012f58: b9 2f 40 02 sll %i5, %g2, %i4
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 -
2012f5c: b8 26 40 1c sub %i1, %i4, %i4
fat_block_num_to_sector_num (fs_info,
fat_sector_num_to_block_num (fs_info, sector)))
<< fs_info->vol.sec_log2);
2012f60: b9 2f 00 01 sll %i4, %g1, %i4
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)
2012f64: c2 0e 20 89 ldub [ %i0 + 0x89 ], %g1
2012f68: 80 a0 60 00 cmp %g1, 0
2012f6c: 02 80 00 06 be 2012f84 <fat_buf_access+0x40>
2012f70: 01 00 00 00 nop
2012f74: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
2012f78: 80 a0 40 19 cmp %g1, %i1
2012f7c: 22 80 00 1c be,a 2012fec <fat_buf_access+0xa8>
2012f80: c2 06 20 8c ld [ %i0 + 0x8c ], %g1
{
fat_buf_release(fs_info);
2012f84: 7f ff ff 7c call 2012d74 <fat_buf_release>
2012f88: 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);
2012f8c: 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)
2012f90: 80 a6 a0 01 cmp %i2, 1
2012f94: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
2012f98: 12 80 00 06 bne 2012fb0 <fat_buf_access+0x6c>
2012f9c: 94 06 20 8c add %i0, 0x8c, %o2
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
2012fa0: 7f ff f7 ae call 2010e58 <rtems_bdbuf_read>
2012fa4: 01 00 00 00 nop
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
2012fa8: 10 80 00 05 b 2012fbc <fat_buf_access+0x78>
2012fac: 80 a2 20 00 cmp %o0, 0
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);
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
2012fb0: 7f ff f7 79 call 2010d94 <rtems_bdbuf_get>
2012fb4: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
2012fb8: 80 a2 20 00 cmp %o0, 0
2012fbc: 02 80 00 08 be 2012fdc <fat_buf_access+0x98> <== ALWAYS TAKEN
2012fc0: 82 10 20 01 mov 1, %g1
rtems_set_errno_and_return_minus_one(EIO);
2012fc4: 40 00 21 7a call 201b5ac <__errno> <== NOT EXECUTED
2012fc8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012fcc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2012fd0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2012fd4: 81 c7 e0 08 ret <== NOT EXECUTED
2012fd8: 81 e8 00 00 restore <== NOT EXECUTED
fs_info->c.blk_num = sec_num;
2012fdc: f2 26 20 84 st %i1, [ %i0 + 0x84 ]
fs_info->c.modified = 0;
2012fe0: c0 2e 20 88 clrb [ %i0 + 0x88 ]
fs_info->c.state = FAT_CACHE_ACTUAL;
2012fe4: c2 2e 20 89 stb %g1, [ %i0 + 0x89 ]
}
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
2012fe8: c2 06 20 8c ld [ %i0 + 0x8c ], %g1
2012fec: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2012ff0: b8 00 40 1c add %g1, %i4, %i4
2012ff4: f8 26 c0 00 st %i4, [ %i3 ]
return RC_OK;
}
2012ff8: 81 c7 e0 08 ret
2012ffc: 91 e8 20 00 restore %g0, 0, %o0
02012d74 <fat_buf_release>:
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
2012d74: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
2012d78: c2 0e 20 89 ldub [ %i0 + 0x89 ], %g1
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
2012d7c: ba 10 00 18 mov %i0, %i5
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
2012d80: 80 a0 60 00 cmp %g1, 0
2012d84: 02 80 00 6e be 2012f3c <fat_buf_release+0x1c8>
2012d88: b0 10 20 00 clr %i0
return RC_OK;
if (fs_info->c.modified)
2012d8c: c2 0f 60 88 ldub [ %i5 + 0x88 ], %g1
2012d90: 80 a0 60 00 cmp %g1, 0
2012d94: 02 80 00 5d be 2012f08 <fat_buf_release+0x194>
2012d98: 01 00 00 00 nop
{
uint32_t sec_num = fs_info->c.blk_num;
2012d9c: c2 07 60 84 ld [ %i5 + 0x84 ], %g1
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
2012da0: c4 17 60 18 lduh [ %i5 + 0x18 ], %g2
2012da4: 80 a0 40 02 cmp %g1, %g2
2012da8: 0a 80 00 05 bcs 2012dbc <fat_buf_release+0x48>
2012dac: b8 10 20 00 clr %i4
2012db0: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
2012db4: 80 a0 40 02 cmp %g1, %g2
2012db8: b8 40 20 00 addx %g0, 0, %i4
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
2012dbc: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
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)
2012dc0: 80 8f 20 ff btst 0xff, %i4
2012dc4: 02 80 00 12 be 2012e0c <fat_buf_release+0x98>
2012dc8: c6 0f 60 0c ldub [ %i5 + 0xc ], %g3
2012dcc: c8 0f 60 54 ldub [ %i5 + 0x54 ], %g4
2012dd0: 80 a1 20 00 cmp %g4, 0
2012dd4: 12 80 00 0e bne 2012e0c <fat_buf_release+0x98> <== NEVER TAKEN
2012dd8: 84 08 a0 ff and %g2, 0xff, %g2
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
2012ddc: c8 07 60 8c ld [ %i5 + 0x8c ], %g4
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,
2012de0: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
2012de4: d2 01 20 1c ld [ %g4 + 0x1c ], %o1
2012de8: d4 17 40 00 lduh [ %i5 ], %o2
2012dec: 86 08 e0 ff and %g3, 0xff, %g3
2012df0: 86 20 c0 02 sub %g3, %g2, %g3
2012df4: b7 30 40 03 srl %g1, %g3, %i3
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);
2012df8: 87 2e c0 03 sll %i3, %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 -
2012dfc: 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);
2012e00: 85 28 40 02 sll %g1, %g2, %g2
2012e04: 40 00 24 a9 call 201c0a8 <memcpy>
2012e08: 92 02 40 02 add %o1, %g2, %o1
fs_info->c.buf->buffer + blk_ofs,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
2012e0c: 7f ff f8 c4 call 201111c <rtems_bdbuf_release_modified>
2012e10: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if (sc != RTEMS_SUCCESSFUL)
2012e14: 80 a2 20 00 cmp %o0, 0
2012e18: 12 80 00 41 bne 2012f1c <fat_buf_release+0x1a8> <== NEVER TAKEN
2012e1c: 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)
2012e20: 02 80 00 45 be 2012f34 <fat_buf_release+0x1c0>
2012e24: c0 2f 60 88 clrb [ %i5 + 0x88 ]
2012e28: c2 0f 60 54 ldub [ %i5 + 0x54 ], %g1
2012e2c: 80 a0 60 00 cmp %g1, 0
2012e30: 22 80 00 2f be,a 2012eec <fat_buf_release+0x178> <== ALWAYS TAKEN
2012e34: b8 10 20 01 mov 1, %i4
{
sc = rtems_bdbuf_release(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
2012e38: 10 80 00 40 b 2012f38 <fat_buf_release+0x1c4> <== NOT EXECUTED
2012e3c: c0 2f 60 89 clrb [ %i5 + 0x89 ] <== NOT EXECUTED
for (i = 1; i < fs_info->vol.fats; i++)
{
rtems_bdbuf_buffer *bd;
sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
2012e40: 7f ff be 04 call 2002650 <.umul>
2012e44: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
2012e48: f6 07 60 84 ld [ %i5 + 0x84 ], %i3
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);
2012e4c: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
2012e50: 90 02 00 1b add %o0, %i3, %o0
2012e54: f6 0f 60 0c ldub [ %i5 + 0xc ], %i3
2012e58: b6 26 c0 01 sub %i3, %g1, %i3
2012e5c: 93 32 00 1b srl %o0, %i3, %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);
2012e60: b7 2a 40 1b sll %o1, %i3, %i3
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 -
2012e64: b6 22 00 1b sub %o0, %i3, %i3
fat_block_num_to_sector_num (fs_info,
fat_sector_num_to_block_num (fs_info, sector)))
<< fs_info->vol.sec_log2);
2012e68: b7 2e c0 01 sll %i3, %g1, %i3
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
2012e6c: 80 a6 e0 00 cmp %i3, 0
2012e70: 12 80 00 0b bne 2012e9c <fat_buf_release+0x128>
2012e74: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
&& fs_info->vol.bps == fs_info->vol.bytes_per_block)
2012e78: c4 17 40 00 lduh [ %i5 ], %g2
2012e7c: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
2012e80: 80 a0 80 01 cmp %g2, %g1
2012e84: 12 80 00 06 bne 2012e9c <fat_buf_release+0x128>
2012e88: 01 00 00 00 nop
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
2012e8c: 7f ff f7 c2 call 2010d94 <rtems_bdbuf_get>
2012e90: 94 07 bf fc add %fp, -4, %o2
}
else
{
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
}
if ( sc != RTEMS_SUCCESSFUL)
2012e94: 10 80 00 05 b 2012ea8 <fat_buf_release+0x134>
2012e98: 80 a2 20 00 cmp %o0, 0
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
}
else
{
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
2012e9c: 7f ff f7 ef call 2010e58 <rtems_bdbuf_read>
2012ea0: 94 07 bf fc add %fp, -4, %o2
}
if ( sc != RTEMS_SUCCESSFUL)
2012ea4: 80 a2 20 00 cmp %o0, 0
2012ea8: 22 80 00 03 be,a 2012eb4 <fat_buf_release+0x140> <== ALWAYS TAKEN
2012eac: c2 07 bf fc ld [ %fp + -4 ], %g1
2012eb0: 30 80 00 0b b,a 2012edc <fat_buf_release+0x168> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
2012eb4: d2 07 60 90 ld [ %i5 + 0x90 ], %o1
2012eb8: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2012ebc: d4 17 40 00 lduh [ %i5 ], %o2
2012ec0: 40 00 24 7a call 201c0a8 <memcpy>
2012ec4: 90 02 00 1b add %o0, %i3, %o0
sc = rtems_bdbuf_release_modified(bd);
2012ec8: 7f ff f8 95 call 201111c <rtems_bdbuf_release_modified>
2012ecc: d0 07 bf fc ld [ %fp + -4 ], %o0
if ( sc != RTEMS_SUCCESSFUL)
2012ed0: 80 a2 20 00 cmp %o0, 0
2012ed4: 22 80 00 06 be,a 2012eec <fat_buf_release+0x178> <== ALWAYS TAKEN
2012ed8: b8 07 20 01 inc %i4
rtems_set_errno_and_return_minus_one(ENOMEM);
2012edc: 40 00 21 b4 call 201b5ac <__errno> <== NOT EXECUTED
2012ee0: 01 00 00 00 nop <== NOT EXECUTED
2012ee4: 10 80 00 11 b 2012f28 <fat_buf_release+0x1b4> <== NOT EXECUTED
2012ee8: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
uint8_t i;
for (i = 1; i < fs_info->vol.fats; i++)
2012eec: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
2012ef0: 90 0f 20 ff and %i4, 0xff, %o0
2012ef4: 80 a2 00 01 cmp %o0, %g1
2012ef8: 0a bf ff d2 bcs 2012e40 <fat_buf_release+0xcc>
2012efc: 01 00 00 00 nop
{
sc = rtems_bdbuf_release(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
2012f00: 10 80 00 0e b 2012f38 <fat_buf_release+0x1c4>
2012f04: c0 2f 60 89 clrb [ %i5 + 0x89 ]
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
2012f08: 7f ff f8 50 call 2011048 <rtems_bdbuf_release>
2012f0c: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if (sc != RTEMS_SUCCESSFUL)
2012f10: 80 a2 20 00 cmp %o0, 0
2012f14: 22 80 00 09 be,a 2012f38 <fat_buf_release+0x1c4> <== ALWAYS TAKEN
2012f18: c0 2f 60 89 clrb [ %i5 + 0x89 ]
rtems_set_errno_and_return_minus_one(EIO);
2012f1c: 40 00 21 a4 call 201b5ac <__errno> <== NOT EXECUTED
2012f20: 01 00 00 00 nop <== NOT EXECUTED
2012f24: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2012f28: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2012f2c: 81 c7 e0 08 ret <== NOT EXECUTED
2012f30: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
fs_info->c.state = FAT_CACHE_EMPTY;
2012f34: c0 2f 60 89 clrb [ %i5 + 0x89 ]
return RC_OK;
2012f38: b0 10 20 00 clr %i0
}
2012f3c: 81 c7 e0 08 ret
2012f40: 81 e8 00 00 restore
02012d18 <fat_cluster_num_to_block_num>:
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)) )
2012d18: 80 a2 60 00 cmp %o1, 0
2012d1c: 32 80 00 0c bne,a 2012d4c <fat_cluster_num_to_block_num+0x34>
2012d20: c2 0a 20 0c ldub [ %o0 + 0xc ], %g1
2012d24: c2 0a 20 0e ldub [ %o0 + 0xe ], %g1
2012d28: 80 88 60 03 btst 3, %g1
2012d2c: 22 80 00 08 be,a 2012d4c <fat_cluster_num_to_block_num+0x34><== NEVER TAKEN
2012d30: c2 0a 20 0c ldub [ %o0 + 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);
2012d34: c4 0a 20 0c ldub [ %o0 + 0xc ], %g2
2012d38: c2 0a 20 02 ldub [ %o0 + 2 ], %g1
2012d3c: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
2012d40: 82 20 80 01 sub %g2, %g1, %g1
2012d44: 81 c3 e0 08 retl
2012d48: 91 32 00 01 srl %o0, %g1, %o0
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);
2012d4c: c4 0a 20 08 ldub [ %o0 + 8 ], %g2
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;
2012d50: 92 02 7f fe add %o1, -2, %o1
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
2012d54: 84 20 80 01 sub %g2, %g1, %g2
2012d58: 93 2a 40 02 sll %o1, %g2, %o1
2012d5c: c4 0a 20 02 ldub [ %o0 + 2 ], %g2
2012d60: d0 02 20 34 ld [ %o0 + 0x34 ], %o0
2012d64: 82 20 40 02 sub %g1, %g2, %g1
2012d68: 91 32 00 01 srl %o0, %g1, %o0
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
}
return blk;
}
2012d6c: 81 c3 e0 08 retl
2012d70: 90 02 00 09 add %o0, %o1, %o0
02012074 <fat_cluster_num_to_sector_num>:
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2012074: 80 a2 60 00 cmp %o1, 0
2012078: 32 80 00 08 bne,a 2012098 <fat_cluster_num_to_sector_num+0x24>
201207c: c2 0a 20 05 ldub [ %o0 + 5 ], %g1
2012080: c2 0a 20 0e ldub [ %o0 + 0xe ], %g1
2012084: 80 88 60 03 btst 3, %g1
2012088: 22 80 00 04 be,a 2012098 <fat_cluster_num_to_sector_num+0x24><== NEVER TAKEN
201208c: c2 0a 20 05 ldub [ %o0 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2012090: 81 c3 e0 08 retl
2012094: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2012098: 92 02 7f fe add %o1, -2, %o1
201209c: 93 2a 40 01 sll %o1, %g1, %o1
20120a0: c2 02 20 34 ld [ %o0 + 0x34 ], %g1
fs_info->vol.data_fsec);
}
20120a4: 81 c3 e0 08 retl
20120a8: 90 02 40 01 add %o1, %g1, %o0
02013118 <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)
{
2013118: 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));
201311c: c2 16 20 06 lduh [ %i0 + 6 ], %g1
2013120: 82 20 40 1a sub %g1, %i2, %g1
2013124: 80 a6 c0 01 cmp %i3, %g1
2013128: 38 80 00 02 bgu,a 2013130 <fat_cluster_set+0x18> <== NEVER TAKEN
201312c: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
2013130: 90 10 00 18 mov %i0, %o0
2013134: 7f ff fe f9 call 2012d18 <fat_cluster_num_to_block_num>
2013138: 92 10 00 19 mov %i1, %o1
uint32_t blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
201313c: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
ssize_t bytes_written = 0;
2013140: a0 10 20 00 clr %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;
2013144: a3 36 80 01 srl %i2, %g1, %l1
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
2013148: 83 2c 40 01 sll %l1, %g1, %g1
201314c: a4 10 20 01 mov 1, %l2
2013150: b4 26 80 01 sub %i2, %g1, %i2
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
2013154: a2 02 00 11 add %o0, %l1, %l1
while ( (RC_OK == rc)
2013158: 10 80 00 2a b 2013200 <fat_cluster_set+0xe8>
201315c: 82 10 20 00 clr %g1
&& (0 < bytes_to_write))
{
uint32_t c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
2013160: 82 20 80 1a sub %g2, %i2, %g1
2013164: 80 a0 40 1b cmp %g1, %i3
2013168: 08 80 00 03 bleu 2013174 <fat_cluster_set+0x5c> <== ALWAYS TAKEN
201316c: ba 10 00 01 mov %g1, %i5
2013170: 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));
2013174: 80 a7 40 01 cmp %i5, %g1
2013178: 08 80 00 03 bleu 2013184 <fat_cluster_set+0x6c> <== ALWAYS TAKEN
201317c: b2 10 00 1d mov %i5, %i1
2013180: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
2013184: 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)
2013188: 80 a6 60 00 cmp %i1, 0
201318c: 02 80 00 27 be 2013228 <fat_cluster_set+0x110> <== NEVER TAKEN
2013190: 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);
2013194: 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);
2013198: 90 10 00 18 mov %i0, %o0
201319c: 93 2c 40 09 sll %l1, %o1, %o1
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)
20131a0: 80 a6 40 02 cmp %i1, %g2
20131a4: 02 80 00 03 be 20131b0 <fat_cluster_set+0x98>
20131a8: 94 10 20 02 mov 2, %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);
20131ac: 94 10 20 01 mov 1, %o2
20131b0: 7f ff ff 65 call 2012f44 <fat_buf_access>
20131b4: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
20131b8: 80 a2 20 00 cmp %o0, 0
20131bc: 12 80 00 0a bne 20131e4 <fat_cluster_set+0xcc> <== NEVER TAKEN
20131c0: 80 a7 40 08 cmp %i5, %o0
{
memset(blk_buf + offset, pattern, bytes_to_write);
20131c4: d0 07 bf fc ld [ %fp + -4 ], %o0
20131c8: 92 10 00 1c mov %i4, %o1
20131cc: 90 02 00 1a add %o0, %i2, %o0
20131d0: 40 00 23 f3 call 201c19c <memset>
20131d4: 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;
20131d8: 10 80 00 14 b 2013228 <fat_cluster_set+0x110>
20131dc: e4 2e 20 88 stb %l2, [ %i0 + 0x88 ]
fs_info,
cur_blk,
ofs_blk,
c,
pattern);
if (c != ret)
20131e0: 80 a7 40 08 cmp %i5, %o0
20131e4: 12 80 00 06 bne 20131fc <fat_cluster_set+0xe4> <== NEVER TAKEN
20131e8: 82 10 3f ff mov -1, %g1
rc = -1;
else
{
bytes_to_write -= ret;
20131ec: b6 26 c0 1d sub %i3, %i5, %i3
bytes_written += ret;
20131f0: a0 04 00 1d add %l0, %i5, %l0
++cur_blk;
20131f4: a2 04 60 01 inc %l1
20131f8: 82 10 20 00 clr %g1
20131fc: b4 10 20 00 clr %i2
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
2013200: 80 a6 e0 00 cmp %i3, 0
2013204: 02 80 00 04 be 2013214 <fat_cluster_set+0xfc>
2013208: 80 a0 60 00 cmp %g1, 0
201320c: 22 bf ff d5 be,a 2013160 <fat_cluster_set+0x48> <== ALWAYS TAKEN
2013210: c4 16 20 0a lduh [ %i0 + 0xa ], %g2
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
2013214: 80 a0 60 00 cmp %g1, 0
2013218: 12 80 00 06 bne 2013230 <fat_cluster_set+0x118> <== NEVER TAKEN
201321c: b0 10 3f ff mov -1, %i0
2013220: 81 c7 e0 08 ret
2013224: 91 e8 00 10 restore %g0, %l0, %o0
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
2013228: 10 bf ff ee b 20131e0 <fat_cluster_set+0xc8>
201322c: 90 10 00 19 mov %i1, %o0
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
2013230: 81 c7 e0 08 ret <== NOT EXECUTED
2013234: 81 e8 00 00 restore <== NOT EXECUTED
02013238 <fat_cluster_write>:
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const void *buff,
const bool overwrite_cluster)
{
2013238: 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));
201323c: c2 16 20 06 lduh [ %i0 + 6 ], %g1
2013240: 82 20 40 1a sub %g1, %i2, %g1
2013244: 80 a6 c0 01 cmp %i3, %g1
2013248: 38 80 00 02 bgu,a 2013250 <fat_cluster_write+0x18> <== NEVER TAKEN
201324c: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
2013250: 90 10 00 18 mov %i0, %o0
2013254: 7f ff fe b1 call 2012d18 <fat_cluster_num_to_block_num>
2013258: 92 10 00 19 mov %i1, %o1
uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
201325c: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
ssize_t bytes_written = 0;
2013260: a2 10 20 00 clr %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);
2013264: a5 36 80 01 srl %i2, %g1, %l2
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
2013268: 83 2c 80 01 sll %l2, %g1, %g1
201326c: a6 10 20 01 mov 1, %l3
2013270: 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;
2013274: a4 02 00 12 add %o0, %l2, %l2
while ( (RC_OK == rc)
2013278: 10 80 00 2d b 201332c <fat_cluster_write+0xf4>
201327c: 82 10 20 00 clr %g1
&& (0 < bytes_to_write))
{
c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
2013280: 82 20 80 1a sub %g2, %i2, %g1
2013284: 80 a0 40 1b cmp %g1, %i3
2013288: 08 80 00 03 bleu 2013294 <fat_cluster_write+0x5c>
201328c: b2 10 00 01 mov %g1, %i1
2013290: 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));
2013294: 80 a6 40 01 cmp %i1, %g1
2013298: 08 80 00 03 bleu 20132a4 <fat_cluster_write+0x6c> <== ALWAYS TAKEN
201329c: a0 10 00 19 mov %i1, %l0
20132a0: a0 10 00 01 mov %g1, %l0 <== NOT EXECUTED
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
20132a4: 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)
20132a8: 80 a4 20 00 cmp %l0, 0
20132ac: 02 80 00 2a be 2013354 <fat_cluster_write+0x11c> <== NEVER TAKEN
20132b0: 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);
20132b4: 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);
20132b8: 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
20132bc: 80 a7 60 00 cmp %i5, 0
20132c0: 12 80 00 05 bne 20132d4 <fat_cluster_write+0x9c>
20132c4: 93 2c 80 09 sll %l2, %o1, %o1
|| (bytes_to_write == fs_info->vol.bytes_per_block))
20132c8: 80 a4 00 02 cmp %l0, %g2
20132cc: 12 80 00 04 bne 20132dc <fat_cluster_write+0xa4>
20132d0: 94 10 20 01 mov 1, %o2
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
20132d4: 10 80 00 02 b 20132dc <fat_cluster_write+0xa4>
20132d8: 94 10 20 02 mov 2, %o2
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
20132dc: 7f ff ff 1a call 2012f44 <fat_buf_access>
20132e0: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
20132e4: 80 a2 20 00 cmp %o0, 0
20132e8: 12 80 00 0a bne 2013310 <fat_cluster_write+0xd8> <== NEVER TAKEN
20132ec: 80 a6 40 08 cmp %i1, %o0
{
memcpy(blk_buf + offset, buf, bytes_to_write);
20132f0: d0 07 bf fc ld [ %fp + -4 ], %o0
20132f4: 92 07 00 11 add %i4, %l1, %o1
20132f8: 90 02 00 1a add %o0, %i2, %o0
20132fc: 40 00 23 6b call 201c0a8 <memcpy>
2013300: 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;
2013304: 10 80 00 14 b 2013354 <fat_cluster_write+0x11c>
2013308: e6 2e 20 88 stb %l3, [ %i0 + 0x88 ]
cur_blk,
ofs_blk,
c,
&buffer[bytes_written],
overwrite_cluster);
if (c != ret)
201330c: 80 a6 40 08 cmp %i1, %o0
2013310: 12 80 00 06 bne 2013328 <fat_cluster_write+0xf0> <== NEVER TAKEN
2013314: 82 10 3f ff mov -1, %g1
rc = -1;
else
{
bytes_to_write -= ret;
2013318: b6 26 c0 19 sub %i3, %i1, %i3
bytes_written += ret;
201331c: a2 04 40 19 add %l1, %i1, %l1
++cur_blk;
2013320: a4 04 a0 01 inc %l2
2013324: 82 10 20 00 clr %g1
2013328: b4 10 20 00 clr %i2
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
201332c: 80 a6 e0 00 cmp %i3, 0
2013330: 02 80 00 04 be 2013340 <fat_cluster_write+0x108>
2013334: 80 a0 60 00 cmp %g1, 0
2013338: 22 bf ff d2 be,a 2013280 <fat_cluster_write+0x48> <== ALWAYS TAKEN
201333c: c4 16 20 0a lduh [ %i0 + 0xa ], %g2
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
2013340: 80 a0 60 00 cmp %g1, 0
2013344: 12 80 00 06 bne 201335c <fat_cluster_write+0x124> <== NEVER TAKEN
2013348: b0 10 3f ff mov -1, %i0
201334c: 81 c7 e0 08 ret
2013350: 91 e8 00 11 restore %g0, %l1, %o0
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
2013354: 10 bf ff ee b 201330c <fat_cluster_write+0xd4>
2013358: 90 10 00 10 mov %l0, %o0
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
201335c: 81 c7 e0 08 ret <== NOT EXECUTED
2013360: 81 e8 00 00 restore <== NOT EXECUTED
020125e0 <fat_file_close>:
int
fat_file_close(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
20125e0: 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)
20125e4: c2 06 60 08 ld [ %i1 + 8 ], %g1
20125e8: 80 a0 60 01 cmp %g1, 1
20125ec: 08 80 00 05 bleu 2012600 <fat_file_close+0x20>
20125f0: 82 00 7f ff add %g1, -1, %g1
{
fat_fd->links_num--;
return rc;
20125f4: 90 10 20 00 clr %o0
20125f8: 10 80 00 25 b 201268c <fat_file_close+0xac>
20125fc: c2 26 60 08 st %g1, [ %i1 + 8 ]
}
key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
2012600: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
2012604: 80 88 60 01 btst 1, %g1
2012608: 02 80 00 14 be 2012658 <fat_file_close+0x78>
201260c: 90 10 00 18 mov %i0, %o0
{
rc = fat_file_truncate(fs_info, fat_fd, 0);
2012610: 92 10 00 19 mov %i1, %o1
2012614: 7f ff ff ae call 20124cc <fat_file_truncate>
2012618: 94 10 20 00 clr %o2
if ( rc != RC_OK )
201261c: 80 a2 20 00 cmp %o0, 0
2012620: 12 80 00 1b bne 201268c <fat_file_close+0xac> <== NEVER TAKEN
2012624: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2012628: 40 00 0e ac call 20160d8 <_Chain_Extract>
201262c: 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) )
2012630: d2 06 60 0c ld [ %i1 + 0xc ], %o1
2012634: 40 00 06 01 call 2013e38 <fat_ino_is_unique>
2012638: 90 10 00 18 mov %i0, %o0
201263c: 80 8a 20 ff btst 0xff, %o0
2012640: 02 80 00 0f be 201267c <fat_file_close+0x9c> <== ALWAYS TAKEN
2012644: 01 00 00 00 nop
fat_free_unique_ino(fs_info, fat_fd->ino);
2012648: d2 06 60 0c ld [ %i1 + 0xc ], %o1 <== NOT EXECUTED
201264c: 40 00 05 f0 call 2013e0c <fat_free_unique_ino> <== NOT EXECUTED
2012650: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2012654: 30 80 00 0a b,a 201267c <fat_file_close+0x9c> <== NOT EXECUTED
free(fat_fd);
}
else
{
if (fat_ino_is_unique(fs_info, fat_fd->ino))
2012658: 40 00 05 f8 call 2013e38 <fat_ino_is_unique>
201265c: d2 06 60 0c ld [ %i1 + 0xc ], %o1
2012660: 80 8a 20 ff btst 0xff, %o0
2012664: 02 80 00 04 be 2012674 <fat_file_close+0x94> <== ALWAYS TAKEN
2012668: 01 00 00 00 nop
{
fat_fd->links_num = 0;
201266c: 10 80 00 06 b 2012684 <fat_file_close+0xa4> <== NOT EXECUTED
2012670: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
2012674: 40 00 0e 99 call 20160d8 <_Chain_Extract>
2012678: 90 10 00 19 mov %i1, %o0
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
201267c: 7f ff cb 36 call 2005354 <free>
2012680: 90 10 00 19 mov %i1, %o0
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
2012684: 40 00 01 bc call 2012d74 <fat_buf_release>
2012688: 81 e8 00 00 restore
return rc;
}
201268c: 81 c7 e0 08 ret
2012690: 91 e8 00 08 restore %g0, %o0, %o0
02012764 <fat_file_extend>:
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
2012764: 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;
2012768: f6 27 00 00 st %i3, [ %i4 ]
if (new_length <= fat_fd->fat_file_size)
201276c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t new_length,
uint32_t *a_length
)
{
int rc = RC_OK;
uint32_t chain = 0;
2012770: 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;
2012774: 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)
2012778: 80 a6 c0 01 cmp %i3, %g1
201277c: 18 80 00 04 bgu 201278c <fat_file_extend+0x28>
2012780: ba 10 00 18 mov %i0, %i5
return RC_OK;
2012784: 81 c7 e0 08 ret
2012788: 91 e8 20 00 restore %g0, 0, %o0
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
201278c: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
2012790: 80 a0 a0 01 cmp %g2, 1
2012794: 32 80 00 0b bne,a 20127c0 <fat_file_extend+0x5c>
2012798: e0 17 60 06 lduh [ %i5 + 6 ], %l0
201279c: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
20127a0: 80 a0 a0 00 cmp %g2, 0
20127a4: 32 80 00 07 bne,a 20127c0 <fat_file_extend+0x5c> <== NEVER TAKEN
20127a8: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
20127ac: 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)) &&
20127b0: 80 88 a0 03 btst 3, %g2
20127b4: 22 80 00 03 be,a 20127c0 <fat_file_extend+0x5c> <== NEVER TAKEN
20127b8: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
20127bc: 30 80 00 34 b,a 201288c <fat_file_extend+0x128>
(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))) &
20127c0: 84 04 3f ff add %l0, -1, %g2
20127c4: 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 -
20127c8: a0 24 00 12 sub %l0, %l2, %l0
20127cc: 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;
20127d0: 84 26 c0 01 sub %i3, %g1, %g2
if (bytes2add > bytes_remain)
20127d4: 80 a0 80 10 cmp %g2, %l0
20127d8: 08 80 00 03 bleu 20127e4 <fat_file_extend+0x80>
20127dc: a2 10 20 00 clr %l1
bytes2add -= bytes_remain;
20127e0: a2 20 80 10 sub %g2, %l0, %l1
else
bytes2add = 0;
if (zero_fill && bytes_remain > 0) {
20127e4: 80 a4 20 00 cmp %l0, 0
20127e8: 02 80 00 17 be 2012844 <fat_file_extend+0xe0>
20127ec: 80 a4 60 00 cmp %l1, 0
20127f0: 80 a6 a0 00 cmp %i2, 0
20127f4: 02 80 00 14 be 2012844 <fat_file_extend+0xe0>
20127f8: 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;
20127fc: 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);
2012800: 90 10 00 1d mov %i5, %o0
2012804: 92 10 00 19 mov %i1, %o1
2012808: 95 30 40 0a srl %g1, %o2, %o2
201280c: 7f ff fe 39 call 20120f0 <fat_file_lseek>
2012810: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2012814: b0 92 60 00 orcc %o1, 0, %i0
2012818: 12 80 00 21 bne 201289c <fat_file_extend+0x138> <== NEVER TAKEN
201281c: d2 07 bf fc ld [ %fp + -4 ], %o1
return rc;
bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
2012820: 90 10 00 1d mov %i5, %o0
2012824: 94 10 00 12 mov %l2, %o2
2012828: 96 10 00 10 mov %l0, %o3
201282c: 98 10 20 00 clr %o4
2012830: 40 00 02 3a call 2013118 <fat_cluster_set>
2012834: b0 10 3f ff mov -1, %i0
if (bytes_remain != bytes_written)
2012838: 80 a4 00 08 cmp %l0, %o0
201283c: 12 80 00 18 bne 201289c <fat_file_extend+0x138> <== NEVER TAKEN
2012840: 80 a4 60 00 cmp %l1, 0
/*
* if in last cluster allocated for the file there is enough room to
* handle extention (hence we don't need to add even one cluster to the
* file ) - return
*/
if (bytes2add == 0)
2012844: 02 bf ff d0 be 2012784 <fat_file_extend+0x20>
2012848: a4 04 7f ff add %l1, -1, %l2
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
201284c: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
2012850: 90 10 00 1d mov %i5, %o0
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
2012854: a5 34 80 01 srl %l2, %g1, %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
2012858: 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;
201285c: a4 04 a0 01 inc %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
2012860: 96 07 bf fc add %fp, -4, %o3
2012864: 94 10 00 12 mov %l2, %o2
2012868: 98 07 bf f8 add %fp, -8, %o4
201286c: 40 00 1c 82 call 2019a74 <fat_scan_fat_for_free_clusters>
2012870: 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)
2012874: b0 92 20 00 orcc %o0, 0, %i0
2012878: 12 80 00 09 bne 201289c <fat_file_extend+0x138> <== NEVER TAKEN
201287c: 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))
2012880: 80 94 00 01 orcc %l0, %g1, %g0
2012884: 12 80 00 08 bne 20128a4 <fat_file_extend+0x140> <== ALWAYS TAKEN
2012888: 80 a4 80 01 cmp %l2, %g1
rtems_set_errno_and_return_minus_one(ENOSPC);
201288c: 40 00 23 48 call 201b5ac <__errno>
2012890: b0 10 3f ff mov -1, %i0
2012894: 82 10 20 1c mov 0x1c, %g1
2012898: c2 22 00 00 st %g1, [ %o0 ]
201289c: 81 c7 e0 08 ret
20128a0: 81 e8 00 00 restore
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
20128a4: 02 80 00 09 be 20128c8 <fat_file_extend+0x164> <== ALWAYS TAKEN
20128a8: 82 24 80 01 sub %l2, %g1, %g1
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
20128ac: c4 17 60 06 lduh [ %i5 + 6 ], %g2 <== NOT EXECUTED
20128b0: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
20128b4: a2 0c 40 02 and %l1, %g2, %l1 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
20128b8: 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);
20128bc: b6 26 c0 11 sub %i3, %l1, %i3 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
20128c0: 83 28 40 02 sll %g1, %g2, %g1 <== NOT EXECUTED
20128c4: b6 26 c0 01 sub %i3, %g1, %i3 <== NOT EXECUTED
}
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
20128c8: d6 06 60 18 ld [ %i1 + 0x18 ], %o3
20128cc: 80 a2 e0 00 cmp %o3, 0
20128d0: 32 80 00 07 bne,a 20128ec <fat_file_extend+0x188>
20128d4: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
20128d8: c2 07 bf f0 ld [ %fp + -16 ], %g1
fat_fd->map.file_cln = 0;
20128dc: 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;
20128e0: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
20128e4: 10 80 00 1d b 2012958 <fat_file_extend+0x1f4>
20128e8: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
20128ec: 80 a0 7f ff cmp %g1, -1
20128f0: 22 80 00 04 be,a 2012900 <fat_file_extend+0x19c> <== NEVER TAKEN
20128f4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
20128f8: 10 80 00 0c b 2012928 <fat_file_extend+0x1c4>
20128fc: c2 27 bf f4 st %g1, [ %fp + -12 ]
}
else
{
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
2012900: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2012904: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2012908: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
201290c: 7f ff ff 62 call 2012694 <fat_file_ioctl> <== NOT EXECUTED
2012910: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
2012914: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
2012918: 02 80 00 05 be 201292c <fat_file_extend+0x1c8> <== NOT EXECUTED
201291c: d2 07 bf f4 ld [ %fp + -12 ], %o1 <== NOT EXECUTED
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(fs_info, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(fs_info, chain);
2012920: 10 80 00 1f b 201299c <fat_file_extend+0x238> <== NOT EXECUTED
2012924: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
}
rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
2012928: d2 07 bf f4 ld [ %fp + -12 ], %o1
201292c: d4 07 bf f0 ld [ %fp + -16 ], %o2
2012930: 40 00 1b 81 call 2019734 <fat_set_fat_cluster>
2012934: 90 10 00 1d mov %i5, %o0
2012938: b4 10 00 08 mov %o0, %i2
if ( rc != RC_OK )
201293c: 80 a6 a0 00 cmp %i2, 0
2012940: 02 80 00 04 be 2012950 <fat_file_extend+0x1ec> <== ALWAYS TAKEN
2012944: 90 10 00 1d mov %i5, %o0
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(fs_info, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(fs_info, chain);
2012948: 10 80 00 16 b 20129a0 <fat_file_extend+0x23c> <== NOT EXECUTED
201294c: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
fat_buf_release(fs_info);
2012950: 40 00 01 09 call 2012d74 <fat_buf_release>
2012954: 01 00 00 00 nop
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
2012958: c2 07 bf fc ld [ %fp + -4 ], %g1
201295c: 80 a0 60 00 cmp %g1, 0
2012960: 22 80 00 14 be,a 20129b0 <fat_file_extend+0x24c> <== NEVER TAKEN
2012964: f6 27 00 00 st %i3, [ %i4 ] <== NOT EXECUTED
{
fat_fd->map.last_cln = last_cl;
2012968: c2 07 bf f8 ld [ %fp + -8 ], %g1
201296c: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
if (fat_fd->fat_file_type == FAT_DIRECTORY)
2012970: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
2012974: 80 a0 60 00 cmp %g1, 0
2012978: 32 80 00 0e bne,a 20129b0 <fat_file_extend+0x24c>
201297c: f6 27 00 00 st %i3, [ %i4 ]
{
rc = fat_init_clusters_chain(fs_info, chain);
2012980: d2 07 bf f0 ld [ %fp + -16 ], %o1
2012984: 40 00 04 d4 call 2013cd4 <fat_init_clusters_chain>
2012988: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
201298c: b4 92 20 00 orcc %o0, 0, %i2
2012990: 22 80 00 08 be,a 20129b0 <fat_file_extend+0x24c> <== ALWAYS TAKEN
2012994: f6 27 00 00 st %i3, [ %i4 ]
{
fat_free_fat_clusters_chain(fs_info, chain);
2012998: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201299c: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
20129a0: 40 00 1c 06 call 20199b8 <fat_free_fat_clusters_chain> <== NOT EXECUTED
20129a4: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
20129a8: 81 c7 e0 08 ret <== NOT EXECUTED
20129ac: 81 e8 00 00 restore <== NOT EXECUTED
}
}
}
*a_length = new_length;
fat_fd->fat_file_size = new_length;
20129b0: f6 26 60 18 st %i3, [ %i1 + 0x18 ]
return RC_OK;
}
20129b4: 81 c7 e0 08 ret
20129b8: 81 e8 00 00 restore
02012694 <fat_file_ioctl>:
fat_file_ioctl(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
2012694: 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);
2012698: 82 07 a0 50 add %fp, 0x50, %g1
201269c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
20126a0: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
20126a4: 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;
20126a8: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
20126ac: 80 a6 a0 01 cmp %i2, 1
20126b0: 12 80 00 26 bne 2012748 <fat_file_ioctl+0xb4> <== NEVER TAKEN
20126b4: c2 27 bf fc st %g1, [ %fp + -4 ]
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
20126b8: 82 07 a0 58 add %fp, 0x58, %g1
20126bc: c2 27 bf fc st %g1, [ %fp + -4 ]
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
20126c0: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
20126c4: 80 a6 c0 01 cmp %i3, %g1
20126c8: 0a 80 00 06 bcs 20126e0 <fat_file_ioctl+0x4c> <== ALWAYS TAKEN
20126cc: ba 10 00 1c mov %i4, %i5
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
20126d0: 40 00 23 b7 call 201b5ac <__errno> <== NOT EXECUTED
20126d4: 01 00 00 00 nop <== NOT EXECUTED
20126d8: 10 80 00 1f b 2012754 <fat_file_ioctl+0xc0> <== NOT EXECUTED
20126dc: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
20126e0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20126e4: 80 a0 60 01 cmp %g1, 1
20126e8: 32 80 00 0d bne,a 201271c <fat_file_ioctl+0x88>
20126ec: d4 0e 20 08 ldub [ %i0 + 8 ], %o2
20126f0: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
20126f4: 80 a0 60 00 cmp %g1, 0
20126f8: 32 80 00 09 bne,a 201271c <fat_file_ioctl+0x88> <== NEVER TAKEN
20126fc: d4 0e 20 08 ldub [ %i0 + 8 ], %o2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2012700: 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)) &&
2012704: 80 88 60 03 btst 3, %g1
2012708: 22 80 00 05 be,a 201271c <fat_file_ioctl+0x88>
201270c: 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;
2012710: c0 27 00 00 clr [ %i4 ]
rc = RC_OK;
break;
2012714: 81 c7 e0 08 ret
2012718: 91 e8 20 00 restore %g0, 0, %o0
}
cl_start = pos >> fs_info->vol.bpc_log2;
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
201271c: 90 10 00 18 mov %i0, %o0
2012720: 92 10 00 19 mov %i1, %o1
2012724: 95 36 c0 0a srl %i3, %o2, %o2
2012728: 7f ff fe 72 call 20120f0 <fat_file_lseek>
201272c: 96 07 bf f8 add %fp, -8, %o3
if ( rc != RC_OK )
2012730: b0 92 60 00 orcc %o1, 0, %i0
2012734: 12 80 00 03 bne 2012740 <fat_file_ioctl+0xac> <== NEVER TAKEN
2012738: c2 07 bf f8 ld [ %fp + -8 ], %g1
break;
*ret = cur_cln;
201273c: c2 27 40 00 st %g1, [ %i5 ]
break;
2012740: 81 c7 e0 08 ret
2012744: 81 e8 00 00 restore
default:
errno = EINVAL;
2012748: 40 00 23 99 call 201b5ac <__errno> <== NOT EXECUTED
201274c: 01 00 00 00 nop <== NOT EXECUTED
2012750: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2012754: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = -1;
2012758: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
break;
}
va_end(ap);
return rc;
}
201275c: 81 c7 e0 08 ret <== NOT EXECUTED
2012760: 81 e8 00 00 restore <== NOT EXECUTED
020120f0 <fat_file_lseek>:
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
20120f0: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
20120f4: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
20120f8: 80 a6 80 01 cmp %i2, %g1
20120fc: 12 80 00 05 bne 2012110 <fat_file_lseek+0x20>
2012100: 01 00 00 00 nop
*disk_cln = fat_fd->map.disk_cln;
2012104: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
2012108: 10 80 00 1b b 2012174 <fat_file_lseek+0x84>
201210c: c2 26 c0 00 st %g1, [ %i3 ]
{
uint32_t cur_cln;
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
2012110: 28 80 00 06 bleu,a 2012128 <fat_file_lseek+0x38>
2012114: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
cur_cln = fat_fd->map.disk_cln;
2012118: c4 06 60 38 ld [ %i1 + 0x38 ], %g2
count = file_cln - fat_fd->map.file_cln;
201211c: b8 26 80 01 sub %i2, %g1, %i4
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
2012120: 10 80 00 04 b 2012130 <fat_file_lseek+0x40>
2012124: c4 27 bf fc st %g2, [ %fp + -4 ]
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
2012128: b8 10 00 1a mov %i2, %i4
201212c: c2 27 bf fc st %g1, [ %fp + -4 ]
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
2012130: 10 80 00 0b b 201215c <fat_file_lseek+0x6c>
2012134: ba 10 20 00 clr %i5
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2012138: 90 10 00 18 mov %i0, %o0
201213c: 40 00 1d 0c call 201956c <fat_get_fat_cluster>
2012140: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2012144: 80 a2 20 00 cmp %o0, 0
2012148: 22 80 00 05 be,a 201215c <fat_file_lseek+0x6c> <== ALWAYS TAKEN
201214c: ba 07 60 01 inc %i5
return rc;
2012150: 86 10 00 08 mov %o0, %g3 <== NOT EXECUTED
2012154: 10 80 00 0a b 201217c <fat_file_lseek+0x8c> <== NOT EXECUTED
2012158: 85 3a 20 1f sra %o0, 0x1f, %g2 <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
201215c: 80 a7 40 1c cmp %i5, %i4
2012160: 12 bf ff f6 bne 2012138 <fat_file_lseek+0x48>
2012164: d2 07 bf fc ld [ %fp + -4 ], %o1
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
2012168: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = cur_cln;
201216c: d2 26 60 38 st %o1, [ %i1 + 0x38 ]
*disk_cln = cur_cln;
2012170: d2 26 c0 00 st %o1, [ %i3 ]
}
return RC_OK;
2012174: 84 10 20 00 clr %g2
2012178: 86 10 20 00 clr %g3
}
201217c: b0 10 00 02 mov %g2, %i0
2012180: 81 c7 e0 08 ret
2012184: 93 e8 00 03 restore %g0, %g3, %o1
02012188 <fat_file_open>:
fat_file_open(
fat_fs_info_t *fs_info,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
2012188: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(fs_info, &dir_pos->sname);
201218c: 90 10 00 18 mov %i0, %o0
2012190: 7f ff ff c7 call 20120ac <fat_construct_key>
2012194: 92 10 00 19 mov %i1, %o1
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
2012198: 82 0a 20 01 and %o0, 1, %g1
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
201219c: 85 28 60 02 sll %g1, 2, %g2
20121a0: b7 28 60 04 sll %g1, 4, %i3
20121a4: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
20121a8: b6 26 c0 02 sub %i3, %g2, %i3
int rc = RC_OK;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(fs_info, &dir_pos->sname);
20121ac: b8 10 00 08 mov %o0, %i4
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
20121b0: a0 00 40 1b add %g1, %i3, %l0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
20121b4: fa 00 40 1b ld [ %g1 + %i3 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
20121b8: 10 80 00 0c b 20121e8 <fat_file_open+0x60>
20121bc: a0 04 20 04 add %l0, 4, %l0
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
20121c0: 7f ff ff bb call 20120ac <fat_construct_key>
20121c4: 92 07 60 20 add %i5, 0x20, %o1
if ( (key1) == ck)
20121c8: 80 a7 00 08 cmp %i4, %o0
20121cc: 32 80 00 07 bne,a 20121e8 <fat_file_open+0x60>
20121d0: fa 07 40 00 ld [ %i5 ], %i5
rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
lfat_fd->links_num++;
20121d4: c2 07 60 08 ld [ %i5 + 8 ], %g1
/* access "valid" hash table */
rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
20121d8: fa 26 80 00 st %i5, [ %i2 ]
lfat_fd->links_num++;
20121dc: 82 00 60 01 inc %g1
20121e0: 10 80 00 42 b 20122e8 <fat_file_open+0x160>
20121e4: c2 27 60 08 st %g1, [ %i5 + 8 ]
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
20121e8: 80 a7 40 10 cmp %i5, %l0
20121ec: 12 bf ff f5 bne 20121c0 <fat_file_open+0x38>
20121f0: 90 10 00 18 mov %i0, %o0
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
20121f4: 10 80 00 3f b 20122f0 <fat_file_open+0x168>
20121f8: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
20121fc: 7f ff ff ac call 20120ac <fat_construct_key> <== NOT EXECUTED
2012200: 92 07 60 20 add %i5, 0x20, %o1 <== NOT EXECUTED
if ( (key1) == ck)
2012204: 80 a7 00 08 cmp %i4, %o0 <== NOT EXECUTED
2012208: 32 80 00 0a bne,a 2012230 <fat_file_open+0xa8> <== NOT EXECUTED
201220c: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
2012210: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2012214: 22 80 00 0b be,a 2012240 <fat_file_open+0xb8> <== NOT EXECUTED
2012218: a0 10 20 00 clr %l0 <== NOT EXECUTED
201221c: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
2012220: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2012224: 22 80 00 07 be,a 2012240 <fat_file_open+0xb8> <== NOT EXECUTED
2012228: a0 10 20 00 clr %l0 <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
201222c: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
2012230: 80 a7 40 10 cmp %i5, %l0
2012234: 12 bf ff f2 bne 20121fc <fat_file_open+0x74> <== NEVER TAKEN
2012238: 90 10 00 18 mov %i0, %o0
201223c: a0 10 3f ff mov -1, %l0
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(fs_info, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
2012240: 7f ff cd 8f call 200587c <malloc>
2012244: 90 10 20 44 mov 0x44, %o0
2012248: d0 26 80 00 st %o0, [ %i2 ]
if ( lfat_fd == NULL )
201224c: 80 a2 20 00 cmp %o0, 0
2012250: 02 80 00 1c be 20122c0 <fat_file_open+0x138> <== NEVER TAKEN
2012254: ba 10 00 08 mov %o0, %i5
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
2012258: 92 10 20 00 clr %o1
201225c: 40 00 27 d0 call 201c19c <memset>
2012260: 94 10 20 44 mov 0x44, %o2
lfat_fd->links_num = 1;
2012264: 82 10 20 01 mov 1, %g1
2012268: c2 27 60 08 st %g1, [ %i5 + 8 ]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
201226c: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
2012270: 90 07 60 20 add %i5, 0x20, %o0
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
2012274: 82 08 7f fe and %g1, -2, %g1
2012278: c2 2f 60 30 stb %g1, [ %i5 + 0x30 ]
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
201227c: 82 10 3f ff mov -1, %g1
lfat_fd->dir_pos = *dir_pos;
2012280: 92 10 00 19 mov %i1, %o1
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
2012284: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
lfat_fd->dir_pos = *dir_pos;
2012288: 40 00 27 88 call 201c0a8 <memcpy>
201228c: 94 10 20 10 mov 0x10, %o2
if ( rc != RC_OK )
2012290: 80 a4 20 00 cmp %l0, 0
2012294: 02 80 00 04 be 20122a4 <fat_file_open+0x11c> <== NEVER TAKEN
2012298: 01 00 00 00 nop
lfat_fd->ino = key;
201229c: 10 80 00 0f b 20122d8 <fat_file_open+0x150>
20122a0: f8 27 60 0c st %i4, [ %i5 + 0xc ]
else
{
lfat_fd->ino = fat_get_unique_ino(fs_info);
20122a4: 40 00 06 aa call 2013d4c <fat_get_unique_ino> <== NOT EXECUTED
20122a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
20122ac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20122b0: 12 80 00 0a bne 20122d8 <fat_file_open+0x150> <== NOT EXECUTED
20122b4: d0 27 60 0c st %o0, [ %i5 + 0xc ] <== NOT EXECUTED
{
free((*fat_fd));
20122b8: 7f ff cc 27 call 2005354 <free> <== NOT EXECUTED
20122bc: 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 );
20122c0: 40 00 24 bb call 201b5ac <__errno> <== NOT EXECUTED
20122c4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20122c8: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
20122cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20122d0: 81 c7 e0 08 ret <== NOT EXECUTED
20122d4: 81 e8 00 00 restore <== NOT EXECUTED
*/
static inline void
_hash_insert(rtems_chain_control *hash, uint32_t key1, uint32_t key2,
fat_file_fd_t *el)
{
rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
20122d8: 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 );
20122dc: 92 10 00 1d mov %i5, %o1
20122e0: 7f ff e0 33 call 200a3ac <_Chain_Append>
20122e4: 90 02 00 1b add %o0, %i3, %o0
/*
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
20122e8: 81 c7 e0 08 ret
20122ec: 91 e8 20 00 restore %g0, 0, %o0
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
20122f0: a0 00 40 1b add %g1, %i3, %l0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
20122f4: fa 00 40 1b ld [ %g1 + %i3 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
20122f8: 10 bf ff ce b 2012230 <fat_file_open+0xa8>
20122fc: a0 04 20 04 add %l0, 4, %l0
02012314 <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
2012314: 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;
2012318: c0 27 bf fc clr [ %fp + -4 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
201231c: 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)
2012320: 80 a6 e0 00 cmp %i3, 0
2012324: 02 80 00 68 be 20124c4 <fat_file_read+0x1b0> <== NEVER TAKEN
2012328: 90 10 20 00 clr %o0
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
201232c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
2012330: 80 a6 80 01 cmp %i2, %g1
2012334: 1a 80 00 64 bcc 20124c4 <fat_file_read+0x1b0>
2012338: 80 a6 c0 01 cmp %i3, %g1
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
201233c: 38 80 00 07 bgu,a 2012358 <fat_file_read+0x44> <== NEVER TAKEN
2012340: b6 20 40 1a sub %g1, %i2, %i3 <== NOT EXECUTED
(start > fat_fd->fat_file_size - count))
2012344: 84 20 40 1b sub %g1, %i3, %g2
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
2012348: 80 a6 80 02 cmp %i2, %g2
201234c: 28 80 00 04 bleu,a 201235c <fat_file_read+0x48>
2012350: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
2012354: b6 20 40 1a sub %g1, %i2, %i3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2012358: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
201235c: 80 a0 60 01 cmp %g1, 1
2012360: 32 80 00 1c bne,a 20123d0 <fat_file_read+0xbc>
2012364: e4 0f 60 08 ldub [ %i5 + 8 ], %l2
2012368: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
201236c: 80 a0 60 00 cmp %g1, 0
2012370: 32 80 00 18 bne,a 20123d0 <fat_file_read+0xbc> <== NEVER TAKEN
2012374: e4 0f 60 08 ldub [ %i5 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2012378: 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)) &&
201237c: 80 88 60 03 btst 3, %g1
2012380: 22 80 00 14 be,a 20123d0 <fat_file_read+0xbc>
2012384: 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);
2012388: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
201238c: 7f ff ff 3a call 2012074 <fat_cluster_num_to_sector_num>
2012390: 90 10 00 1d mov %i5, %o0
sec += (start >> fs_info->vol.sec_log2);
2012394: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = start & (fs_info->vol.bps - 1);
2012398: 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);
201239c: 93 36 80 09 srl %i2, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
20123a0: 94 02 bf ff add %o2, -1, %o2
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
20123a4: 92 02 00 09 add %o0, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, count, buf);
20123a8: 94 0e 80 0a and %i2, %o2, %o2
20123ac: 90 10 00 1d mov %i5, %o0
20123b0: 96 10 00 1b mov %i3, %o3
20123b4: 40 00 03 13 call 2013000 <_fat_block_read>
20123b8: 98 10 00 1c mov %i4, %o4
if ( ret < 0 )
20123bc: 80 a2 20 00 cmp %o0, 0
20123c0: 16 80 00 41 bge 20124c4 <fat_file_read+0x1b0> <== ALWAYS TAKEN
20123c4: 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;
20123c8: 10 80 00 3f b 20124c4 <fat_file_read+0x1b0> <== NOT EXECUTED
20123cc: 90 10 3f ff mov -1, %o0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
20123d0: f0 17 60 06 lduh [ %i5 + 6 ], %i0
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
20123d4: 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);
20123d8: a6 07 bf fc add %fp, -4, %l3
20123dc: 90 10 00 1d mov %i5, %o0
20123e0: 92 10 00 19 mov %i1, %o1
20123e4: 94 10 00 12 mov %l2, %o2
20123e8: 7f ff ff 42 call 20120f0 <fat_file_lseek>
20123ec: 96 10 00 13 mov %l3, %o3
if (rc != RC_OK)
20123f0: 90 92 60 00 orcc %o1, 0, %o0
20123f4: 12 80 00 34 bne 20124c4 <fat_file_read+0x1b0> <== NEVER TAKEN
20123f8: a0 10 20 00 clr %l0
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
20123fc: b1 2e 20 10 sll %i0, 0x10, %i0
2012400: b1 36 20 10 srl %i0, 0x10, %i0
2012404: b0 06 3f ff add %i0, -1, %i0
2012408: b4 0e 80 18 and %i2, %i0, %i2
201240c: b0 10 20 00 clr %i0
2012410: 10 80 00 20 b 2012490 <fat_file_read+0x17c>
2012414: a2 10 00 1a mov %i2, %l1
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
2012418: a0 24 00 11 sub %l0, %l1, %l0
201241c: 80 a4 00 1b cmp %l0, %i3
2012420: 38 80 00 02 bgu,a 2012428 <fat_file_read+0x114>
2012424: a0 10 00 1b mov %i3, %l0
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
2012428: d2 07 bf fc ld [ %fp + -4 ], %o1
201242c: 7f ff ff 12 call 2012074 <fat_cluster_num_to_sector_num>
2012430: 90 10 00 1d mov %i5, %o0
sec += (ofs >> fs_info->vol.sec_log2);
2012434: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = ofs & (fs_info->vol.bps - 1);
2012438: d4 17 40 00 lduh [ %i5 ], %o2
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
201243c: 93 34 40 09 srl %l1, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
2012440: 94 02 bf ff add %o2, -1, %o2
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
2012444: 92 02 00 09 add %o0, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
2012448: 94 0c 40 0a and %l1, %o2, %o2
201244c: 90 10 00 1d mov %i5, %o0
2012450: 96 10 00 10 mov %l0, %o3
2012454: 40 00 02 eb call 2013000 <_fat_block_read>
2012458: 98 07 00 18 add %i4, %i0, %o4
if ( ret < 0 )
201245c: 80 a2 20 00 cmp %o0, 0
2012460: 06 80 00 18 bl 20124c0 <fat_file_read+0x1ac> <== NEVER TAKEN
2012464: b6 26 c0 10 sub %i3, %l0, %i3
return -1;
count -= c;
cmpltd += c;
2012468: b0 06 00 10 add %i0, %l0, %i0
save_cln = cur_cln;
201246c: e0 07 bf fc ld [ %fp + -4 ], %l0
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2012470: 90 10 00 1d mov %i5, %o0
2012474: 92 10 00 10 mov %l0, %o1
2012478: 94 10 00 13 mov %l3, %o2
201247c: 40 00 1c 3c call 201956c <fat_get_fat_cluster>
2012480: a2 10 20 00 clr %l1
if ( rc != RC_OK )
2012484: 80 a2 20 00 cmp %o0, 0
2012488: 12 80 00 0f bne 20124c4 <fat_file_read+0x1b0> <== NEVER TAKEN
201248c: 01 00 00 00 nop
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
2012490: 80 a6 e0 00 cmp %i3, 0
2012494: 32 bf ff e1 bne,a 2012418 <fat_file_read+0x104>
2012498: e0 17 60 06 lduh [ %i5 + 6 ], %l0
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
201249c: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
20124a0: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
20124a4: e0 26 60 38 st %l0, [ %i1 + 0x38 ]
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
20124a8: b4 06 80 18 add %i2, %i0, %i2
fat_fd->map.disk_cln = save_cln;
return cmpltd;
20124ac: 90 10 00 18 mov %i0, %o0
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
20124b0: b5 36 80 01 srl %i2, %g1, %i2
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
20124b4: a4 06 80 12 add %i2, %l2, %l2
20124b8: 10 80 00 03 b 20124c4 <fat_file_read+0x1b0>
20124bc: e4 26 60 34 st %l2, [ %i1 + 0x34 ]
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
20124c0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
20124c4: 81 c7 e0 08 ret
20124c8: 91 e8 00 08 restore %g0, %o0, %o0
02012c3c <fat_file_size>:
int
fat_file_size(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
2012c3c: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
2012c40: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
2012c44: c2 27 bf fc st %g1, [ %fp + -4 ]
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2012c48: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2012c4c: 80 a0 60 01 cmp %g1, 1
2012c50: 12 80 00 0d bne 2012c84 <fat_file_size+0x48>
2012c54: ba 10 00 18 mov %i0, %i5
2012c58: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2012c5c: 80 a0 60 00 cmp %g1, 0
2012c60: 32 80 00 0a bne,a 2012c88 <fat_file_size+0x4c> <== NEVER TAKEN
2012c64: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2012c68: 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)) &&
2012c6c: 80 88 60 03 btst 3, %g1
2012c70: 22 80 00 06 be,a 2012c88 <fat_file_size+0x4c> <== ALWAYS TAKEN
2012c74: c0 26 60 18 clr [ %i1 + 0x18 ]
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
2012c78: c2 06 20 2c ld [ %i0 + 0x2c ], %g1 <== NOT EXECUTED
2012c7c: 10 80 00 18 b 2012cdc <fat_file_size+0xa0> <== NOT EXECUTED
2012c80: c2 26 60 18 st %g1, [ %i1 + 0x18 ] <== NOT EXECUTED
return rc;
}
fat_fd->fat_file_size = 0;
2012c84: c0 26 60 18 clr [ %i1 + 0x18 ]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2012c88: 10 80 00 0d b 2012cbc <fat_file_size+0x80>
2012c8c: 82 10 20 00 clr %g1
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2012c90: 92 10 00 1c mov %i4, %o1
2012c94: 40 00 1a 36 call 201956c <fat_get_fat_cluster>
2012c98: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2012c9c: b0 92 20 00 orcc %o0, 0, %i0
2012ca0: 12 80 00 10 bne 2012ce0 <fat_file_size+0xa4> <== NEVER TAKEN
2012ca4: 01 00 00 00 nop
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
2012ca8: c2 17 60 06 lduh [ %i5 + 6 ], %g1
2012cac: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
2012cb0: 82 00 80 01 add %g2, %g1, %g1
2012cb4: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
save_cln = cur_cln;
2012cb8: 82 10 00 1c mov %i4, %g1
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2012cbc: f8 07 bf fc ld [ %fp + -4 ], %i4
2012cc0: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
2012cc4: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
2012cc8: 86 0f 00 03 and %i4, %g3, %g3
2012ccc: 80 a0 c0 02 cmp %g3, %g2
2012cd0: 0a bf ff f0 bcs 2012c90 <fat_file_size+0x54>
2012cd4: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
2012cd8: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
2012cdc: b0 10 20 00 clr %i0
return rc;
}
2012ce0: 81 c7 e0 08 ret
2012ce4: 81 e8 00 00 restore
020124cc <fat_file_truncate>:
fat_file_truncate(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
20124cc: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
20124d0: 82 10 3f ff mov -1, %g1
20124d4: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( new_length >= fat_fd->fat_file_size )
20124d8: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
20124dc: 80 a6 80 01 cmp %i2, %g1
20124e0: 0a 80 00 04 bcs 20124f0 <fat_file_truncate+0x24>
20124e4: c0 27 bf f8 clr [ %fp + -8 ]
return rc;
20124e8: 10 80 00 3b b 20125d4 <fat_file_truncate+0x108>
20124ec: 92 10 20 00 clr %o1
assert(fat_fd->fat_file_size);
20124f0: 80 a0 60 00 cmp %g1, 0
20124f4: 32 80 00 0a bne,a 201251c <fat_file_truncate+0x50> <== ALWAYS TAKEN
20124f8: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
20124fc: 11 00 80 ad sethi %hi(0x202b400), %o0 <== NOT EXECUTED
2012500: 15 00 80 ae sethi %hi(0x202b800), %o2 <== NOT EXECUTED
2012504: 17 00 80 ad sethi %hi(0x202b400), %o3 <== NOT EXECUTED
2012508: 90 12 23 a8 or %o0, 0x3a8, %o0 <== NOT EXECUTED
201250c: 92 10 22 d1 mov 0x2d1, %o1 <== NOT EXECUTED
2012510: 94 12 a0 08 or %o2, 8, %o2 <== NOT EXECUTED
2012514: 40 00 08 82 call 201471c <__assert_func> <== NOT EXECUTED
2012518: 96 12 e3 f0 or %o3, 0x3f0, %o3 <== NOT EXECUTED
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
201251c: c6 16 20 06 lduh [ %i0 + 6 ], %g3
2012520: 86 00 ff ff add %g3, -1, %g3
2012524: b4 00 c0 1a add %g3, %i2, %i2
2012528: b5 36 80 02 srl %i2, %g2, %i2
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
201252c: 85 2e 80 02 sll %i2, %g2, %g2
2012530: 80 a0 80 01 cmp %g2, %g1
2012534: 1a bf ff ed bcc 20124e8 <fat_file_truncate+0x1c>
2012538: 80 a6 a0 00 cmp %i2, 0
return RC_OK;
if (cl_start != 0)
201253c: 12 80 00 0b bne 2012568 <fat_file_truncate+0x9c>
2012540: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
return rc;
}
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
2012544: 92 10 00 19 mov %i1, %o1
2012548: 94 10 00 1a mov %i2, %o2
201254c: 7f ff fe e9 call 20120f0 <fat_file_lseek>
2012550: 96 07 bf f8 add %fp, -8, %o3
if (rc != RC_OK)
2012554: 80 a2 60 00 cmp %o1, 0
2012558: 32 80 00 20 bne,a 20125d8 <fat_file_truncate+0x10c> <== NEVER TAKEN
201255c: b0 10 00 09 mov %o1, %i0 <== NOT EXECUTED
return rc;
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
2012560: 10 80 00 0b b 201258c <fat_file_truncate+0xc0>
2012564: d2 07 bf f8 ld [ %fp + -8 ], %o1
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
return RC_OK;
if (cl_start != 0)
{
rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
2012568: 92 10 00 19 mov %i1, %o1
201256c: 94 06 bf ff add %i2, -1, %o2
2012570: 7f ff fe e0 call 20120f0 <fat_file_lseek>
2012574: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2012578: 80 a2 60 00 cmp %o1, 0
201257c: 02 bf ff f2 be 2012544 <fat_file_truncate+0x78> <== ALWAYS TAKEN
2012580: 90 10 00 18 mov %i0, %o0
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
}
return RC_OK;
}
2012584: 81 c7 e0 08 ret <== NOT EXECUTED
2012588: 91 e8 00 09 restore %g0, %o1, %o0 <== NOT EXECUTED
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
201258c: 40 00 1d 0b call 20199b8 <fat_free_fat_clusters_chain>
2012590: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
2012594: 92 92 20 00 orcc %o0, 0, %o1
2012598: 12 80 00 0f bne 20125d4 <fat_file_truncate+0x108> <== NEVER TAKEN
201259c: 80 a6 a0 00 cmp %i2, 0
return rc;
if (cl_start != 0)
20125a0: 02 80 00 0d be 20125d4 <fat_file_truncate+0x108>
20125a4: 92 10 20 00 clr %o1
{
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
20125a8: d2 07 bf fc ld [ %fp + -4 ], %o1
20125ac: 90 10 00 18 mov %i0, %o0
20125b0: 40 00 1c 61 call 2019734 <fat_set_fat_cluster>
20125b4: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
20125b8: 92 92 20 00 orcc %o0, 0, %o1
20125bc: 12 80 00 06 bne 20125d4 <fat_file_truncate+0x108> <== NEVER TAKEN
20125c0: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
fat_fd->map.file_cln = cl_start - 1;
20125c4: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = new_last_cln;
20125c8: 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;
20125cc: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
20125d0: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
}
return RC_OK;
}
20125d4: b0 10 00 09 mov %o1, %i0
20125d8: 81 c7 e0 08 ret
20125dc: 81 e8 00 00 restore
020129bc <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
20129bc: 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;
20129c0: c0 27 bf f8 clr [ %fp + -8 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
20129c4: 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;
20129c8: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t file_cln_initial = fat_fd->map.file_cln;
20129cc: e6 06 60 34 ld [ %i1 + 0x34 ], %l3
uint32_t cln;
if ( count == 0 )
20129d0: 80 a6 e0 00 cmp %i3, 0
20129d4: 02 80 00 84 be 2012be4 <fat_file_write+0x228> <== NEVER TAKEN
20129d8: 90 10 20 00 clr %o0
return cmpltd;
if (start >= fat_fd->size_limit)
20129dc: fa 06 60 14 ld [ %i1 + 0x14 ], %i5
20129e0: 80 a6 80 1d cmp %i2, %i5
20129e4: 2a 80 00 07 bcs,a 2012a00 <fat_file_write+0x44> <== ALWAYS TAKEN
20129e8: ba 27 40 1a sub %i5, %i2, %i5
rtems_set_errno_and_return_minus_one(EFBIG);
20129ec: 40 00 22 f0 call 201b5ac <__errno> <== NOT EXECUTED
20129f0: 01 00 00 00 nop <== NOT EXECUTED
20129f4: 82 10 20 1b mov 0x1b, %g1 ! 1b <PROM_START+0x1b> <== NOT EXECUTED
20129f8: 10 80 00 30 b 2012ab8 <fat_file_write+0xfc> <== NOT EXECUTED
20129fc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2012a00: 80 a7 40 1b cmp %i5, %i3
2012a04: 38 80 00 02 bgu,a 2012a0c <fat_file_write+0x50> <== ALWAYS TAKEN
2012a08: ba 10 00 1b mov %i3, %i5
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;
2012a0c: 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);
2012a10: b6 07 40 1a add %i5, %i2, %i3
2012a14: 94 40 20 00 addx %g0, 0, %o2
2012a18: 90 10 00 10 mov %l0, %o0
2012a1c: 92 10 00 19 mov %i1, %o1
2012a20: 96 10 00 1b mov %i3, %o3
2012a24: 7f ff ff 50 call 2012764 <fat_file_extend>
2012a28: 98 07 bf f8 add %fp, -8, %o4
if (RC_OK == rc)
2012a2c: 80 a2 20 00 cmp %o0, 0
2012a30: 12 80 00 6d bne 2012be4 <fat_file_write+0x228>
2012a34: 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))
2012a38: 80 a0 40 1b cmp %g1, %i3
2012a3c: 32 80 00 02 bne,a 2012a44 <fat_file_write+0x88> <== NEVER TAKEN
2012a40: 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));
2012a44: c6 06 60 20 ld [ %i1 + 0x20 ], %g3
*/
if (c != (start + count))
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))
2012a48: c4 0c 20 0e ldub [ %l0 + 0xe ], %g2
*/
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));
2012a4c: 80 a0 e0 01 cmp %g3, 1
2012a50: 12 80 00 09 bne 2012a74 <fat_file_write+0xb8>
2012a54: 82 10 20 00 clr %g1
2012a58: c6 06 60 24 ld [ %i1 + 0x24 ], %g3
2012a5c: 80 a0 e0 00 cmp %g3, 0
2012a60: 12 80 00 06 bne 2012a78 <fat_file_write+0xbc> <== NEVER TAKEN
2012a64: 80 a0 60 00 cmp %g1, 0
2012a68: 82 08 a0 03 and %g2, 3, %g1
2012a6c: 80 a0 00 01 cmp %g0, %g1
2012a70: 82 40 20 00 addx %g0, 0, %g1
*/
if (c != (start + count))
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))
2012a74: 80 a0 60 00 cmp %g1, 0
2012a78: 02 80 00 12 be 2012ac0 <fat_file_write+0x104>
2012a7c: f6 0c 20 08 ldub [ %l0 + 8 ], %i3
{
cln = fat_fd->cln;
2012a80: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
cln += (start >> fs_info->vol.bpc_log2);
byte = start & (fs_info->vol.bpc -1);
2012a84: 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);
2012a88: b7 36 80 1b srl %i2, %i3, %i3
byte = start & (fs_info->vol.bpc -1);
2012a8c: 94 02 bf ff add %o2, -1, %o2
ret = fat_cluster_write(fs_info,
2012a90: 90 10 00 10 mov %l0, %o0
2012a94: 92 06 c0 09 add %i3, %o1, %o1
2012a98: 94 0e 80 0a and %i2, %o2, %o2
2012a9c: 96 10 00 1d mov %i5, %o3
2012aa0: 98 10 00 1c mov %i4, %o4
2012aa4: 40 00 01 e5 call 2013238 <fat_cluster_write>
2012aa8: 9a 10 20 00 clr %o5
cln,
byte,
count,
buf,
false);
if (0 > ret)
2012aac: 80 a2 20 00 cmp %o0, 0
2012ab0: 16 80 00 4d bge 2012be4 <fat_file_write+0x228> <== ALWAYS TAKEN
2012ab4: 01 00 00 00 nop
rc = -1;
2012ab8: 10 80 00 4b b 2012be4 <fat_file_write+0x228> <== NOT EXECUTED
2012abc: 90 10 3f ff mov -1, %o0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
2012ac0: 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;
2012ac4: b6 0e e0 ff and %i3, 0xff, %i3
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);
2012ac8: aa 07 bf fc add %fp, -4, %l5
{
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;
2012acc: a3 36 80 1b srl %i2, %i3, %l1
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);
2012ad0: 90 10 00 10 mov %l0, %o0
2012ad4: 92 10 00 19 mov %i1, %o1
2012ad8: 94 10 00 11 mov %l1, %o2
2012adc: 7f ff fd 85 call 20120f0 <fat_file_lseek>
2012ae0: 96 10 00 15 mov %l5, %o3
if (RC_OK == rc)
2012ae4: 80 a2 60 00 cmp %o1, 0
2012ae8: 12 80 00 34 bne 2012bb8 <fat_file_write+0x1fc> <== NEVER TAKEN
2012aec: b7 2c 40 1b sll %l1, %i3, %i3
{
file_cln_cnt = cur_cln - fat_fd->cln;
2012af0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
2012af4: e4 07 bf fc ld [ %fp + -4 ], %l2
2012af8: a4 24 80 01 sub %l2, %g1, %l2
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);
2012afc: 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;
2012b00: 90 10 20 00 clr %o0
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);
2012b04: b0 10 00 1a mov %i2, %i0
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;
2012b08: a8 10 20 00 clr %l4
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 */
2012b0c: ac 10 20 00 clr %l6
const uint32_t count,
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
2012b10: 10 80 00 1a b 2012b78 <fat_file_write+0x1bc>
2012b14: b6 10 20 00 clr %i3
{
file_cln_cnt = cur_cln - fat_fd->cln;
while ( (RC_OK == rc)
&& (bytes_to_write > 0))
{
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
2012b18: 96 22 c0 18 sub %o3, %i0, %o3
2012b1c: 80 a2 c0 1d cmp %o3, %i5
2012b20: 38 80 00 02 bgu,a 2012b28 <fat_file_write+0x16c>
2012b24: 96 10 00 1d mov %i5, %o3
if (file_cln_initial < file_cln_cnt)
2012b28: 80 a4 c0 12 cmp %l3, %l2
2012b2c: 2a 80 00 02 bcs,a 2012b34 <fat_file_write+0x178>
2012b30: a8 10 20 01 mov 1, %l4
overwrite_cluster = true;
ret = fat_cluster_write(fs_info,
2012b34: d2 07 bf fc ld [ %fp + -4 ], %o1
2012b38: 90 10 00 10 mov %l0, %o0
2012b3c: 94 10 00 18 mov %i0, %o2
2012b40: 98 07 00 1b add %i4, %i3, %o4
2012b44: 40 00 01 bd call 2013238 <fat_cluster_write>
2012b48: 9a 0d 20 01 and %l4, 1, %o5
2012b4c: 82 10 00 08 mov %o0, %g1
cur_cln,
ofs_cln,
c,
&buf[cmpltd],
overwrite_cluster);
if (0 > ret)
2012b50: 80 a0 60 00 cmp %g1, 0
2012b54: 16 80 00 1d bge 2012bc8 <fat_file_write+0x20c> <== ALWAYS TAKEN
2012b58: 90 10 3f ff mov -1, %o0
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)
2012b5c: 10 80 00 08 b 2012b7c <fat_file_write+0x1c0> <== NOT EXECUTED
2012b60: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
++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);
2012b64: 90 10 00 10 mov %l0, %o0
2012b68: 92 10 00 16 mov %l6, %o1
2012b6c: 40 00 1a 80 call 201956c <fat_get_fat_cluster>
2012b70: 94 10 00 15 mov %l5, %o2
ofs_cln = 0;
2012b74: 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)
2012b78: 80 a7 60 00 cmp %i5, 0
2012b7c: 02 80 00 04 be 2012b8c <fat_file_write+0x1d0>
2012b80: 80 a2 20 00 cmp %o0, 0
2012b84: 22 bf ff e5 be,a 2012b18 <fat_file_write+0x15c> <== ALWAYS TAKEN
2012b88: d6 14 20 06 lduh [ %l0 + 6 ], %o3
}
/* 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);
2012b8c: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
2012b90: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
2012b94: ec 26 60 38 st %l6, [ %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);
2012b98: b4 06 80 1b add %i2, %i3, %i2
2012b9c: b5 36 80 01 srl %i2, %g1, %i2
}
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
2012ba0: a2 06 80 11 add %i2, %l1, %l1
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
}
if (RC_OK != rc)
2012ba4: 92 92 20 00 orcc %o0, 0, %o1
2012ba8: 12 80 00 03 bne 2012bb4 <fat_file_write+0x1f8> <== NEVER TAKEN
2012bac: e2 26 60 34 st %l1, [ %i1 + 0x34 ]
return rc;
else
return cmpltd;
2012bb0: 92 10 00 1b mov %i3, %o1
fat_fd,
start,
count,
buf,
file_cln_initial);
if (0 > ret)
2012bb4: 80 a2 60 00 cmp %o1, 0
2012bb8: 16 80 00 0b bge 2012be4 <fat_file_write+0x228> <== ALWAYS TAKEN
2012bbc: 90 10 00 09 mov %o1, %o0
2012bc0: 10 80 00 09 b 2012be4 <fat_file_write+0x228> <== NOT EXECUTED
2012bc4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
if (0 > ret)
rc = -1;
if (RC_OK == rc)
{
++file_cln_cnt;
2012bc8: a4 04 a0 01 inc %l2
bytes_to_write -= ret;
cmpltd += ret;
2012bcc: b6 06 c0 01 add %i3, %g1, %i3
save_cln = cur_cln;
if (0 < bytes_to_write)
2012bd0: ba a7 40 01 subcc %i5, %g1, %i5
2012bd4: 12 bf ff e4 bne 2012b64 <fat_file_write+0x1a8>
2012bd8: ec 07 bf fc ld [ %fp + -4 ], %l6
2012bdc: 10 bf ff e6 b 2012b74 <fat_file_write+0x1b8>
2012be0: 90 10 20 00 clr %o0
}
if (RC_OK != rc)
return rc;
else
return cmpltd;
}
2012be4: 81 c7 e0 08 ret
2012be8: 91 e8 00 08 restore %g0, %o0, %o0
020199b8 <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
20199b8: 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;
20199bc: b8 10 20 00 clr %i4
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
20199c0: ba 10 00 18 mov %i0, %i5
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
20199c4: c0 27 bf fc clr [ %fp + -4 ]
fat_fs_info_t *fs_info,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
20199c8: b6 10 00 19 mov %i1, %i3
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
20199cc: 10 80 00 19 b 2019a30 <fat_free_fat_clusters_chain+0x78>
20199d0: b4 10 20 00 clr %i2
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
20199d4: 92 10 00 1b mov %i3, %o1
20199d8: 7f ff fe e5 call 201956c <fat_get_fat_cluster>
20199dc: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
20199e0: b0 92 20 00 orcc %o0, 0, %i0
20199e4: 02 80 00 0b be 2019a10 <fat_free_fat_clusters_chain+0x58> <== ALWAYS TAKEN
20199e8: 90 10 00 1d mov %i5, %o0
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
20199ec: c2 07 60 44 ld [ %i5 + 0x44 ], %g1 <== NOT EXECUTED
20199f0: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
20199f4: 02 80 00 03 be 2019a00 <fat_free_fat_clusters_chain+0x48> <== NOT EXECUTED
20199f8: b8 07 00 01 add %i4, %g1, %i4 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
20199fc: f8 27 60 44 st %i4, [ %i5 + 0x44 ] <== NOT EXECUTED
fat_buf_release(fs_info);
2019a00: 7f ff e4 dd call 2012d74 <fat_buf_release> <== NOT EXECUTED
2019a04: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2019a08: 81 c7 e0 08 ret <== NOT EXECUTED
2019a0c: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
2019a10: 92 10 00 1b mov %i3, %o1
2019a14: 7f ff ff 48 call 2019734 <fat_set_fat_cluster>
2019a18: 94 10 20 00 clr %o2
if ( rc != RC_OK )
2019a1c: 80 a2 20 00 cmp %o0, 0
2019a20: 32 80 00 02 bne,a 2019a28 <fat_free_fat_clusters_chain+0x70><== NEVER TAKEN
2019a24: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
2019a28: f6 07 bf fc ld [ %fp + -4 ], %i3
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
2019a2c: b8 07 20 01 inc %i4
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2019a30: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
2019a34: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2019a38: 84 0e c0 02 and %i3, %g2, %g2
2019a3c: 80 a0 80 01 cmp %g2, %g1
2019a40: 0a bf ff e5 bcs 20199d4 <fat_free_fat_clusters_chain+0x1c>
2019a44: 90 10 00 1d mov %i5, %o0
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
2019a48: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
2019a4c: 80 a0 7f ff cmp %g1, -1
2019a50: 02 80 00 05 be 2019a64 <fat_free_fat_clusters_chain+0xac> <== ALWAYS TAKEN
2019a54: f2 27 60 4c st %i1, [ %i5 + 0x4c ]
fs_info->vol.free_cls += freed_cls_cnt;
2019a58: b8 07 00 01 add %i4, %g1, %i4 <== NOT EXECUTED
2019a5c: f8 27 60 44 st %i4, [ %i5 + 0x44 ] <== NOT EXECUTED
fat_buf_release(fs_info);
2019a60: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2019a64: 7f ff e4 c4 call 2012d74 <fat_buf_release>
2019a68: b0 10 00 1a mov %i2, %i0
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
2019a6c: 81 c7 e0 08 ret
2019a70: 81 e8 00 00 restore
02013e0c <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);
2013e0c: c2 02 20 80 ld [ %o0 + 0x80 ], %g1 <== NOT EXECUTED
2013e10: c4 02 20 74 ld [ %o0 + 0x74 ], %g2 <== NOT EXECUTED
2013e14: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
2013e18: 92 22 40 01 sub %o1, %g1, %o1 <== NOT EXECUTED
2013e1c: 83 32 60 03 srl %o1, 3, %g1 <== NOT EXECUTED
2013e20: 92 0a 60 07 and %o1, 7, %o1 <== NOT EXECUTED
2013e24: 93 28 c0 09 sll %g3, %o1, %o1 <== NOT EXECUTED
2013e28: c6 08 80 01 ldub [ %g2 + %g1 ], %g3 <== NOT EXECUTED
2013e2c: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
2013e30: 81 c3 e0 08 retl <== NOT EXECUTED
2013e34: d2 28 80 01 stb %o1, [ %g2 + %g1 ] <== NOT EXECUTED
0201956c <fat_get_fat_cluster>:
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
201956c: 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)) )
2019570: 80 a6 60 01 cmp %i1, 1
2019574: 08 80 00 67 bleu 2019710 <fat_get_fat_cluster+0x1a4> <== NEVER TAKEN
2019578: ba 10 00 18 mov %i0, %i5
201957c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
2019580: 82 00 60 01 inc %g1
2019584: 80 a6 40 01 cmp %i1, %g1
2019588: 28 80 00 03 bleu,a 2019594 <fat_get_fat_cluster+0x28> <== ALWAYS TAKEN
201958c: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
2019590: 30 80 00 60 b,a 2019710 <fat_get_fat_cluster+0x1a4> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
2019594: 86 08 60 01 and %g1, 1, %g3
2019598: 80 88 e0 ff btst 0xff, %g3
201959c: 02 80 00 05 be 20195b0 <fat_get_fat_cluster+0x44>
20195a0: 88 08 60 02 and %g1, 2, %g4
20195a4: 85 36 60 01 srl %i1, 1, %g2
20195a8: 10 80 00 06 b 20195c0 <fat_get_fat_cluster+0x54>
20195ac: 84 00 80 19 add %g2, %i1, %g2
20195b0: 80 89 20 ff btst 0xff, %g4
20195b4: 02 80 00 03 be 20195c0 <fat_get_fat_cluster+0x54>
20195b8: 85 2e 60 02 sll %i1, 2, %g2
20195bc: 85 2e 60 01 sll %i1, 1, %g2
20195c0: f6 0f 60 02 ldub [ %i5 + 2 ], %i3
20195c4: c8 07 60 58 ld [ %i5 + 0x58 ], %g4
20195c8: 85 30 80 1b srl %g2, %i3, %g2
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
20195cc: 80 88 e0 ff btst 0xff, %g3
20195d0: 02 80 00 05 be 20195e4 <fat_get_fat_cluster+0x78>
20195d4: b6 00 80 04 add %g2, %g4, %i3
20195d8: b9 36 60 01 srl %i1, 1, %i4
20195dc: 10 80 00 07 b 20195f8 <fat_get_fat_cluster+0x8c>
20195e0: b8 07 00 19 add %i4, %i1, %i4
20195e4: 82 08 60 02 and %g1, 2, %g1
20195e8: 80 88 60 ff btst 0xff, %g1
20195ec: 02 80 00 03 be 20195f8 <fat_get_fat_cluster+0x8c>
20195f0: b9 2e 60 02 sll %i1, 2, %i4
20195f4: b9 2e 60 01 sll %i1, 1, %i4
20195f8: e0 17 40 00 lduh [ %i5 ], %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
20195fc: 90 10 00 1d mov %i5, %o0
2019600: 92 10 00 1b mov %i3, %o1
2019604: 94 10 20 01 mov 1, %o2
2019608: 7f ff e6 4f call 2012f44 <fat_buf_access>
201960c: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2019610: b0 92 20 00 orcc %o0, 0, %i0
2019614: 12 80 00 37 bne 20196f0 <fat_get_fat_cluster+0x184> <== NEVER TAKEN
2019618: 83 2c 20 10 sll %l0, 0x10, %g1
return rc;
switch ( fs_info->vol.type )
201961c: c4 0f 60 0e ldub [ %i5 + 0xe ], %g2
2019620: 80 a0 a0 02 cmp %g2, 2
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
2019624: 83 30 60 10 srl %g1, 0x10, %g1
2019628: 82 00 7f ff add %g1, -1, %g1
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
201962c: 02 80 00 27 be 20196c8 <fat_get_fat_cluster+0x15c>
2019630: 82 0f 00 01 and %i4, %g1, %g1
2019634: 80 a0 a0 04 cmp %g2, 4
2019638: 02 80 00 30 be 20196f8 <fat_get_fat_cluster+0x18c>
201963c: 80 a0 a0 01 cmp %g2, 1
2019640: 12 80 00 34 bne 2019710 <fat_get_fat_cluster+0x1a4> <== NEVER TAKEN
2019644: c6 07 bf fc ld [ %fp + -4 ], %g3
/*
* 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) )
2019648: c8 17 40 00 lduh [ %i5 ], %g4
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
201964c: c4 08 c0 01 ldub [ %g3 + %g1 ], %g2
if ( ofs == (fs_info->vol.bps - 1) )
2019650: 88 01 3f ff add %g4, -1, %g4
2019654: 80 a0 40 04 cmp %g1, %g4
2019658: 12 80 00 10 bne 2019698 <fat_get_fat_cluster+0x12c> <== ALWAYS TAKEN
201965c: c4 26 80 00 st %g2, [ %i2 ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
2019660: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2019664: 92 06 e0 01 add %i3, 1, %o1 <== NOT EXECUTED
2019668: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
201966c: 7f ff e6 36 call 2012f44 <fat_buf_access> <== NOT EXECUTED
2019670: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
2019674: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2019678: 12 80 00 2c bne 2019728 <fat_get_fat_cluster+0x1bc> <== NOT EXECUTED
201967c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*ret_val |= *sec_buf << 8;
2019680: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED
2019684: c2 08 40 00 ldub [ %g1 ], %g1 <== NOT EXECUTED
2019688: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
201968c: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
2019690: 10 80 00 07 b 20196ac <fat_get_fat_cluster+0x140> <== NOT EXECUTED
2019694: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
}
else
{
*ret_val |= *(sec_buf + ofs + 1) << 8;
2019698: 82 00 c0 01 add %g3, %g1, %g1
201969c: c2 08 60 01 ldub [ %g1 + 1 ], %g1
20196a0: 83 28 60 08 sll %g1, 8, %g1
20196a4: 84 10 40 02 or %g1, %g2, %g2
20196a8: c4 26 80 00 st %g2, [ %i2 ]
}
if ( FAT_CLUSTER_IS_ODD(cln) )
20196ac: 80 8e 60 01 btst 1, %i1
20196b0: 02 80 00 04 be 20196c0 <fat_get_fat_cluster+0x154>
20196b4: c2 06 80 00 ld [ %i2 ], %g1
*ret_val = (*ret_val) >> FAT12_SHIFT;
20196b8: 10 80 00 0d b 20196ec <fat_get_fat_cluster+0x180>
20196bc: 83 30 60 04 srl %g1, 4, %g1
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
20196c0: 10 80 00 0b b 20196ec <fat_get_fat_cluster+0x180>
20196c4: 82 08 6f ff and %g1, 0xfff, %g1
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(sec_buf + ofs));
20196c8: c4 07 bf fc ld [ %fp + -4 ], %g2
*ret_val = CF_LE_W(*ret_val);
20196cc: 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));
20196d0: c2 10 80 01 lduh [ %g2 + %g1 ], %g1
*ret_val = CF_LE_W(*ret_val);
20196d4: 86 10 e3 ff or %g3, 0x3ff, %g3
20196d8: 83 28 60 10 sll %g1, 0x10, %g1
20196dc: 85 30 60 18 srl %g1, 0x18, %g2
20196e0: 83 30 60 08 srl %g1, 8, %g1
20196e4: 82 08 40 03 and %g1, %g3, %g1
20196e8: 82 10 80 01 or %g2, %g1, %g1
20196ec: c2 26 80 00 st %g1, [ %i2 ]
break;
20196f0: 81 c7 e0 08 ret
20196f4: 81 e8 00 00 restore
case FAT_FAT32:
*ret_val = *((uint32_t *)(sec_buf + ofs));
*ret_val = CF_LE_L(*ret_val);
20196f8: c4 07 bf fc ld [ %fp + -4 ], %g2
20196fc: 7f ff ff 90 call 201953c <CPU_swap_u32>
2019700: d0 00 80 01 ld [ %g2 + %g1 ], %o0
2019704: d0 26 80 00 st %o0, [ %i2 ]
break;
2019708: 81 c7 e0 08 ret
201970c: 81 e8 00 00 restore
default:
rtems_set_errno_and_return_minus_one(EIO);
2019710: 40 00 07 a7 call 201b5ac <__errno> <== NOT EXECUTED
2019714: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2019718: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201971c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2019720: 81 c7 e0 08 ret <== NOT EXECUTED
2019724: 81 e8 00 00 restore <== NOT EXECUTED
*ret_val = (*(sec_buf + ofs));
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&sec_buf);
if (rc != RC_OK)
2019728: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
201972c: 81 c7 e0 08 ret <== NOT EXECUTED
2019730: 81 e8 00 00 restore <== NOT EXECUTED
02013d4c <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
2013d4c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
2013d50: 39 03 ff ff sethi %hi(0xffffc00), %i4 <== NOT EXECUTED
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
2013d54: 10 80 00 2b b 2013e00 <fat_get_unique_ino+0xb4> <== NOT EXECUTED
2013d58: b8 17 23 ff or %i4, 0x3ff, %i4 ! fffffff <RAM_END+0xdbfffff><== NOT EXECUTED
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
2013d5c: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 <== NOT EXECUTED
2013d60: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
2013d64: b6 00 c0 02 add %g3, %g2, %i3 <== NOT EXECUTED
2013d68: f4 08 c0 02 ldub [ %g3 + %g2 ], %i2 <== NOT EXECUTED
2013d6c: c4 48 c0 02 ldsb [ %g3 + %g2 ], %g2 <== NOT EXECUTED
2013d70: ba 08 60 07 and %g1, 7, %i5 <== NOT EXECUTED
2013d74: 85 38 80 1d sra %g2, %i5, %g2 <== NOT EXECUTED
2013d78: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
2013d7c: 12 80 00 0a bne 2013da4 <fat_get_unique_ino+0x58> <== NOT EXECUTED
2013d80: 82 00 60 01 inc %g1 <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
2013d84: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2013d88: bb 28 40 1d sll %g1, %i5, %i5 <== NOT EXECUTED
2013d8c: ba 17 40 1a or %i5, %i2, %i5 <== NOT EXECUTED
2013d90: fa 2e c0 00 stb %i5, [ %i3 ] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
2013d94: c4 06 20 78 ld [ %i0 + 0x78 ], %g2 <== NOT EXECUTED
2013d98: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
2013d9c: 81 c7 e0 08 ret <== NOT EXECUTED
2013da0: 91 e8 80 01 restore %g2, %g1, %o0 <== NOT EXECUTED
}
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
2013da4: 80 a0 40 04 cmp %g1, %g4 <== NOT EXECUTED
2013da8: 3a 80 00 03 bcc,a 2013db4 <fat_get_unique_ino+0x68> <== NOT EXECUTED
2013dac: c0 26 20 78 clr [ %i0 + 0x78 ] <== NOT EXECUTED
2013db0: c2 26 20 78 st %g1, [ %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++)
2013db4: 92 02 60 01 inc %o1 <== NOT EXECUTED
2013db8: 80 a2 40 04 cmp %o1, %g4 <== NOT EXECUTED
2013dbc: 32 bf ff e8 bne,a 2013d5c <fat_get_unique_ino+0x10> <== NOT EXECUTED
2013dc0: c6 06 20 74 ld [ %i0 + 0x74 ], %g3 <== NOT EXECUTED
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
2013dc4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
2013dc8: 93 2a 60 01 sll %o1, 1, %o1 <== NOT EXECUTED
2013dcc: 82 27 00 01 sub %i4, %g1, %g1 <== NOT EXECUTED
2013dd0: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
2013dd4: 2a 80 00 04 bcs,a 2013de4 <fat_get_unique_ino+0x98> <== NOT EXECUTED
2013dd8: d0 06 20 74 ld [ %i0 + 0x74 ], %o0 <== NOT EXECUTED
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
2013ddc: 81 c7 e0 08 ret <== NOT EXECUTED
2013de0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
2013de4: 7f ff c9 6c call 2006394 <realloc> <== NOT EXECUTED
2013de8: d2 26 20 7c st %o1, [ %i0 + 0x7c ] <== NOT EXECUTED
if (fs_info->uino != NULL)
2013dec: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2013df0: 02 bf ff fb be 2013ddc <fat_get_unique_ino+0x90> <== NOT EXECUTED
2013df4: d0 26 20 74 st %o0, [ %i0 + 0x74 ] <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
2013df8: c2 06 20 7c ld [ %i0 + 0x7c ], %g1 <== NOT EXECUTED
2013dfc: c2 26 20 78 st %g1, [ %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++)
2013e00: c8 06 20 7c ld [ %i0 + 0x7c ], %g4 <== NOT EXECUTED
2013e04: 10 bf ff ed b 2013db8 <fat_get_unique_ino+0x6c> <== NOT EXECUTED
2013e08: 92 10 20 00 clr %o1 <== NOT EXECUTED
02013cd4 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
2013cd4: 9d e3 bf 98 save %sp, -104, %sp
2013cd8: ba 10 00 18 mov %i0, %i5
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)
2013cdc: 10 80 00 10 b 2013d1c <fat_init_clusters_chain+0x48>
2013ce0: f2 27 bf fc st %i1, [ %fp + -4 ]
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
2013ce4: 90 10 00 1d mov %i5, %o0
2013ce8: 94 10 20 00 clr %o2
2013cec: 7f ff fd 0b call 2013118 <fat_cluster_set>
2013cf0: 98 10 20 00 clr %o4
if ( ret != fs_info->vol.bpc )
2013cf4: c2 17 60 06 lduh [ %i5 + 6 ], %g1
2013cf8: 80 a2 00 01 cmp %o0, %g1
2013cfc: 12 80 00 11 bne 2013d40 <fat_init_clusters_chain+0x6c> <== NEVER TAKEN
2013d00: d2 07 bf fc ld [ %fp + -4 ], %o1
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2013d04: 90 10 00 1d mov %i5, %o0
2013d08: 40 00 16 19 call 201956c <fat_get_fat_cluster>
2013d0c: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2013d10: b0 92 20 00 orcc %o0, 0, %i0
2013d14: 12 80 00 0c bne 2013d44 <fat_init_clusters_chain+0x70> <== NEVER TAKEN
2013d18: 01 00 00 00 nop
{
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)
2013d1c: d2 07 bf fc ld [ %fp + -4 ], %o1
2013d20: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
2013d24: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2013d28: 84 0a 40 02 and %o1, %g2, %g2
2013d2c: 80 a0 80 01 cmp %g2, %g1
2013d30: 2a bf ff ed bcs,a 2013ce4 <fat_init_clusters_chain+0x10>
2013d34: d6 17 60 06 lduh [ %i5 + 6 ], %o3
return rc;
}
}
return rc;
2013d38: 81 c7 e0 08 ret
2013d3c: 91 e8 20 00 restore %g0, 0, %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;
2013d40: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
}
}
return rc;
}
2013d44: 81 c7 e0 08 ret <== NOT EXECUTED
2013d48: 81 e8 00 00 restore <== NOT EXECUTED
02013364 <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)
{
2013364: 9d e3 bf 08 save %sp, -248, %sp
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
vol->fd = open(device, O_RDWR);
2013368: 92 10 20 02 mov 2, %o1
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(fat_fs_info_t *fs_info, const char *device)
{
201336c: b6 10 00 18 mov %i0, %i3
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;
2013370: c0 27 bf a4 clr [ %fp + -92 ]
vol->fd = open(device, O_RDWR);
2013374: 7f ff cb 6d call 2006128 <open>
2013378: 90 10 00 19 mov %i1, %o0
if (vol->fd < 0)
201337c: 80 a2 20 00 cmp %o0, 0
2013380: 06 80 00 17 bl 20133dc <fat_init_volume_info+0x78> <== NEVER TAKEN
2013384: d0 26 e0 60 st %o0, [ %i3 + 0x60 ]
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
2013388: 7f ff c8 1d call 20053fc <fstat>
201338c: 92 07 bf b8 add %fp, -72, %o1
if (rc != 0)
2013390: 80 a2 20 00 cmp %o0, 0
2013394: 12 80 00 10 bne 20133d4 <fat_init_volume_info+0x70> <== NEVER TAKEN
2013398: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
close(vol->fd);
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
201339c: c6 07 bf c4 ld [ %fp + -60 ], %g3
20133a0: 05 00 00 3c sethi %hi(0xf000), %g2
20133a4: 86 08 c0 02 and %g3, %g2, %g3
20133a8: 05 00 00 18 sethi %hi(0x6000), %g2
20133ac: 80 a0 c0 02 cmp %g3, %g2
20133b0: 12 80 00 09 bne 20133d4 <fat_init_volume_info+0x70> <== NEVER TAKEN
20133b4: 13 10 01 10 sethi %hi(0x40044000), %o1
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
20133b8: 94 06 20 64 add %i0, 0x64, %o2
20133bc: 40 00 05 97 call 2014a18 <ioctl>
20133c0: 92 12 62 09 or %o1, 0x209, %o1
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* check that device is registred as block device and lock it */
rc = rtems_disk_fd_get_disk_device(vol->fd, &vol->dd);
if (rc != 0) {
20133c4: 80 a2 20 00 cmp %o0, 0
20133c8: 22 80 00 09 be,a 20133ec <fat_init_volume_info+0x88> <== ALWAYS TAKEN
20133cc: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
close(vol->fd);
20133d0: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
20133d4: 7f ff c7 23 call 2005060 <close> <== NOT EXECUTED
20133d8: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
20133dc: 40 00 20 74 call 201b5ac <__errno> <== NOT EXECUTED
20133e0: 01 00 00 00 nop <== NOT EXECUTED
20133e4: 10 80 01 af b 2013aa0 <fat_init_volume_info+0x73c> <== NOT EXECUTED
20133e8: 82 10 20 06 mov 6, %g1 ! 6 <PROM_START+0x6> <== NOT EXECUTED
}
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dd, 0, &block);
20133ec: 92 10 20 00 clr %o1
20133f0: 7f ff f6 9a call 2010e58 <rtems_bdbuf_read>
20133f4: 94 07 bf a4 add %fp, -92, %o2
if (sc != RTEMS_SUCCESSFUL)
20133f8: 80 a2 20 00 cmp %o0, 0
20133fc: 22 80 00 03 be,a 2013408 <fat_init_volume_info+0xa4> <== ALWAYS TAKEN
2013400: d0 07 bf a4 ld [ %fp + -92 ], %o0
2013404: 30 80 00 32 b,a 20134cc <fat_init_volume_info+0x168> <== NOT EXECUTED
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
2013408: c6 02 20 1c ld [ %o0 + 0x1c ], %g3
201340c: c2 08 e0 20 ldub [ %g3 + 0x20 ], %g1
2013410: c4 08 e0 0b ldub [ %g3 + 0xb ], %g2
2013414: c2 2f bf 9a stb %g1, [ %fp + -102 ]
2013418: c2 08 e0 23 ldub [ %g3 + 0x23 ], %g1
201341c: d2 08 e0 0c ldub [ %g3 + 0xc ], %o1
2013420: c2 2f bf 8f stb %g1, [ %fp + -113 ]
2013424: c2 08 e0 2c ldub [ %g3 + 0x2c ], %g1
2013428: d8 08 e0 0e ldub [ %g3 + 0xe ], %o4
201342c: c2 2f bf 9d stb %g1, [ %fp + -99 ]
2013430: c2 08 e0 2d ldub [ %g3 + 0x2d ], %g1
2013434: d6 08 e0 0f ldub [ %g3 + 0xf ], %o3
2013438: c2 2f bf 9c stb %g1, [ %fp + -100 ]
201343c: c2 08 e0 2e ldub [ %g3 + 0x2e ], %g1
2013440: c8 08 e0 11 ldub [ %g3 + 0x11 ], %g4
2013444: c2 2f bf 9b stb %g1, [ %fp + -101 ]
2013448: c2 08 e0 2f ldub [ %g3 + 0x2f ], %g1
201344c: da 08 e0 12 ldub [ %g3 + 0x12 ], %o5
2013450: c2 2f bf 97 stb %g1, [ %fp + -105 ]
2013454: c2 08 e0 30 ldub [ %g3 + 0x30 ], %g1
2013458: fa 08 e0 0d ldub [ %g3 + 0xd ], %i5
201345c: f4 08 e0 10 ldub [ %g3 + 0x10 ], %i2
2013460: e2 08 e0 13 ldub [ %g3 + 0x13 ], %l1
2013464: e4 08 e0 14 ldub [ %g3 + 0x14 ], %l2
2013468: ee 08 e0 16 ldub [ %g3 + 0x16 ], %l7
201346c: f0 08 e0 17 ldub [ %g3 + 0x17 ], %i0
2013470: e0 08 e0 21 ldub [ %g3 + 0x21 ], %l0
2013474: f2 08 e0 22 ldub [ %g3 + 0x22 ], %i1
2013478: e8 08 e0 24 ldub [ %g3 + 0x24 ], %l4
201347c: ec 08 e0 25 ldub [ %g3 + 0x25 ], %l6
2013480: ea 08 e0 26 ldub [ %g3 + 0x26 ], %l5
2013484: e6 08 e0 27 ldub [ %g3 + 0x27 ], %l3
2013488: f8 08 e0 28 ldub [ %g3 + 0x28 ], %i4
201348c: c2 2f bf 9f stb %g1, [ %fp + -97 ]
2013490: c6 08 e0 31 ldub [ %g3 + 0x31 ], %g3
sc = rtems_bdbuf_release( block);
2013494: c4 27 bf 80 st %g2, [ %fp + -128 ]
2013498: c8 27 bf 7c st %g4, [ %fp + -132 ]
201349c: d2 27 bf 78 st %o1, [ %fp + -136 ]
20134a0: d6 27 bf 74 st %o3, [ %fp + -140 ]
20134a4: d8 3f bf 68 std %o4, [ %fp + -152 ]
20134a8: 7f ff f6 e8 call 2011048 <rtems_bdbuf_release>
20134ac: c6 2f bf 9e stb %g3, [ %fp + -98 ]
if (sc != RTEMS_SUCCESSFUL)
20134b0: c4 07 bf 80 ld [ %fp + -128 ], %g2
20134b4: 80 a2 20 00 cmp %o0, 0
20134b8: c8 07 bf 7c ld [ %fp + -132 ], %g4
20134bc: d2 07 bf 78 ld [ %fp + -136 ], %o1
20134c0: d6 07 bf 74 ld [ %fp + -140 ], %o3
20134c4: 02 80 00 08 be 20134e4 <fat_init_volume_info+0x180> <== ALWAYS TAKEN
20134c8: d8 1f bf 68 ldd [ %fp + -152 ], %o4
{
close(vol->fd);
20134cc: 7f ff c6 e5 call 2005060 <close> <== NOT EXECUTED
20134d0: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
20134d4: 40 00 20 36 call 201b5ac <__errno> <== NOT EXECUTED
20134d8: 01 00 00 00 nop <== NOT EXECUTED
20134dc: 10 80 01 71 b 2013aa0 <fat_init_volume_info+0x73c> <== NOT EXECUTED
20134e0: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
20134e4: 84 08 a0 ff and %g2, 0xff, %g2
20134e8: 92 0a 60 ff and %o1, 0xff, %o1
20134ec: 93 2a 60 08 sll %o1, 8, %o1
20134f0: 92 12 40 02 or %o1, %g2, %o1
20134f4: d2 36 c0 00 sth %o1, [ %i3 ]
if ( (vol->bps != 512) &&
20134f8: 85 2a 60 10 sll %o1, 0x10, %g2
20134fc: 85 30 a0 10 srl %g2, 0x10, %g2
2013500: 80 a0 a4 00 cmp %g2, 0x400
2013504: 02 80 00 0c be 2013534 <fat_init_volume_info+0x1d0> <== NEVER TAKEN
2013508: 86 10 00 09 mov %o1, %g3
201350c: 80 a0 a2 00 cmp %g2, 0x200
2013510: 22 80 00 0a be,a 2013538 <fat_init_volume_info+0x1d4> <== ALWAYS TAKEN
2013514: 85 2a 60 10 sll %o1, 0x10, %g2
(vol->bps != 1024) &&
2013518: 80 a0 a8 00 cmp %g2, 0x800 <== NOT EXECUTED
201351c: 02 80 00 06 be 2013534 <fat_init_volume_info+0x1d0> <== NOT EXECUTED
2013520: 1f 00 00 04 sethi %hi(0x1000), %o7 <== NOT EXECUTED
(vol->bps != 2048) &&
2013524: 80 a0 80 0f cmp %g2, %o7 <== NOT EXECUTED
2013528: 02 80 00 04 be 2013538 <fat_init_volume_info+0x1d4> <== NOT EXECUTED
201352c: 85 2a 60 10 sll %o1, 0x10, %g2 <== NOT EXECUTED
2013530: 30 80 00 d6 b,a 2013888 <fat_init_volume_info+0x524> <== 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;
2013534: 85 2a 60 10 sll %o1, 0x10, %g2 <== NOT EXECUTED
2013538: c0 2e e0 03 clrb [ %i3 + 3 ]
201353c: 10 80 00 05 b 2013550 <fat_init_volume_info+0x1ec>
2013540: 85 30 a0 19 srl %g2, 0x19, %g2
i >>= 1, vol->sec_mul++);
2013544: 85 38 a0 01 sra %g2, 1, %g2 <== NOT EXECUTED
2013548: 9e 03 e0 01 inc %o7 <== NOT EXECUTED
201354c: de 2e e0 03 stb %o7, [ %i3 + 3 ] <== 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;
2013550: 80 88 a0 01 btst 1, %g2
2013554: 22 bf ff fc be,a 2013544 <fat_init_volume_info+0x1e0> <== NEVER TAKEN
2013558: de 0e e0 03 ldub [ %i3 + 3 ], %o7 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
201355c: 93 2a 60 10 sll %o1, 0x10, %o1
2013560: c0 2e e0 02 clrb [ %i3 + 2 ]
2013564: 93 32 60 10 srl %o1, 0x10, %o1
2013568: 10 80 00 05 b 201357c <fat_init_volume_info+0x218>
201356c: 9e 10 00 09 mov %o1, %o7
i >>= 1, vol->sec_log2++);
2013570: 84 00 a0 01 inc %g2
2013574: 9f 3b e0 01 sra %o7, 1, %o7
2013578: c4 2e e0 02 stb %g2, [ %i3 + 2 ]
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;
201357c: 80 8b e0 01 btst 1, %o7
2013580: 02 bf ff fc be 2013570 <fat_init_volume_info+0x20c>
2013584: c4 0e e0 02 ldub [ %i3 + 2 ], %g2
i >>= 1, vol->sec_log2++);
vol->bytes_per_block = vol->bps;
2013588: c6 36 e0 0a sth %g3, [ %i3 + 0xa ]
vol->bytes_per_block_log2 = vol->sec_log2;
201358c: c4 2e e0 0c stb %g2, [ %i3 + 0xc ]
vol->sectors_per_block = 1;
2013590: 86 10 20 01 mov 1, %g3
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
2013594: fa 2e e0 04 stb %i5, [ %i3 + 4 ]
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
2013598: 9e 8f 60 ff andcc %i5, 0xff, %o7
201359c: 02 80 00 bb be 2013888 <fat_init_volume_info+0x524> <== NEVER TAKEN
20135a0: c6 2e e0 09 stb %g3, [ %i3 + 9 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
20135a4: 10 80 00 05 b 20135b8 <fat_init_volume_info+0x254>
20135a8: c0 2e e0 05 clrb [ %i3 + 5 ]
i >>= 1, vol->spc_log2++);
20135ac: 86 00 e0 01 inc %g3
20135b0: 9f 3b e0 01 sra %o7, 1, %o7
20135b4: c6 2e e0 05 stb %g3, [ %i3 + 5 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
20135b8: 80 8b e0 01 btst 1, %o7
20135bc: 02 bf ff fc be 20135ac <fat_init_volume_info+0x248>
20135c0: c6 0e e0 05 ldub [ %i3 + 5 ], %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)
20135c4: 87 2a 40 03 sll %o1, %g3, %g3
20135c8: 95 28 e0 10 sll %g3, 0x10, %o2
20135cc: 1f 20 00 00 sethi %hi(0x80000000), %o7
20135d0: 80 a2 80 0f cmp %o2, %o7
20135d4: 18 80 00 ad bgu 2013888 <fat_init_volume_info+0x524> <== NEVER TAKEN
20135d8: c6 36 e0 06 sth %g3, [ %i3 + 6 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
20135dc: 1f 00 00 3f sethi %hi(0xfc00), %o7
20135e0: c0 2e e0 08 clrb [ %i3 + 8 ]
20135e4: 9e 13 e3 ff or %o7, 0x3ff, %o7
20135e8: 10 80 00 05 b 20135fc <fat_init_volume_info+0x298>
20135ec: 86 08 c0 0f and %g3, %o7, %g3
i >>= 1, vol->bpc_log2++);
20135f0: 87 38 e0 01 sra %g3, 1, %g3
20135f4: 9e 03 e0 01 inc %o7
20135f8: de 2e e0 08 stb %o7, [ %i3 + 8 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
20135fc: 80 88 e0 01 btst 1, %g3
2013600: 22 bf ff fc be,a 20135f0 <fat_init_volume_info+0x28c>
2013604: de 0e e0 08 ldub [ %i3 + 8 ], %o7
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
2013608: f4 2e e0 0d stb %i2, [ %i3 + 0xd ]
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)) /
201360c: 86 02 7f ff add %o1, -1, %g3
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
2013610: 96 0a e0 ff and %o3, 0xff, %o3
2013614: 98 0b 20 ff and %o4, 0xff, %o4
2013618: 97 2a e0 08 sll %o3, 8, %o3
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
201361c: 9a 0b 60 ff and %o5, 0xff, %o5
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);
2013620: 98 12 c0 0c or %o3, %o4, %o4
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
2013624: 9b 2b 60 08 sll %o5, 8, %o5
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);
2013628: d8 36 e0 18 sth %o4, [ %i3 + 0x18 ]
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
201362c: 88 09 20 ff and %g4, 0xff, %g4
2013630: 88 13 40 04 or %o5, %g4, %g4
2013634: c8 36 e0 24 sth %g4, [ %i3 + 0x24 ]
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
2013638: 89 29 20 10 sll %g4, 0x10, %g4
201363c: c4 27 bf 80 st %g2, [ %fp + -128 ]
2013640: 91 31 20 0b srl %g4, 0xb, %o0
2013644: d8 27 bf 68 st %o4, [ %fp + -152 ]
2013648: 7f ff bc 3e call 2002740 <.div>
201364c: 90 02 00 03 add %o0, %g3, %o0
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
2013650: c4 07 bf 80 ld [ %fp + -128 ], %g2
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
2013654: d0 26 e0 28 st %o0, [ %i3 + 0x28 ]
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
2013658: 85 2a 00 02 sll %o0, %g2, %g2
201365c: c4 26 e0 2c st %g2, [ %i3 + 0x2c ]
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
2013660: b0 0e 20 ff and %i0, 0xff, %i0
2013664: ae 0d e0 ff and %l7, 0xff, %l7
2013668: b1 2e 20 08 sll %i0, 8, %i0
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
201366c: 86 10 00 08 mov %o0, %g3
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
2013670: ae 16 00 17 or %i0, %l7, %l7
2013674: af 2d e0 10 sll %l7, 0x10, %l7
2013678: 80 a5 e0 00 cmp %l7, 0
201367c: 02 80 00 05 be 2013690 <fat_init_volume_info+0x32c>
2013680: d8 07 bf 68 ld [ %fp + -152 ], %o4
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
2013684: af 35 e0 10 srl %l7, 0x10, %l7
2013688: 10 80 00 0c b 20136b8 <fat_init_volume_info+0x354>
201368c: ee 26 e0 1c st %l7, [ %i3 + 0x1c ]
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
2013690: ac 0d a0 ff and %l6, 0xff, %l6
2013694: aa 0d 60 ff and %l5, 0xff, %l5
2013698: ad 2d a0 08 sll %l6, 8, %l6
201369c: ab 2d 60 10 sll %l5, 0x10, %l5
20136a0: a8 0d 20 ff and %l4, 0xff, %l4
20136a4: aa 15 80 15 or %l6, %l5, %l5
20136a8: a7 2c e0 18 sll %l3, 0x18, %l3
20136ac: a8 15 40 14 or %l5, %l4, %l4
20136b0: a6 15 00 13 or %l4, %l3, %l3
20136b4: e6 26 e0 1c st %l3, [ %i3 + 0x1c ]
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
20136b8: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
20136bc: 99 2b 20 10 sll %o4, 0x10, %o4
20136c0: c6 27 bf 84 st %g3, [ %fp + -124 ]
20136c4: b1 33 20 10 srl %o4, 0x10, %i0
20136c8: 7f ff bb e2 call 2002650 <.umul>
20136cc: 90 0e a0 ff and %i2, 0xff, %o0
20136d0: c6 07 bf 84 ld [ %fp + -124 ], %g3
20136d4: 90 06 00 08 add %i0, %o0, %o0
20136d8: 86 00 c0 08 add %g3, %o0, %g3
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
20136dc: d0 26 e0 20 st %o0, [ %i3 + 0x20 ]
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
20136e0: a4 0c a0 ff and %l2, 0xff, %l2
20136e4: a2 0c 60 ff and %l1, 0xff, %l1
20136e8: a5 2c a0 08 sll %l2, 8, %l2
20136ec: a2 14 80 11 or %l2, %l1, %l1
20136f0: a3 2c 60 10 sll %l1, 0x10, %l1
20136f4: 80 a4 60 00 cmp %l1, 0
20136f8: 02 80 00 05 be 201370c <fat_init_volume_info+0x3a8>
20136fc: c6 26 e0 34 st %g3, [ %i3 + 0x34 ]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
2013700: a3 34 60 10 srl %l1, 0x10, %l1
2013704: 10 80 00 0d b 2013738 <fat_init_volume_info+0x3d4>
2013708: e2 26 e0 30 st %l1, [ %i3 + 0x30 ]
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
201370c: f4 0f bf 9a ldub [ %fp + -102 ], %i2
2013710: c2 0f bf 8f ldub [ %fp + -113 ], %g1
2013714: a0 0c 20 ff and %l0, 0xff, %l0
2013718: b2 0e 60 ff and %i1, 0xff, %i1
201371c: a1 2c 20 08 sll %l0, 8, %l0
2013720: b3 2e 60 10 sll %i1, 0x10, %i1
2013724: 85 28 60 18 sll %g1, 0x18, %g2
2013728: b2 14 00 19 or %l0, %i1, %i1
201372c: b4 16 40 1a or %i1, %i2, %i2
2013730: b4 16 80 02 or %i2, %g2, %i2
2013734: f4 26 e0 30 st %i2, [ %i3 + 0x30 ]
data_secs = vol->tot_secs - vol->data_fsec;
2013738: d0 06 e0 30 ld [ %i3 + 0x30 ], %o0
vol->data_cls = data_secs / vol->spc;
201373c: 92 0f 60 ff and %i5, 0xff, %o1
2013740: 7f ff bb fe call 2002738 <.udiv>
2013744: 90 22 00 03 sub %o0, %g3, %o0
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
2013748: 80 a2 2f f4 cmp %o0, 0xff4
201374c: 18 80 00 08 bgu 201376c <fat_init_volume_info+0x408>
2013750: d0 26 e0 38 st %o0, [ %i3 + 0x38 ]
{
vol->type = FAT_FAT12;
2013754: 84 10 20 01 mov 1, %g2
2013758: c4 2e e0 0e stb %g2, [ %i3 + 0xe ]
vol->mask = FAT_FAT12_MASK;
201375c: 84 10 2f ff mov 0xfff, %g2
2013760: c4 26 e0 10 st %g2, [ %i3 + 0x10 ]
vol->eoc_val = FAT_FAT12_EOC;
2013764: 10 80 00 0f b 20137a0 <fat_init_volume_info+0x43c>
2013768: 84 10 2f f8 mov 0xff8, %g2
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
201376c: 05 00 00 3f sethi %hi(0xfc00), %g2
2013770: 86 10 a3 f4 or %g2, 0x3f4, %g3 ! fff4 <PROM_START+0xfff4>
2013774: 80 a2 00 03 cmp %o0, %g3
2013778: 38 80 00 05 bgu,a 201378c <fat_init_volume_info+0x428>
201377c: 84 10 20 04 mov 4, %g2
{
vol->type = FAT_FAT16;
2013780: 86 10 20 02 mov 2, %g3
2013784: 10 80 00 04 b 2013794 <fat_init_volume_info+0x430>
2013788: c6 2e e0 0e stb %g3, [ %i3 + 0xe ]
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
201378c: c4 2e e0 0e stb %g2, [ %i3 + 0xe ]
vol->mask = FAT_FAT32_MASK;
2013790: 05 03 ff ff sethi %hi(0xffffc00), %g2
2013794: 86 10 a3 ff or %g2, 0x3ff, %g3 ! fffffff <RAM_END+0xdbfffff>
vol->eoc_val = FAT_FAT32_EOC;
2013798: 84 10 a3 f8 or %g2, 0x3f8, %g2
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
201379c: c6 26 e0 10 st %g3, [ %i3 + 0x10 ]
vol->eoc_val = FAT_FAT32_EOC;
20137a0: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
}
}
if (vol->type == FAT_FAT32)
20137a4: c4 0e e0 0e ldub [ %i3 + 0xe ], %g2
20137a8: 80 a0 a0 04 cmp %g2, 4
20137ac: 12 80 00 63 bne 2013938 <fat_init_volume_info+0x5d4>
20137b0: 82 10 3f ff mov -1, %g1
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
20137b4: c6 0f bf 9c ldub [ %fp + -100 ], %g3
20137b8: c4 0f bf 9b ldub [ %fp + -101 ], %g2
20137bc: 87 28 e0 08 sll %g3, 8, %g3
20137c0: 85 28 a0 10 sll %g2, 0x10, %g2
20137c4: c2 0f bf 97 ldub [ %fp + -105 ], %g1
20137c8: 84 10 c0 02 or %g3, %g2, %g2
20137cc: c6 0f bf 9d ldub [ %fp + -99 ], %g3
20137d0: 84 10 80 03 or %g2, %g3, %g2
20137d4: 87 28 60 18 sll %g1, 0x18, %g3
20137d8: 84 10 80 03 or %g2, %g3, %g2
20137dc: c4 26 e0 3c st %g2, [ %i3 + 0x3c ]
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
20137e0: 84 0f 3f 80 and %i4, -128, %g2
if (vol->mirror)
20137e4: 80 88 a0 80 btst 0x80, %g2
20137e8: 02 80 00 05 be 20137fc <fat_init_volume_info+0x498> <== ALWAYS TAKEN
20137ec: c4 2e e0 54 stb %g2, [ %i3 + 0x54 ]
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
20137f0: b8 0f 20 0f and %i4, 0xf, %i4 <== NOT EXECUTED
20137f4: 10 80 00 03 b 2013800 <fat_init_volume_info+0x49c> <== NOT EXECUTED
20137f8: f8 2e e0 5c stb %i4, [ %i3 + 0x5c ] <== NOT EXECUTED
else
vol->afat = 0;
20137fc: c0 2e e0 5c clrb [ %i3 + 0x5c ]
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
2013800: d2 0f bf 9e ldub [ %fp + -98 ], %o1
2013804: c4 0f bf 9f ldub [ %fp + -97 ], %g2
2013808: 93 2a 60 08 sll %o1, 8, %o1
201380c: 92 12 40 02 or %o1, %g2, %o1
2013810: d2 36 e0 40 sth %o1, [ %i3 + 0x40 ]
if( vol->info_sec == 0 )
2013814: 93 2a 60 10 sll %o1, 0x10, %o1
2013818: 93 32 60 10 srl %o1, 0x10, %o1
201381c: 80 a2 60 00 cmp %o1, 0
2013820: 32 80 00 03 bne,a 201382c <fat_init_volume_info+0x4c8> <== ALWAYS TAKEN
2013824: 90 10 00 1b mov %i3, %o0
2013828: 30 80 00 18 b,a 2013888 <fat_init_volume_info+0x524> <== NOT EXECUTED
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , 0,
201382c: 94 10 20 00 clr %o2
2013830: 96 10 20 04 mov 4, %o3
2013834: 7f ff fd f3 call 2013000 <_fat_block_read>
2013838: 98 07 bf a8 add %fp, -88, %o4
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
201383c: 80 a2 20 00 cmp %o0, 0
2013840: 06 80 00 22 bl 20138c8 <fat_init_volume_info+0x564> <== NEVER TAKEN
2013844: c4 0f bf aa ldub [ %fp + -86 ], %g2
{
close(vol->fd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
2013848: c6 0f bf a9 ldub [ %fp + -87 ], %g3
201384c: 85 28 a0 10 sll %g2, 0x10, %g2
2013850: 87 28 e0 08 sll %g3, 8, %g3
2013854: 86 10 c0 02 or %g3, %g2, %g3
2013858: c4 0f bf a8 ldub [ %fp + -88 ], %g2
201385c: 86 10 c0 02 or %g3, %g2, %g3
2013860: c4 0f bf ab ldub [ %fp + -85 ], %g2
2013864: 85 28 a0 18 sll %g2, 0x18, %g2
2013868: 86 10 c0 02 or %g3, %g2, %g3
201386c: 05 10 58 54 sethi %hi(0x41615000), %g2
2013870: 84 10 a2 52 or %g2, 0x252, %g2 ! 41615252 <RAM_END+0x3f215252>
2013874: 80 a0 c0 02 cmp %g3, %g2
2013878: 02 80 00 0a be 20138a0 <fat_init_volume_info+0x53c> <== ALWAYS TAKEN
201387c: 90 10 00 1b mov %i3, %o0
* 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);
2013880: 7f ff fd 3d call 2012d74 <fat_buf_release> <== NOT EXECUTED
2013884: 01 00 00 00 nop <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(fs_info);
close(vol->fd);
2013888: 7f ff c5 f6 call 2005060 <close> <== NOT EXECUTED
201388c: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
2013890: 40 00 1f 47 call 201b5ac <__errno> <== NOT EXECUTED
2013894: 01 00 00 00 nop <== NOT EXECUTED
2013898: 10 80 00 82 b 2013aa0 <fat_init_volume_info+0x73c> <== NOT EXECUTED
201389c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
20138a0: d2 16 e0 40 lduh [ %i3 + 0x40 ], %o1
20138a4: 94 10 21 e4 mov 0x1e4, %o2
20138a8: 96 10 20 0c mov 0xc, %o3
20138ac: 7f ff fd d5 call 2013000 <_fat_block_read>
20138b0: 98 07 bf a8 add %fp, -88, %o4
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
20138b4: 80 a2 20 00 cmp %o0, 0
20138b8: 16 80 00 08 bge 20138d8 <fat_init_volume_info+0x574> <== ALWAYS TAKEN
20138bc: c6 0f bf ad ldub [ %fp + -83 ], %g3
* 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);
20138c0: 7f ff fd 2d call 2012d74 <fat_buf_release> <== NOT EXECUTED
20138c4: 90 10 00 1b mov %i3, %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);
20138c8: 7f ff c5 e6 call 2005060 <close> <== NOT EXECUTED
20138cc: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
{
close(vol->fd);
free(fs_info->vhash);
free(fs_info->rhash);
free(fs_info->uino);
rtems_set_errno_and_return_minus_one( ENOMEM );
20138d0: 81 c7 e0 08 ret <== NOT EXECUTED
20138d4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
20138d8: c4 0f bf ae ldub [ %fp + -82 ], %g2
20138dc: 87 28 e0 08 sll %g3, 8, %g3
20138e0: 85 28 a0 10 sll %g2, 0x10, %g2
20138e4: 84 10 c0 02 or %g3, %g2, %g2
20138e8: c6 0f bf ac ldub [ %fp + -84 ], %g3
20138ec: 84 10 80 03 or %g2, %g3, %g2
20138f0: c6 0f bf af ldub [ %fp + -81 ], %g3
20138f4: 87 28 e0 18 sll %g3, 0x18, %g3
20138f8: 84 10 80 03 or %g2, %g3, %g2
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
20138fc: c6 0f bf b1 ldub [ %fp + -79 ], %g3
_fat_block_release(fs_info);
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
2013900: c4 26 e0 48 st %g2, [ %i3 + 0x48 ]
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->free_cls = vol->free_cls_in_fs_info;
2013904: c4 26 e0 44 st %g2, [ %i3 + 0x44 ]
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
2013908: c4 0f bf b2 ldub [ %fp + -78 ], %g2
201390c: 87 28 e0 08 sll %g3, 8, %g3
2013910: 85 28 a0 10 sll %g2, 0x10, %g2
2013914: 84 10 c0 02 or %g3, %g2, %g2
2013918: c6 0f bf b0 ldub [ %fp + -80 ], %g3
201391c: 84 10 80 03 or %g2, %g3, %g2
2013920: c6 0f bf b3 ldub [ %fp + -77 ], %g3
2013924: 87 28 e0 18 sll %g3, 0x18, %g3
2013928: 84 10 80 03 or %g2, %g3, %g2
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
201392c: c4 26 e0 50 st %g2, [ %i3 + 0x50 ]
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
vol->next_cl = vol->next_cl_in_fs_info;
2013930: 10 80 00 07 b 201394c <fat_init_volume_info+0x5e8>
2013934: c4 26 e0 4c st %g2, [ %i3 + 0x4c ]
}
}
}
else
{
vol->rdir_cl = 0;
2013938: c0 26 e0 3c clr [ %i3 + 0x3c ]
vol->mirror = 0;
201393c: c0 2e e0 54 clrb [ %i3 + 0x54 ]
vol->afat = 0;
2013940: c0 2e e0 5c clrb [ %i3 + 0x5c ]
vol->free_cls = FAT_UNDEFINED_VALUE;
2013944: c2 26 e0 44 st %g1, [ %i3 + 0x44 ]
vol->next_cl = FAT_UNDEFINED_VALUE;
2013948: c2 26 e0 4c st %g1, [ %i3 + 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);
201394c: 7f ff fd 0a call 2012d74 <fat_buf_release>
2013950: 90 10 00 1b mov %i3, %o0
vol->next_cl = FAT_UNDEFINED_VALUE;
}
_fat_block_release(fs_info);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
2013954: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
2013958: 7f ff bb 3e call 2002650 <.umul>
201395c: d0 0e e0 5c ldub [ %i3 + 0x5c ], %o0
2013960: c4 16 e0 18 lduh [ %i3 + 0x18 ], %g2
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
2013964: 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;
2013968: 90 02 00 02 add %o0, %g2, %o0
201396c: d0 26 e0 58 st %o0, [ %i3 + 0x58 ]
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
2013970: 7f ff c5 a5 call 2005004 <calloc>
2013974: 90 10 20 02 mov 2, %o0
if ( fs_info->vhash == NULL )
2013978: 80 a2 20 00 cmp %o0, 0
201397c: 02 80 00 12 be 20139c4 <fat_init_volume_info+0x660> <== NEVER TAKEN
2013980: d0 26 e0 6c st %o0, [ %i3 + 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 );
2013984: 84 02 20 04 add %o0, 4, %g2
2013988: 86 02 20 10 add %o0, 0x10, %g3
head->next = tail;
201398c: c4 22 00 00 st %g2, [ %o0 ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
2013990: 84 02 20 0c add %o0, 0xc, %g2
head->next = tail;
head->previous = NULL;
2013994: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
2013998: 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;
201399c: c6 22 20 0c st %g3, [ %o0 + 0xc ]
head->previous = NULL;
20139a0: c0 22 20 10 clr [ %o0 + 0x10 ]
tail->previous = head;
20139a4: 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));
20139a8: 92 10 20 0c mov 0xc, %o1
20139ac: 7f ff c5 96 call 2005004 <calloc>
20139b0: 90 10 20 02 mov 2, %o0
if ( fs_info->rhash == NULL )
20139b4: 80 a2 20 00 cmp %o0, 0
20139b8: 12 80 00 06 bne 20139d0 <fat_init_volume_info+0x66c> <== ALWAYS TAKEN
20139bc: d0 26 e0 70 st %o0, [ %i3 + 0x70 ]
20139c0: 30 80 00 1c b,a 2013a30 <fat_init_volume_info+0x6cc> <== 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);
20139c4: 7f ff c5 a7 call 2005060 <close> <== NOT EXECUTED
20139c8: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
20139cc: 30 80 00 32 b,a 2013a94 <fat_init_volume_info+0x730> <== 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 );
20139d0: 84 02 20 04 add %o0, 4, %g2
head->next = tail;
20139d4: c4 22 00 00 st %g2, [ %o0 ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
20139d8: 84 02 20 0c add %o0, 0xc, %g2
head->next = tail;
head->previous = NULL;
20139dc: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
20139e0: c4 22 20 14 st %g2, [ %o0 + 0x14 ]
20139e4: 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;
20139e8: c0 22 20 10 clr [ %o0 + 0x10 ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
20139ec: 86 02 20 10 add %o0, 0x10, %g3
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
20139f0: 84 10 21 00 mov 0x100, %g2
head->next = tail;
20139f4: c6 22 20 0c st %g3, [ %o0 + 0xc ]
20139f8: c4 26 e0 7c st %g2, [ %i3 + 0x7c ]
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
20139fc: c6 06 e0 30 ld [ %i3 + 0x30 ], %g3
2013a00: c4 0e e0 03 ldub [ %i3 + 3 ], %g2
fs_info->index = 0;
2013a04: c0 26 e0 78 clr [ %i3 + 0x78 ]
}
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;
2013a08: 85 28 c0 02 sll %g3, %g2, %g2
2013a0c: 85 28 a0 04 sll %g2, 4, %g2
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
2013a10: 90 10 21 00 mov 0x100, %o0
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
2013a14: c4 26 e0 80 st %g2, [ %i3 + 0x80 ]
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
2013a18: 7f ff c5 7b call 2005004 <calloc>
2013a1c: 92 10 20 01 mov 1, %o1
if ( fs_info->uino == NULL )
2013a20: 80 a2 20 00 cmp %o0, 0
2013a24: 12 80 00 0d bne 2013a58 <fat_init_volume_info+0x6f4> <== ALWAYS TAKEN
2013a28: d0 26 e0 74 st %o0, [ %i3 + 0x74 ]
2013a2c: 30 80 00 05 b,a 2013a40 <fat_init_volume_info+0x6dc> <== 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);
2013a30: 7f ff c5 8c call 2005060 <close> <== NOT EXECUTED
2013a34: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
2013a38: 10 80 00 15 b 2013a8c <fat_init_volume_info+0x728> <== NOT EXECUTED
2013a3c: d0 06 e0 6c ld [ %i3 + 0x6c ], %o0 <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
if ( fs_info->uino == NULL )
{
close(vol->fd);
2013a40: 7f ff c5 88 call 2005060 <close> <== NOT EXECUTED
2013a44: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
2013a48: 7f ff c6 43 call 2005354 <free> <== NOT EXECUTED
2013a4c: d0 06 e0 6c ld [ %i3 + 0x6c ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
2013a50: 10 80 00 0f b 2013a8c <fat_init_volume_info+0x728> <== NOT EXECUTED
2013a54: d0 06 e0 70 ld [ %i3 + 0x70 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
2013a58: d0 16 c0 00 lduh [ %i3 ], %o0
2013a5c: 7f ff c5 6a call 2005004 <calloc>
2013a60: 92 10 20 01 mov 1, %o1
if (fs_info->sec_buf == NULL)
2013a64: 80 a2 20 00 cmp %o0, 0
2013a68: 12 80 00 11 bne 2013aac <fat_init_volume_info+0x748> <== ALWAYS TAKEN
2013a6c: d0 26 e0 90 st %o0, [ %i3 + 0x90 ]
{
close(vol->fd);
2013a70: 7f ff c5 7c call 2005060 <close> <== NOT EXECUTED
2013a74: d0 06 e0 60 ld [ %i3 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
2013a78: 7f ff c6 37 call 2005354 <free> <== NOT EXECUTED
2013a7c: d0 06 e0 6c ld [ %i3 + 0x6c ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
2013a80: 7f ff c6 35 call 2005354 <free> <== NOT EXECUTED
2013a84: d0 06 e0 70 ld [ %i3 + 0x70 ], %o0 <== NOT EXECUTED
free(fs_info->uino);
2013a88: d0 06 e0 74 ld [ %i3 + 0x74 ], %o0 <== NOT EXECUTED
2013a8c: 7f ff c6 32 call 2005354 <free> <== NOT EXECUTED
2013a90: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
2013a94: 40 00 1e c6 call 201b5ac <__errno> <== NOT EXECUTED
2013a98: 01 00 00 00 nop <== NOT EXECUTED
2013a9c: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
2013aa0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2013aa4: 81 c7 e0 08 ret <== NOT EXECUTED
2013aa8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
return bytes_written;
}
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{
return (sec_num & (vol->spc - 1)) == 0;
2013aac: c4 0e e0 04 ldub [ %i3 + 4 ], %g2
2013ab0: c6 06 e0 34 ld [ %i3 + 0x34 ], %g3
2013ab4: 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)
2013ab8: 80 88 80 03 btst %g2, %g3
2013abc: 22 80 00 04 be,a 2013acc <fat_init_volume_info+0x768> <== ALWAYS TAKEN
2013ac0: c6 0e e0 0e ldub [ %i3 + 0xe ], %g3
vol->bytes_per_block_log2 = vol->bpc_log2;
vol->sectors_per_block = vol->spc;
}
}
return RC_OK;
2013ac4: 81 c7 e0 08 ret <== NOT EXECUTED
2013ac8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
* 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)))
2013acc: 80 a0 e0 04 cmp %g3, 4
2013ad0: 22 80 00 07 be,a 2013aec <fat_init_volume_info+0x788>
2013ad4: d0 06 e0 64 ld [ %i3 + 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;
2013ad8: c6 06 e0 20 ld [ %i3 + 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)))
2013adc: 80 88 80 03 btst %g2, %g3
2013ae0: 12 80 00 0f bne 2013b1c <fat_init_volume_info+0x7b8> <== NEVER TAKEN
2013ae4: b0 10 20 00 clr %i0
{
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
2013ae8: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0
2013aec: d2 16 e0 06 lduh [ %i3 + 6 ], %o1
2013af0: 7f ff f6 78 call 20114d0 <rtems_bdbuf_set_block_size>
2013af4: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
2013af8: 80 a2 20 00 cmp %o0, 0
2013afc: 12 80 00 08 bne 2013b1c <fat_init_volume_info+0x7b8> <== NEVER TAKEN
2013b00: b0 10 20 00 clr %i0
{
vol->bytes_per_block = vol->bpc;
2013b04: c4 16 e0 06 lduh [ %i3 + 6 ], %g2
2013b08: c4 36 e0 0a sth %g2, [ %i3 + 0xa ]
vol->bytes_per_block_log2 = vol->bpc_log2;
2013b0c: c4 0e e0 08 ldub [ %i3 + 8 ], %g2
2013b10: c4 2e e0 0c stb %g2, [ %i3 + 0xc ]
vol->sectors_per_block = vol->spc;
2013b14: c4 0e e0 04 ldub [ %i3 + 4 ], %g2
2013b18: c4 2e e0 09 stb %g2, [ %i3 + 9 ]
}
}
return RC_OK;
}
2013b1c: 81 c7 e0 08 ret
2013b20: 81 e8 00 00 restore
02019a74 <fat_scan_fat_for_free_clusters>:
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
2019a74: 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;
2019a78: e8 06 20 38 ld [ %i0 + 0x38 ], %l4
bool zero_fill
)
{
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
2019a7c: 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;
2019a80: c0 26 c0 00 clr [ %i3 ]
if (count == 0)
2019a84: 80 a6 a0 00 cmp %i2, 0
2019a88: 02 80 00 7e be 2019c80 <fat_scan_fat_for_free_clusters+0x20c><== NEVER TAKEN
2019a8c: a2 10 20 00 clr %l1
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
2019a90: e0 06 20 4c ld [ %i0 + 0x4c ], %l0
2019a94: 80 a4 3f ff cmp %l0, -1
2019a98: 22 80 00 02 be,a 2019aa0 <fat_scan_fat_for_free_clusters+0x2c>
2019a9c: 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;
2019aa0: a8 05 20 02 add %l4, 2, %l4
2019aa4: a6 10 20 02 mov 2, %l3
2019aa8: 10 80 00 5a b 2019c10 <fat_scan_fat_for_free_clusters+0x19c>
2019aac: a4 10 20 00 clr %l2
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
2019ab0: 92 10 00 10 mov %l0, %o1
2019ab4: 7f ff fe ae call 201956c <fat_get_fat_cluster>
2019ab8: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2019abc: a2 92 20 00 orcc %o0, 0, %l1
2019ac0: 02 80 00 0b be 2019aec <fat_scan_fat_for_free_clusters+0x78><== ALWAYS TAKEN
2019ac4: c2 07 bf fc ld [ %fp + -4 ], %g1
{
if (*cls_added != 0)
2019ac8: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
2019acc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2019ad0: 22 80 00 6d be,a 2019c84 <fat_scan_fat_for_free_clusters+0x210><== NOT EXECUTED
2019ad4: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
2019ad8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2019adc: 7f ff ff b7 call 20199b8 <fat_free_fat_clusters_chain> <== NOT EXECUTED
2019ae0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
2019ae4: 81 c7 e0 08 ret <== NOT EXECUTED
2019ae8: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
if (*cls_added != 0)
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
2019aec: 80 a0 60 00 cmp %g1, 0
2019af0: 32 80 00 44 bne,a 2019c00 <fat_scan_fat_for_free_clusters+0x18c>
2019af4: 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)
2019af8: c2 06 c0 00 ld [ %i3 ], %g1
2019afc: 80 a0 60 00 cmp %g1, 0
2019b00: 12 80 00 0e bne 2019b38 <fat_scan_fat_for_free_clusters+0xc4>
2019b04: 90 10 00 18 mov %i0, %o0
{
*chain = cl4find;
2019b08: e0 26 40 00 st %l0, [ %i1 ]
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
2019b0c: 92 10 00 10 mov %l0, %o1
2019b10: 7f ff ff 09 call 2019734 <fat_set_fat_cluster>
2019b14: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
2019b18: 80 a2 20 00 cmp %o0, 0
2019b1c: 32 80 00 59 bne,a 2019c80 <fat_scan_fat_for_free_clusters+0x20c><== NEVER TAKEN
2019b20: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
if ( rc != RC_OK )
goto cleanup;
}
if (zero_fill)
2019b24: 80 a7 60 00 cmp %i5, 0
2019b28: 22 80 00 18 be,a 2019b88 <fat_scan_fat_for_free_clusters+0x114>
2019b2c: c2 06 c0 00 ld [ %i3 ], %g1
{
bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
2019b30: 10 80 00 1c b 2019ba0 <fat_scan_fat_for_free_clusters+0x12c>
2019b34: d6 16 20 06 lduh [ %i0 + 6 ], %o3
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
2019b38: 92 10 00 10 mov %l0, %o1
2019b3c: 7f ff fe fe call 2019734 <fat_set_fat_cluster>
2019b40: 94 10 3f ff mov -1, %o2
2019b44: aa 10 00 08 mov %o0, %l5
if ( rc != RC_OK )
2019b48: 80 a5 60 00 cmp %l5, 0
2019b4c: 02 80 00 07 be 2019b68 <fat_scan_fat_for_free_clusters+0xf4><== ALWAYS TAKEN
2019b50: 90 10 00 18 mov %i0, %o0
{
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
2019b54: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2019b58: 7f ff ff 98 call 20199b8 <fat_free_fat_clusters_chain> <== NOT EXECUTED
2019b5c: a2 10 00 15 mov %l5, %l1 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
2019b60: 81 c7 e0 08 ret <== NOT EXECUTED
2019b64: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
}
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
2019b68: 92 10 00 12 mov %l2, %o1
2019b6c: 7f ff fe f2 call 2019734 <fat_set_fat_cluster>
2019b70: 94 10 00 10 mov %l0, %o2
if ( rc != RC_OK )
2019b74: a4 92 20 00 orcc %o0, 0, %l2
2019b78: 02 bf ff ec be 2019b28 <fat_scan_fat_for_free_clusters+0xb4><== ALWAYS TAKEN
2019b7c: 80 a7 60 00 cmp %i5, 0
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
2019b80: 10 80 00 35 b 2019c54 <fat_scan_fat_for_free_clusters+0x1e0><== NOT EXECUTED
2019b84: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
goto cleanup;
}
}
save_cln = cl4find;
(*cls_added)++;
2019b88: 82 00 60 01 inc %g1
/* have we satisfied request ? */
if (*cls_added == count)
2019b8c: 80 a0 40 1a cmp %g1, %i2
2019b90: 02 80 00 0f be 2019bcc <fat_scan_fat_for_free_clusters+0x158>
2019b94: c2 26 c0 00 st %g1, [ %i3 ]
2019b98: 10 80 00 19 b 2019bfc <fat_scan_fat_for_free_clusters+0x188>
2019b9c: a4 10 00 10 mov %l0, %l2
goto cleanup;
}
if (zero_fill)
{
bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
2019ba0: 90 10 00 18 mov %i0, %o0
2019ba4: 92 10 00 10 mov %l0, %o1
2019ba8: 94 10 20 00 clr %o2
2019bac: 7f ff e5 5b call 2013118 <fat_cluster_set>
2019bb0: 98 10 20 00 clr %o4
if (fs_info->vol.bpc != bytes_written)
2019bb4: c2 16 20 06 lduh [ %i0 + 6 ], %g1
2019bb8: 80 a0 40 08 cmp %g1, %o0
2019bbc: 22 bf ff f3 be,a 2019b88 <fat_scan_fat_for_free_clusters+0x114><== ALWAYS TAKEN
2019bc0: c2 06 c0 00 ld [ %i3 ], %g1
{
rc = -1;
2019bc4: 10 80 00 23 b 2019c50 <fat_scan_fat_for_free_clusters+0x1dc><== NOT EXECUTED
2019bc8: a4 10 3f ff mov -1, %l2 <== 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)
2019bcc: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
2019bd0: 80 a0 7f ff cmp %g1, -1
2019bd4: 02 80 00 05 be 2019be8 <fat_scan_fat_for_free_clusters+0x174><== ALWAYS TAKEN
2019bd8: e0 26 20 4c st %l0, [ %i0 + 0x4c ]
fs_info->vol.free_cls -= (*cls_added);
2019bdc: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
2019be0: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
2019be4: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*last_cl = save_cln;
2019be8: e0 27 00 00 st %l0, [ %i4 ]
fat_buf_release(fs_info);
2019bec: 7f ff e4 62 call 2012d74 <fat_buf_release>
2019bf0: 90 10 00 18 mov %i0, %o0
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
2019bf4: 81 c7 e0 08 ret
2019bf8: 91 e8 00 11 restore %g0, %l1, %o0
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
2019bfc: a0 04 20 01 inc %l0
if (cl4find >= data_cls_val)
2019c00: 80 a4 00 14 cmp %l0, %l4
2019c04: 0a 80 00 03 bcs 2019c10 <fat_scan_fat_for_free_clusters+0x19c><== ALWAYS TAKEN
2019c08: a6 04 e0 01 inc %l3
cl4find = 2;
2019c0c: 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)
2019c10: 80 a4 c0 14 cmp %l3, %l4
2019c14: 0a bf ff a7 bcs 2019ab0 <fat_scan_fat_for_free_clusters+0x3c><== ALWAYS TAKEN
2019c18: 90 10 00 18 mov %i0, %o0
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
2019c1c: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
2019c20: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
2019c24: 02 80 00 05 be 2019c38 <fat_scan_fat_for_free_clusters+0x1c4><== NOT EXECUTED
2019c28: e4 26 20 4c st %l2, [ %i0 + 0x4c ] <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
2019c2c: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
2019c30: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
2019c34: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*last_cl = save_cln;
2019c38: e4 27 00 00 st %l2, [ %i4 ] <== NOT EXECUTED
fat_buf_release(fs_info);
2019c3c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2019c40: 7f ff e4 4d call 2012d74 <fat_buf_release> <== NOT EXECUTED
2019c44: a2 10 20 00 clr %l1 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
2019c48: 81 c7 e0 08 ret <== NOT EXECUTED
2019c4c: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
2019c50: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2019c54: 7f ff ff 59 call 20199b8 <fat_free_fat_clusters_chain> <== NOT EXECUTED
2019c58: 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);
2019c5c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2019c60: 94 10 20 00 clr %o2 <== NOT EXECUTED
2019c64: 7f ff fe b4 call 2019734 <fat_set_fat_cluster> <== NOT EXECUTED
2019c68: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
fat_buf_release(fs_info);
2019c6c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2019c70: 7f ff e4 41 call 2012d74 <fat_buf_release> <== NOT EXECUTED
2019c74: a2 10 00 12 mov %l2, %l1 <== NOT EXECUTED
return rc;
}
2019c78: 81 c7 e0 08 ret <== NOT EXECUTED
2019c7c: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
2019c80: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
2019c84: 81 c7 e0 08 ret <== NOT EXECUTED
2019c88: 81 e8 00 00 restore <== NOT EXECUTED
02013080 <fat_sector_write>:
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
2013080: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
ssize_t cmpltd = 0;
2013084: a0 10 20 00 clr %l0
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
2013088: 10 80 00 1b b 20130f4 <fat_sector_write+0x74>
201308c: a2 10 20 01 mov 1, %l1
{
c = MIN(count, (fs_info->vol.bps - ofs));
2013090: ba 27 40 1a sub %i5, %i2, %i5
2013094: 80 a7 40 1b cmp %i5, %i3
2013098: 38 80 00 02 bgu,a 20130a0 <fat_sector_write+0x20>
201309c: ba 10 00 1b mov %i3, %i5
if (c == fs_info->vol.bytes_per_block)
20130a0: c2 16 20 0a lduh [ %i0 + 0xa ], %g1
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
20130a4: 90 10 00 18 mov %i0, %o0
20130a8: 92 10 00 19 mov %i1, %o1
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bytes_per_block)
20130ac: 80 a7 40 01 cmp %i5, %g1
20130b0: 02 80 00 03 be 20130bc <fat_sector_write+0x3c> <== NEVER TAKEN
20130b4: 94 10 20 02 mov 2, %o2
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);
20130b8: 94 10 20 01 mov 1, %o2
20130bc: 7f ff ff a2 call 2012f44 <fat_buf_access>
20130c0: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
20130c4: 80 a2 20 00 cmp %o0, 0
20130c8: 12 80 00 10 bne 2013108 <fat_sector_write+0x88> <== NEVER TAKEN
20130cc: d0 07 bf fc ld [ %fp + -4 ], %o0
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
20130d0: 92 07 00 10 add %i4, %l0, %o1
20130d4: 90 02 00 1a add %o0, %i2, %o0
20130d8: 94 10 00 1d mov %i5, %o2
20130dc: 40 00 23 f3 call 201c0a8 <memcpy>
20130e0: b6 26 c0 1d sub %i3, %i5, %i3
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
20130e4: a0 07 40 10 add %i5, %l0, %l0
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
20130e8: e2 2e 20 88 stb %l1, [ %i0 + 0x88 ]
sec_num++;
20130ec: b2 06 60 01 inc %i1
ofs = 0;
20130f0: b4 10 20 00 clr %i2
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
20130f4: 80 a6 e0 00 cmp %i3, 0
20130f8: 32 bf ff e6 bne,a 2013090 <fat_sector_write+0x10>
20130fc: fa 16 00 00 lduh [ %i0 ], %i5
cmpltd +=c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
2013100: 81 c7 e0 08 ret
2013104: 91 e8 00 10 restore %g0, %l0, %o0
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)
return -1;
2013108: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
cmpltd +=c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
201310c: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
2013110: 81 c7 e0 08 ret <== NOT EXECUTED
2013114: 81 e8 00 00 restore <== NOT EXECUTED
02019734 <fat_set_fat_cluster>:
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
2019734: 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;
2019738: c0 27 bf fc clr [ %fp + -4 ]
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
201973c: 80 a6 60 01 cmp %i1, 1
2019740: 08 80 00 98 bleu 20199a0 <fat_set_fat_cluster+0x26c> <== NEVER TAKEN
2019744: ba 10 00 18 mov %i0, %i5
2019748: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
201974c: 82 00 60 01 inc %g1
2019750: 80 a6 40 01 cmp %i1, %g1
2019754: 28 80 00 03 bleu,a 2019760 <fat_set_fat_cluster+0x2c> <== ALWAYS TAKEN
2019758: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
201975c: 30 80 00 91 b,a 20199a0 <fat_set_fat_cluster+0x26c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
2019760: 84 08 60 01 and %g1, 1, %g2
2019764: 80 88 a0 ff btst 0xff, %g2
2019768: 02 80 00 05 be 201977c <fat_set_fat_cluster+0x48>
201976c: 86 08 60 02 and %g1, 2, %g3
2019770: a1 36 60 01 srl %i1, 1, %l0
2019774: 10 80 00 06 b 201978c <fat_set_fat_cluster+0x58>
2019778: a0 04 00 19 add %l0, %i1, %l0
201977c: 80 88 e0 ff btst 0xff, %g3
2019780: 02 80 00 03 be 201978c <fat_set_fat_cluster+0x58>
2019784: a1 2e 60 02 sll %i1, 2, %l0
2019788: a1 2e 60 01 sll %i1, 1, %l0
201978c: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
2019790: 80 88 a0 ff btst 0xff, %g2
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
2019794: a1 34 00 03 srl %l0, %g3, %l0
2019798: c6 07 60 58 ld [ %i5 + 0x58 ], %g3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
201979c: 02 80 00 05 be 20197b0 <fat_set_fat_cluster+0x7c>
20197a0: a0 04 00 03 add %l0, %g3, %l0
20197a4: b7 36 60 01 srl %i1, 1, %i3
20197a8: 10 80 00 07 b 20197c4 <fat_set_fat_cluster+0x90>
20197ac: b6 06 c0 19 add %i3, %i1, %i3
20197b0: 82 08 60 02 and %g1, 2, %g1
20197b4: 80 88 60 ff btst 0xff, %g1
20197b8: 02 80 00 03 be 20197c4 <fat_set_fat_cluster+0x90>
20197bc: b7 2e 60 02 sll %i1, 2, %i3
20197c0: b7 2e 60 01 sll %i1, 1, %i3
20197c4: f8 17 40 00 lduh [ %i5 ], %i4
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
20197c8: 90 10 00 1d mov %i5, %o0
20197cc: 92 10 00 10 mov %l0, %o1
20197d0: 94 10 20 01 mov 1, %o2
20197d4: 7f ff e5 dc call 2012f44 <fat_buf_access>
20197d8: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
20197dc: b0 92 20 00 orcc %o0, 0, %i0
20197e0: 12 80 00 4c bne 2019910 <fat_set_fat_cluster+0x1dc> <== NEVER TAKEN
20197e4: b9 2f 20 10 sll %i4, 0x10, %i4
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
20197e8: b9 37 20 10 srl %i4, 0x10, %i4
20197ec: b8 07 3f ff add %i4, -1, %i4
20197f0: b8 0e c0 1c and %i3, %i4, %i4
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
20197f4: f6 0f 60 0e ldub [ %i5 + 0xe ], %i3
20197f8: 80 a6 e0 02 cmp %i3, 2
20197fc: 02 80 00 53 be 2019948 <fat_set_fat_cluster+0x214>
2019800: 80 a6 e0 04 cmp %i3, 4
2019804: 02 80 00 5b be 2019970 <fat_set_fat_cluster+0x23c>
2019808: 80 a6 e0 01 cmp %i3, 1
201980c: 12 80 00 65 bne 20199a0 <fat_set_fat_cluster+0x26c> <== NEVER TAKEN
2019810: 80 8e 60 01 btst 1, %i1
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
2019814: 02 80 00 23 be 20198a0 <fat_set_fat_cluster+0x16c>
2019818: c2 07 bf fc ld [ %fp + -4 ], %g1
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*(sec_buf + ofs) &= 0x0F;
201981c: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
2019820: 84 08 a0 0f and %g2, 0xf, %g2
2019824: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
2019828: c2 07 bf fc ld [ %fp + -4 ], %g1
201982c: 85 2e a0 04 sll %i2, 4, %g2
2019830: c6 08 40 1c ldub [ %g1 + %i4 ], %g3
2019834: 84 10 c0 02 or %g3, %g2, %g2
2019838: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
201983c: c2 17 40 00 lduh [ %i5 ], %g1
2019840: 82 00 7f ff add %g1, -1, %g1
2019844: 80 a7 00 01 cmp %i4, %g1
2019848: 12 80 00 0f bne 2019884 <fat_set_fat_cluster+0x150> <== ALWAYS TAKEN
201984c: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
2019850: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2019854: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
2019858: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
201985c: 7f ff e5 ba call 2012f44 <fat_buf_access> <== NOT EXECUTED
2019860: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
2019864: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2019868: 12 80 00 2a bne 2019910 <fat_set_fat_cluster+0x1dc> <== NOT EXECUTED
201986c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*sec_buf &= 0x00;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
2019870: b5 2e a0 14 sll %i2, 0x14, %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 &= 0x00;
2019874: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
2019878: b5 36 a0 18 srl %i2, 0x18, %i2 <== NOT EXECUTED
201987c: 10 80 00 21 b 2019900 <fat_set_fat_cluster+0x1cc> <== NOT EXECUTED
2019880: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0x00;
2019884: c2 07 bf fc ld [ %fp + -4 ], %g1
2019888: b8 07 20 01 inc %i4
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
201988c: b5 2e a0 14 sll %i2, 0x14, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0x00;
2019890: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
2019894: b5 36 a0 18 srl %i2, 0x18, %i2
2019898: 10 80 00 27 b 2019934 <fat_set_fat_cluster+0x200>
201989c: c2 07 bf fc ld [ %fp + -4 ], %g1
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*(sec_buf + ofs) &= 0x00;
20198a0: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
20198a4: c2 07 bf fc ld [ %fp + -4 ], %g1
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
20198a8: b4 0e af ff and %i2, 0xfff, %i2
*(sec_buf + ofs) &= 0x00;
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
20198ac: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
20198b0: 84 10 80 1a or %g2, %i2, %g2
20198b4: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
20198b8: c2 17 40 00 lduh [ %i5 ], %g1
20198bc: 82 00 7f ff add %g1, -1, %g1
20198c0: 80 a7 00 01 cmp %i4, %g1
20198c4: 12 80 00 15 bne 2019918 <fat_set_fat_cluster+0x1e4> <== ALWAYS TAKEN
20198c8: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
20198cc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20198d0: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
20198d4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
20198d8: 7f ff e5 9b call 2012f44 <fat_buf_access> <== NOT EXECUTED
20198dc: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
20198e0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
20198e4: 12 80 00 0b bne 2019910 <fat_set_fat_cluster+0x1dc> <== NOT EXECUTED
20198e8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*sec_buf &= 0xF0;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
20198ec: 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;
20198f0: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
20198f4: 84 08 bf f0 and %g2, -16, %g2 <== NOT EXECUTED
20198f8: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
20198fc: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
2019900: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
2019904: b4 16 80 02 or %i2, %g2, %i2 <== NOT EXECUTED
2019908: f4 28 40 00 stb %i2, [ %g1 ] <== NOT EXECUTED
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
201990c: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ] <== NOT EXECUTED
2019910: 81 c7 e0 08 ret <== NOT EXECUTED
2019914: 81 e8 00 00 restore <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
2019918: c2 07 bf fc ld [ %fp + -4 ], %g1
201991c: b8 07 20 01 inc %i4
2019920: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
2019924: b5 36 a0 08 srl %i2, 8, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
2019928: 84 08 bf f0 and %g2, -16, %g2
201992c: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
2019930: c2 07 bf fc ld [ %fp + -4 ], %g1
2019934: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
2019938: b4 10 80 1a or %g2, %i2, %i2
201993c: f4 28 40 1c stb %i2, [ %g1 + %i4 ]
2019940: 81 c7 e0 08 ret
2019944: 81 e8 00 00 restore
break;
}
return RC_OK;
}
2019948: 03 00 00 3f sethi %hi(0xfc00), %g1
201994c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2019950: 82 0e 80 01 and %i2, %g1, %g1
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
(uint16_t )(CT_LE_W(in_val));
2019954: 83 28 60 08 sll %g1, 8, %g1
2019958: b5 2e a0 10 sll %i2, 0x10, %i2
201995c: b5 36 a0 18 srl %i2, 0x18, %i2
2019960: b4 10 40 1a or %g1, %i2, %i2
}
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
2019964: c2 07 bf fc ld [ %fp + -4 ], %g1
2019968: 10 80 00 0a b 2019990 <fat_set_fat_cluster+0x25c>
201996c: f4 30 40 1c sth %i2, [ %g1 + %i4 ]
(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));
2019970: 11 3c 00 00 sethi %hi(0xf0000000), %o0
2019974: 7f ff fe f2 call 201953c <CPU_swap_u32>
2019978: 90 2e 80 08 andn %i2, %o0, %o0
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
201997c: c2 07 bf fc ld [ %fp + -4 ], %g1
2019980: c4 00 40 1c ld [ %g1 + %i4 ], %g2
2019984: 84 08 a0 f0 and %g2, 0xf0, %g2
*((uint32_t *)(sec_buf + ofs)) |= fat32_clv;
2019988: 90 12 00 02 or %o0, %g2, %o0
201998c: d0 20 40 1c st %o0, [ %g1 + %i4 ]
2019990: 82 10 20 01 mov 1, %g1
2019994: c2 2f 60 88 stb %g1, [ %i5 + 0x88 ]
2019998: 81 c7 e0 08 ret
201999c: 81 e8 00 00 restore
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
20199a0: 40 00 07 03 call 201b5ac <__errno> <== NOT EXECUTED
20199a4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20199a8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20199ac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
break;
}
return RC_OK;
}
20199b0: 81 c7 e0 08 ret <== NOT EXECUTED
20199b4: 81 e8 00 00 restore <== NOT EXECUTED
02013bf4 <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)
{
2013bf4: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
int i = 0;
rc = fat_sync(fs_info);
2013bf8: 90 10 00 18 mov %i0, %o0
2013bfc: 7f ff ff ca call 2013b24 <fat_sync>
2013c00: ba 10 00 18 mov %i0, %i5
if ( rc != RC_OK )
2013c04: b0 92 20 00 orcc %o0, 0, %i0
2013c08: 32 80 00 02 bne,a 2013c10 <fat_shutdown_drive+0x1c> <== NEVER TAKEN
2013c0c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
2013c10: b8 10 20 00 clr %i4
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
2013c14: f6 07 60 6c ld [ %i5 + 0x6c ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
2013c18: 10 80 00 04 b 2013c28 <fat_shutdown_drive+0x34>
2013c1c: b6 06 c0 1c add %i3, %i4, %i3
free(node);
2013c20: 7f ff c5 cd call 2005354 <free> <== NOT EXECUTED
2013c24: 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 );
2013c28: 7f ff d9 ed call 200a3dc <_Chain_Get>
2013c2c: 90 10 00 1b mov %i3, %o0
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
2013c30: 80 a2 20 00 cmp %o0, 0
2013c34: 12 bf ff fb bne 2013c20 <fat_shutdown_drive+0x2c> <== NEVER TAKEN
2013c38: 01 00 00 00 nop
2013c3c: b8 07 20 0c add %i4, 0xc, %i4
rc = fat_sync(fs_info);
if ( rc != RC_OK )
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
2013c40: 80 a7 20 18 cmp %i4, 0x18
2013c44: 32 bf ff f5 bne,a 2013c18 <fat_shutdown_drive+0x24>
2013c48: f6 07 60 6c ld [ %i5 + 0x6c ], %i3
2013c4c: b8 10 20 00 clr %i4
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
2013c50: f6 07 60 70 ld [ %i5 + 0x70 ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
2013c54: 10 80 00 04 b 2013c64 <fat_shutdown_drive+0x70>
2013c58: b6 06 c0 1c add %i3, %i4, %i3
free(node);
2013c5c: 7f ff c5 be call 2005354 <free> <== NOT EXECUTED
2013c60: 01 00 00 00 nop <== NOT EXECUTED
2013c64: 7f ff d9 de call 200a3dc <_Chain_Get>
2013c68: 90 10 00 1b mov %i3, %o0
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
2013c6c: 80 a2 20 00 cmp %o0, 0
2013c70: 12 bf ff fb bne 2013c5c <fat_shutdown_drive+0x68> <== NEVER TAKEN
2013c74: 01 00 00 00 nop
2013c78: b8 07 20 0c add %i4, 0xc, %i4
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
2013c7c: 80 a7 20 18 cmp %i4, 0x18
2013c80: 32 bf ff f5 bne,a 2013c54 <fat_shutdown_drive+0x60>
2013c84: f6 07 60 70 ld [ %i5 + 0x70 ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
2013c88: 7f ff c5 b3 call 2005354 <free>
2013c8c: d0 07 60 6c ld [ %i5 + 0x6c ], %o0
free(fs_info->rhash);
2013c90: 7f ff c5 b1 call 2005354 <free>
2013c94: d0 07 60 70 ld [ %i5 + 0x70 ], %o0
free(fs_info->uino);
2013c98: 7f ff c5 af call 2005354 <free>
2013c9c: d0 07 60 74 ld [ %i5 + 0x74 ], %o0
free(fs_info->sec_buf);
2013ca0: 7f ff c5 ad call 2005354 <free>
2013ca4: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
close(fs_info->vol.fd);
2013ca8: 7f ff c4 ee call 2005060 <close>
2013cac: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
if (rc)
2013cb0: 80 a6 20 00 cmp %i0, 0
2013cb4: 02 80 00 06 be 2013ccc <fat_shutdown_drive+0xd8> <== ALWAYS TAKEN
2013cb8: 01 00 00 00 nop
errno = EIO;
2013cbc: 40 00 1e 3c call 201b5ac <__errno> <== NOT EXECUTED
2013cc0: 01 00 00 00 nop <== NOT EXECUTED
2013cc4: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2013cc8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return rc;
}
2013ccc: 81 c7 e0 08 ret
2013cd0: 81 e8 00 00 restore
02013b24 <fat_sync>:
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
2013b24: 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)
2013b28: c4 0e 20 0e ldub [ %i0 + 0xe ], %g2
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
2013b2c: ba 10 00 18 mov %i0, %i5
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
static int
fat_fat32_update_fsinfo_sector(fat_fs_info_t *fs_info)
{
ssize_t ret1 = 0, ret2 = 0;
2013b30: 90 10 20 00 clr %o0
if (fs_info->vol.type == FAT_FAT32)
2013b34: 80 a0 a0 04 cmp %g2, 4
2013b38: 12 80 00 20 bne 2013bb8 <fat_sync+0x94>
2013b3c: b4 10 20 00 clr %i2
{
uint32_t free_count = fs_info->vol.free_cls;
2013b40: f6 06 20 44 ld [ %i0 + 0x44 ], %i3
uint32_t next_free = fs_info->vol.next_cl;
if (free_count != fs_info->vol.free_cls_in_fs_info)
2013b44: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
2013b48: 80 a6 c0 01 cmp %i3, %g1
2013b4c: 02 80 00 0d be 2013b80 <fat_sync+0x5c> <== ALWAYS TAKEN
2013b50: f8 06 20 4c ld [ %i0 + 0x4c ], %i4
{
uint32_t le_free_count = CT_LE_L(free_count);
2013b54: 7f ff fc 65 call 2012ce8 <CPU_swap_u32> <== NOT EXECUTED
2013b58: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
fs_info->vol.free_cls_in_fs_info = free_count;
ret1 = fat_sector_write(fs_info,
2013b5c: d2 16 20 40 lduh [ %i0 + 0x40 ], %o1 <== 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);
2013b60: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
fs_info->vol.free_cls_in_fs_info = free_count;
2013b64: f6 26 20 48 st %i3, [ %i0 + 0x48 ] <== NOT EXECUTED
ret1 = fat_sector_write(fs_info,
2013b68: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2013b6c: 94 10 21 e8 mov 0x1e8, %o2 <== NOT EXECUTED
2013b70: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
2013b74: 7f ff fd 43 call 2013080 <fat_sector_write> <== NOT EXECUTED
2013b78: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
2013b7c: b4 10 00 08 mov %o0, %i2 <== 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)
2013b80: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
2013b84: 80 a7 00 02 cmp %i4, %g2
2013b88: 02 80 00 0c be 2013bb8 <fat_sync+0x94> <== NEVER TAKEN
2013b8c: 90 10 20 00 clr %o0
{
uint32_t le_next_free = CT_LE_L(next_free);
2013b90: 7f ff fc 56 call 2012ce8 <CPU_swap_u32>
2013b94: 90 10 00 1c mov %i4, %o0
fs_info->vol.next_cl_in_fs_info = next_free;
ret2 = fat_sector_write(fs_info,
2013b98: d2 17 60 40 lduh [ %i5 + 0x40 ], %o1
&le_free_count);
}
if (next_free != fs_info->vol.next_cl_in_fs_info)
{
uint32_t le_next_free = CT_LE_L(next_free);
2013b9c: d0 27 bf fc st %o0, [ %fp + -4 ]
fs_info->vol.next_cl_in_fs_info = next_free;
2013ba0: f8 27 60 50 st %i4, [ %i5 + 0x50 ]
ret2 = fat_sector_write(fs_info,
2013ba4: 90 10 00 1d mov %i5, %o0
2013ba8: 94 10 21 ec mov 0x1ec, %o2
2013bac: 96 10 20 04 mov 4, %o3
2013bb0: 7f ff fd 34 call 2013080 <fat_sector_write>
2013bb4: 98 07 bf fc add %fp, -4, %o4
sizeof(le_next_free),
&le_next_free);
}
}
if ( (ret1 < 0) || (ret2 < 0) )
2013bb8: 80 a2 20 00 cmp %o0, 0
2013bbc: 06 80 00 04 bl 2013bcc <fat_sync+0xa8> <== NEVER TAKEN
2013bc0: 80 a6 a0 00 cmp %i2, 0
2013bc4: 16 80 00 03 bge 2013bd0 <fat_sync+0xac> <== ALWAYS TAKEN
2013bc8: b0 10 20 00 clr %i0
{
int rc = RC_OK;
rc = fat_fat32_update_fsinfo_sector(fs_info);
if ( rc != RC_OK )
rc = -1;
2013bcc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
fat_buf_release(fs_info);
2013bd0: 7f ff fc 69 call 2012d74 <fat_buf_release>
2013bd4: 90 10 00 1d mov %i5, %o0
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
2013bd8: 7f ff f5 bb call 20112c4 <rtems_bdbuf_syncdev>
2013bdc: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
2013be0: 80 a2 20 00 cmp %o0, 0
2013be4: 32 80 00 02 bne,a 2013bec <fat_sync+0xc8> <== NEVER TAKEN
2013be8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
return rc;
}
2013bec: 81 c7 e0 08 ret
2013bf0: 81 e8 00 00 restore
02032668 <fchdir>:
/**
* compatible with SVr4, 4.4BSD and X/OPEN - Change Directory
*/
int fchdir( int fd )
{
2032668: 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 );
203266c: 03 00 81 77 sethi %hi(0x205dc00), %g1
2032670: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 ! 205dd10 <rtems_libio_number_iops>
int rv = 0;
rtems_libio_t *iop;
struct stat st;
rtems_filesystem_location_info_t loc;
st.st_mode = 0;
2032674: c0 27 bf c4 clr [ %fp + -60 ]
st.st_uid = 0;
2032678: c0 37 bf ca clrh [ %fp + -54 ]
st.st_gid = 0;
rtems_libio_check_fd( fd );
203267c: 80 a6 00 01 cmp %i0, %g1
2032680: 1a 80 00 0c bcc 20326b0 <fchdir+0x48>
2032684: c0 37 bf cc clrh [ %fp + -52 ]
iop = rtems_libio_iop( fd );
2032688: 83 2e 20 03 sll %i0, 3, %g1
203268c: b1 2e 20 06 sll %i0, 6, %i0
2032690: b0 26 00 01 sub %i0, %g1, %i0
2032694: 03 00 81 87 sethi %hi(0x2061c00), %g1
2032698: fa 00 62 b4 ld [ %g1 + 0x2b4 ], %i5 ! 2061eb4 <rtems_libio_iops>
203269c: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open( iop );
20326a0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
20326a4: 80 88 61 00 btst 0x100, %g1
20326a8: 32 80 00 08 bne,a 20326c8 <fchdir+0x60>
20326ac: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
20326b0: 40 00 10 e9 call 2036a54 <__errno>
20326b4: b0 10 3f ff mov -1, %i0
20326b8: 82 10 20 09 mov 9, %g1
20326bc: c2 22 00 00 st %g1, [ %o0 ]
20326c0: 81 c7 e0 08 ret
20326c4: 81 e8 00 00 restore
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
20326c8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
20326cc: c2 00 40 00 ld [ %g1 ], %g1
20326d0: 9f c0 40 00 call %g1
20326d4: b8 07 60 14 add %i5, 0x14, %i4
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
20326d8: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
20326dc: 90 10 00 1c mov %i4, %o0
20326e0: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
20326e4: 9f c0 40 00 call %g1
20326e8: 92 07 bf b8 add %fp, -72, %o1
if ( rv == 0 ) {
20326ec: b0 92 20 00 orcc %o0, 0, %i0
20326f0: 32 80 00 13 bne,a 203273c <fchdir+0xd4> <== NEVER TAKEN
20326f4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
bool access_ok = rtems_filesystem_check_access(
20326f8: d2 07 bf c4 ld [ %fp + -60 ], %o1
20326fc: d4 17 bf ca lduh [ %fp + -54 ], %o2
2032700: d6 17 bf cc lduh [ %fp + -52 ], %o3
2032704: 7f ff 6e da call 200e26c <rtems_filesystem_check_access>
2032708: 90 10 20 01 mov 1, %o0
st.st_mode,
st.st_uid,
st.st_gid
);
if ( access_ok ) {
203270c: 80 8a 20 ff btst 0xff, %o0
2032710: 02 80 00 06 be 2032728 <fchdir+0xc0>
2032714: 90 07 bf a0 add %fp, -96, %o0
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
2032718: 7f ff 6d 8e call 200dd50 <rtems_filesystem_location_clone>
203271c: 92 10 00 1c mov %i4, %o1
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2032720: 10 80 00 07 b 203273c <fchdir+0xd4>
2032724: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
} else {
errno = EACCES;
2032728: 40 00 10 cb call 2036a54 <__errno>
203272c: b0 10 3f ff mov -1, %i0
2032730: 82 10 20 0d mov 0xd, %g1
2032734: c2 22 00 00 st %g1, [ %o0 ]
2032738: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
203273c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2032740: c2 00 60 04 ld [ %g1 + 4 ], %g1
2032744: 9f c0 40 00 call %g1
2032748: 01 00 00 00 nop
rv = -1;
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
if ( rv == 0 ) {
203274c: 80 a6 20 00 cmp %i0, 0
2032750: 12 80 00 05 bne 2032764 <fchdir+0xfc>
2032754: 01 00 00 00 nop
rv = rtems_filesystem_chdir( &loc );
2032758: 7f ff c4 69 call 20238fc <rtems_filesystem_chdir>
203275c: 90 07 bf a0 add %fp, -96, %o0
2032760: b0 10 00 08 mov %o0, %i0
}
return rv;
}
2032764: 81 c7 e0 08 ret
2032768: 81 e8 00 00 restore
02023be4 <fchmod>:
/**
* POSIX 1003.1b 5.6.4 - Change File Modes
*/
int fchmod( int fd, mode_t mode )
{
2023be4: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2023be8: 03 00 81 77 sethi %hi(0x205dc00), %g1
2023bec: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 ! 205dd10 <rtems_libio_number_iops>
2023bf0: 80 a6 00 01 cmp %i0, %g1
2023bf4: 2a 80 00 03 bcs,a 2023c00 <fchmod+0x1c>
2023bf8: 83 2e 20 03 sll %i0, 3, %g1
2023bfc: 30 80 00 0a b,a 2023c24 <fchmod+0x40>
iop = rtems_libio_iop( fd );
2023c00: b1 2e 20 06 sll %i0, 6, %i0
2023c04: b0 26 00 01 sub %i0, %g1, %i0
2023c08: 03 00 81 87 sethi %hi(0x2061c00), %g1
2023c0c: fa 00 62 b4 ld [ %g1 + 0x2b4 ], %i5 ! 2061eb4 <rtems_libio_iops>
2023c10: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
2023c14: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2023c18: 80 88 61 00 btst 0x100, %g1
2023c1c: 32 80 00 06 bne,a 2023c34 <fchmod+0x50>
2023c20: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
2023c24: 40 00 4b 8c call 2036a54 <__errno>
2023c28: 01 00 00 00 nop
2023c2c: 10 80 00 1b b 2023c98 <fchmod+0xb4>
2023c30: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
if (iop->pathinfo.mt_entry->writeable) {
2023c34: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
2023c38: 80 a0 60 00 cmp %g1, 0
2023c3c: 02 80 00 14 be 2023c8c <fchmod+0xa8> <== NEVER TAKEN
2023c40: 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 );
2023c44: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2023c48: c2 00 40 00 ld [ %g1 ], %g1
2023c4c: 9f c0 40 00 call %g1
2023c50: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
2023c54: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2023c58: 90 07 60 14 add %i5, 0x14, %o0
2023c5c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2023c60: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
2023c64: 9f c0 40 00 call %g1
2023c68: 92 10 00 19 mov %i1, %o1
2023c6c: 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;
2023c70: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
2023c74: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2023c78: c2 00 60 04 ld [ %g1 + 4 ], %g1
2023c7c: 9f c0 40 00 call %g1
2023c80: 01 00 00 00 nop
2023c84: 81 c7 e0 08 ret
2023c88: 81 e8 00 00 restore
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
2023c8c: 40 00 4b 72 call 2036a54 <__errno> <== NOT EXECUTED
2023c90: 01 00 00 00 nop <== NOT EXECUTED
2023c94: 82 10 20 1e mov 0x1e, %g1 ! 1e <PROM_START+0x1e> <== NOT EXECUTED
2023c98: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
2023c9c: 81 c7 e0 08 ret
2023ca0: 91 e8 3f ff restore %g0, -1, %o0
02023ca4 <fchown>:
/**
* POSIX 1003.1b 5.6.5 - Change Owner and Group of a File
*/
int fchown( int fd, uid_t owner, gid_t group )
{
2023ca4: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2023ca8: 03 00 81 77 sethi %hi(0x205dc00), %g1
2023cac: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 ! 205dd10 <rtems_libio_number_iops>
2023cb0: 80 a6 00 01 cmp %i0, %g1
2023cb4: 2a 80 00 03 bcs,a 2023cc0 <fchown+0x1c>
2023cb8: 83 2e 20 03 sll %i0, 3, %g1
2023cbc: 30 80 00 0a b,a 2023ce4 <fchown+0x40>
iop = rtems_libio_iop( fd );
2023cc0: b1 2e 20 06 sll %i0, 6, %i0
2023cc4: b0 26 00 01 sub %i0, %g1, %i0
2023cc8: 03 00 81 87 sethi %hi(0x2061c00), %g1
2023ccc: fa 00 62 b4 ld [ %g1 + 0x2b4 ], %i5 ! 2061eb4 <rtems_libio_iops>
2023cd0: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
2023cd4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2023cd8: 80 88 61 00 btst 0x100, %g1
2023cdc: 32 80 00 06 bne,a 2023cf4 <fchown+0x50>
2023ce0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
2023ce4: 40 00 4b 5c call 2036a54 <__errno>
2023ce8: 01 00 00 00 nop
2023cec: 10 80 00 1c b 2023d5c <fchown+0xb8>
2023cf0: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
if (iop->pathinfo.mt_entry->writeable) {
2023cf4: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
2023cf8: 80 a0 60 00 cmp %g1, 0
2023cfc: 02 80 00 15 be 2023d50 <fchown+0xac> <== NEVER TAKEN
2023d00: 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 );
2023d04: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2023d08: c2 00 40 00 ld [ %g1 ], %g1
2023d0c: 9f c0 40 00 call %g1
2023d10: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->chown_h)(
2023d14: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2023d18: 90 07 60 14 add %i5, 0x14, %o0
2023d1c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2023d20: 92 10 00 19 mov %i1, %o1
2023d24: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
2023d28: 9f c0 40 00 call %g1
2023d2c: 94 10 00 1a mov %i2, %o2
2023d30: 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;
2023d34: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
2023d38: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2023d3c: c2 00 60 04 ld [ %g1 + 4 ], %g1
2023d40: 9f c0 40 00 call %g1
2023d44: 01 00 00 00 nop
2023d48: 81 c7 e0 08 ret
2023d4c: 81 e8 00 00 restore
owner,
group
);
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
2023d50: 40 00 4b 41 call 2036a54 <__errno> <== NOT EXECUTED
2023d54: 01 00 00 00 nop <== NOT EXECUTED
2023d58: 82 10 20 1e mov 0x1e, %g1 ! 1e <PROM_START+0x1e> <== NOT EXECUTED
2023d5c: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
2023d60: 81 c7 e0 08 ret
2023d64: 91 e8 3f ff restore %g0, -1, %o0
0202f720 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
202f720: 9d e3 bf 98 save %sp, -104, %sp
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
202f724: 05 00 80 d7 sethi %hi(0x2035c00), %g2
202f728: c4 00 a0 8c ld [ %g2 + 0x8c ], %g2 ! 2035c8c <rtems_libio_number_iops>
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
202f72c: 82 07 a0 4c add %fp, 0x4c, %g1
202f730: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
202f734: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
202f738: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
202f73c: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
202f740: 80 a6 00 02 cmp %i0, %g2
202f744: 1a 80 00 0c bcc 202f774 <fcntl+0x54>
202f748: c2 27 bf fc st %g1, [ %fp + -4 ]
iop = rtems_libio_iop( fd );
202f74c: 85 2e 20 03 sll %i0, 3, %g2
202f750: b1 2e 20 06 sll %i0, 6, %i0
202f754: b0 26 00 02 sub %i0, %g2, %i0
202f758: 05 00 81 1a sethi %hi(0x2046800), %g2
202f75c: fa 00 a0 38 ld [ %g2 + 0x38 ], %i5 ! 2046838 <rtems_libio_iops>
202f760: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
202f764: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
202f768: 80 8a 21 00 btst 0x100, %o0
202f76c: 12 80 00 06 bne 202f784 <fcntl+0x64>
202f770: 80 a6 60 09 cmp %i1, 9
202f774: 7f ff c4 ab call 2020a20 <__errno>
202f778: 01 00 00 00 nop
202f77c: 10 80 00 5d b 202f8f0 <fcntl+0x1d0>
202f780: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
202f784: 18 80 00 58 bgu 202f8e4 <fcntl+0x1c4>
202f788: 85 2e 60 02 sll %i1, 2, %g2
202f78c: 07 00 80 bd sethi %hi(0x202f400), %g3
202f790: 86 10 e2 f8 or %g3, 0x2f8, %g3 ! 202f6f8 <_calloc_r+0x14>
202f794: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
202f798: 81 c0 80 00 jmp %g2
202f79c: 01 00 00 00 nop
/*
* FIXME: We ignore the start value fd2 for the file descriptor search. This
* is not POSIX conform.
*/
rtems_libio_t *diop = rtems_libio_allocate();
202f7a0: 7f ff 63 05 call 20083b4 <rtems_libio_allocate>
202f7a4: 01 00 00 00 nop
if (diop != NULL) {
202f7a8: b8 92 20 00 orcc %o0, 0, %i4
202f7ac: 02 80 00 62 be 202f934 <fcntl+0x214>
202f7b0: b0 10 3f ff mov -1, %i0
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
202f7b4: 7f ff 62 ea call 200835c <rtems_libio_to_fcntl_flags>
202f7b8: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
oflag &= ~O_CREAT;
diop->flags |= rtems_libio_fcntl_flags( oflag );
202f7bc: f4 07 20 10 ld [ %i4 + 0x10 ], %i2
rtems_libio_t *diop = rtems_libio_allocate();
if (diop != NULL) {
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
oflag &= ~O_CREAT;
202f7c0: b6 0a 3d ff and %o0, -513, %i3
diop->flags |= rtems_libio_fcntl_flags( oflag );
202f7c4: 7f ff 62 d9 call 2008328 <rtems_libio_fcntl_flags>
202f7c8: 90 10 00 1b mov %i3, %o0
202f7cc: 90 12 00 1a or %o0, %i2, %o0
202f7d0: d0 27 20 10 st %o0, [ %i4 + 0x10 ]
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
202f7d4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
202f7d8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
202f7dc: c2 00 40 00 ld [ %g1 ], %g1
202f7e0: 9f c0 40 00 call %g1
202f7e4: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
202f7e8: 92 07 60 14 add %i5, 0x14, %o1
202f7ec: 7f ff 9d 20 call 2016c6c <rtems_filesystem_location_clone>
202f7f0: 90 07 20 14 add %i4, 0x14, %o0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
202f7f4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
202f7f8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
202f7fc: c2 00 60 04 ld [ %g1 + 4 ], %g1
202f800: 9f c0 40 00 call %g1
202f804: 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 );
202f808: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
202f80c: 90 10 00 1c mov %i4, %o0
202f810: c2 00 40 00 ld [ %g1 ], %g1
202f814: 92 10 20 00 clr %o1
202f818: 94 10 00 1b mov %i3, %o2
202f81c: 9f c0 40 00 call %g1
202f820: 96 10 20 00 clr %o3
if ( rv == 0 ) {
202f824: b0 92 20 00 orcc %o0, 0, %i0
202f828: 12 80 00 11 bne 202f86c <fcntl+0x14c> <== NEVER TAKEN
202f82c: 03 00 81 1a sethi %hi(0x2046800), %g1
rv = diop - rtems_libio_iops;
202f830: f0 00 60 38 ld [ %g1 + 0x38 ], %i0 ! 2046838 <rtems_libio_iops>
202f834: b8 27 00 18 sub %i4, %i0, %i4
202f838: b9 3f 20 03 sra %i4, 3, %i4
202f83c: 85 2f 20 03 sll %i4, 3, %g2
202f840: 83 2f 20 06 sll %i4, 6, %g1
202f844: 82 00 80 01 add %g2, %g1, %g1
202f848: 85 28 60 06 sll %g1, 6, %g2
202f84c: 82 00 40 02 add %g1, %g2, %g1
202f850: 82 00 40 1c add %g1, %i4, %g1
202f854: b1 28 60 0f sll %g1, 0xf, %i0
202f858: 82 00 40 18 add %g1, %i0, %g1
202f85c: 83 28 60 03 sll %g1, 3, %g1
202f860: b8 00 40 1c add %g1, %i4, %i4
202f864: 10 80 00 25 b 202f8f8 <fcntl+0x1d8>
202f868: b0 20 00 1c neg %i4, %i0
} else {
rtems_libio_free( diop );
202f86c: 7f ff 62 e9 call 2008410 <rtems_libio_free> <== NOT EXECUTED
202f870: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
202f874: 10 80 00 22 b 202f8fc <fcntl+0x1dc> <== NOT EXECUTED
202f878: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
fd2 = va_arg( ap, int );
ret = duplicate_iop( iop, fd2 );
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
202f87c: b1 32 20 0b srl %o0, 0xb, %i0
202f880: 10 80 00 21 b 202f904 <fcntl+0x1e4>
202f884: b0 0e 20 01 and %i0, 1, %i0
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
202f888: c2 00 40 00 ld [ %g1 ], %g1
202f88c: 80 a0 60 00 cmp %g1, 0
202f890: 22 80 00 0e be,a 202f8c8 <fcntl+0x1a8>
202f894: 90 0a 37 ff and %o0, -2049, %o0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
202f898: 10 80 00 0c b 202f8c8 <fcntl+0x1a8>
202f89c: 90 12 28 00 or %o0, 0x800, %o0
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
202f8a0: 7f ff 62 af call 200835c <rtems_libio_to_fcntl_flags>
202f8a4: 01 00 00 00 nop
202f8a8: 10 80 00 14 b 202f8f8 <fcntl+0x1d8>
202f8ac: b0 10 00 08 mov %o0, %i0
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
202f8b0: 7f ff 62 9e call 2008328 <rtems_libio_fcntl_flags>
202f8b4: d0 00 40 00 ld [ %g1 ], %o0
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
202f8b8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
202f8bc: 90 0a 22 01 and %o0, 0x201, %o0
202f8c0: 82 08 7d fe and %g1, -514, %g1
202f8c4: 90 12 00 01 or %o0, %g1, %o0
202f8c8: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
202f8cc: 10 80 00 0e b 202f904 <fcntl+0x1e4>
202f8d0: b0 10 20 00 clr %i0
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
202f8d4: 7f ff c4 53 call 2020a20 <__errno>
202f8d8: 01 00 00 00 nop
202f8dc: 10 80 00 05 b 202f8f0 <fcntl+0x1d0>
202f8e0: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
ret = -1;
break;
default:
errno = EINVAL;
202f8e4: 7f ff c4 4f call 2020a20 <__errno>
202f8e8: 01 00 00 00 nop
202f8ec: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
202f8f0: 10 80 00 10 b 202f930 <fcntl+0x210>
202f8f4: c2 22 00 00 st %g1, [ %o0 ]
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
202f8f8: 80 a6 20 00 cmp %i0, 0
202f8fc: 06 80 00 0e bl 202f934 <fcntl+0x214> <== NEVER TAKEN
202f900: 01 00 00 00 nop
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
202f904: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
202f908: 90 10 00 1d mov %i5, %o0
202f90c: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
202f910: 9f c0 40 00 call %g1
202f914: 92 10 00 19 mov %i1, %o1
if (err) {
202f918: ba 92 20 00 orcc %o0, 0, %i5
202f91c: 02 80 00 06 be 202f934 <fcntl+0x214> <== ALWAYS TAKEN
202f920: 01 00 00 00 nop
errno = err;
202f924: 7f ff c4 3f call 2020a20 <__errno> <== NOT EXECUTED
202f928: 01 00 00 00 nop <== NOT EXECUTED
202f92c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
202f930: b0 10 3f ff mov -1, %i0
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
202f934: 81 c7 e0 08 ret
202f938: 81 e8 00 00 restore
0200dd0c <fifo_open>:
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200dd0c: 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) {
200dd10: 3b 00 80 8c sethi %hi(0x2023000), %i5
200dd14: c2 07 61 80 ld [ %i5 + 0x180 ], %g1 ! 2023180 <pipe_semaphore>
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200dd18: b6 10 00 18 mov %i0, %i3
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
200dd1c: 80 a0 60 00 cmp %g1, 0
200dd20: 02 80 00 0c be 200dd50 <fifo_open+0x44>
200dd24: b8 17 61 80 or %i5, 0x180, %i4
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
200dd28: 03 00 80 8c sethi %hi(0x2023000), %g1
200dd2c: d0 00 61 80 ld [ %g1 + 0x180 ], %o0 ! 2023180 <pipe_semaphore>
200dd30: 92 10 20 00 clr %o1
200dd34: 7f ff ec 88 call 2008f54 <rtems_semaphore_obtain>
200dd38: 94 10 20 00 clr %o2
}
if (sc == RTEMS_SUCCESSFUL) {
200dd3c: 80 a2 20 00 cmp %o0, 0
200dd40: 22 80 01 00 be,a 200e140 <fifo_open+0x434> <== ALWAYS TAKEN
200dd44: fa 06 c0 00 ld [ %i3 ], %i5
return 0;
} else {
return -ENOMEM;
200dd48: 81 c7 e0 08 ret <== NOT EXECUTED
200dd4c: 91 e8 3f f4 restore %g0, -12, %o0 <== NOT EXECUTED
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
200dd50: 03 00 80 8c sethi %hi(0x2023000), %g1
200dd54: d0 00 63 00 ld [ %g1 + 0x300 ], %o0 ! 2023300 <rtems_libio_semaphore>
200dd58: 92 10 20 00 clr %o1
200dd5c: 7f ff ec 7e call 2008f54 <rtems_semaphore_obtain>
200dd60: 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) {
200dd64: c2 07 61 80 ld [ %i5 + 0x180 ], %g1
200dd68: 80 a0 60 00 cmp %g1, 0
200dd6c: 12 80 00 0a bne 200dd94 <fifo_open+0x88> <== NEVER TAKEN
200dd70: ba 10 20 00 clr %i5
sc = rtems_semaphore_create(
200dd74: 11 14 12 54 sethi %hi(0x50495000), %o0
200dd78: 92 10 20 01 mov 1, %o1
200dd7c: 90 12 20 45 or %o0, 0x45, %o0
200dd80: 94 10 20 54 mov 0x54, %o2
200dd84: 96 10 20 00 clr %o3
200dd88: 7f ff eb d6 call 2008ce0 <rtems_semaphore_create>
200dd8c: 98 10 00 1c mov %i4, %o4
200dd90: ba 10 00 08 mov %o0, %i5
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
200dd94: 03 00 80 8c sethi %hi(0x2023000), %g1
200dd98: 7f ff ec b8 call 2009078 <rtems_semaphore_release>
200dd9c: d0 00 63 00 ld [ %g1 + 0x300 ], %o0 ! 2023300 <rtems_libio_semaphore>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
200dda0: 80 a7 60 00 cmp %i5, 0
200dda4: 02 bf ff e1 be 200dd28 <fifo_open+0x1c>
200dda8: b0 10 3f f4 mov -12, %i0
200ddac: 81 c7 e0 08 ret
200ddb0: 81 e8 00 00 restore
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
200ddb4: 7f ff db b5 call 2004c88 <malloc>
200ddb8: 90 10 20 34 mov 0x34, %o0
if (pipe == NULL)
200ddbc: ba 92 20 00 orcc %o0, 0, %i5
200ddc0: 02 80 00 e4 be 200e150 <fifo_open+0x444> <== NEVER TAKEN
200ddc4: 92 10 20 00 clr %o1
return err;
memset(pipe, 0, sizeof(pipe_control_t));
200ddc8: 40 00 12 ce call 2012900 <memset>
200ddcc: 94 10 20 34 mov 0x34, %o2
pipe->Size = PIPE_BUF;
200ddd0: 82 10 22 00 mov 0x200, %g1
pipe->Buffer = malloc(pipe->Size);
200ddd4: 90 10 22 00 mov 0x200, %o0
200ddd8: 7f ff db ac call 2004c88 <malloc>
200dddc: c2 27 60 04 st %g1, [ %i5 + 4 ]
if (! pipe->Buffer)
200dde0: 80 a2 20 00 cmp %o0, 0
200dde4: 02 80 00 40 be 200dee4 <fifo_open+0x1d8> <== NEVER TAKEN
200dde8: d0 27 40 00 st %o0, [ %i5 ]
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
200ddec: 39 00 80 8a sethi %hi(0x2022800), %i4
200ddf0: d0 4f 22 38 ldsb [ %i4 + 0x238 ], %o0 ! 2022a38 <c.7185>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
200ddf4: 35 14 12 5c sethi %hi(0x50497000), %i2
200ddf8: 82 16 a2 00 or %i2, 0x200, %g1 ! 50497200 <RAM_END+0x4e097200>
200ddfc: 92 10 20 00 clr %o1
200de00: 90 12 00 01 or %o0, %g1, %o0
200de04: 94 10 20 00 clr %o2
200de08: 40 00 05 f1 call 200f5cc <rtems_barrier_create>
200de0c: 96 07 60 2c add %i5, 0x2c, %o3
200de10: 80 a2 20 00 cmp %o0, 0
200de14: 12 80 00 32 bne 200dedc <fifo_open+0x1d0>
200de18: d0 4f 22 38 ldsb [ %i4 + 0x238 ], %o0
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
200de1c: 03 14 12 5d sethi %hi(0x50497400), %g1
200de20: 82 10 63 00 or %g1, 0x300, %g1 ! 50497700 <RAM_END+0x4e097700>
200de24: 92 10 20 00 clr %o1
200de28: 90 12 00 01 or %o0, %g1, %o0
200de2c: 94 10 20 00 clr %o2
200de30: 40 00 05 e7 call 200f5cc <rtems_barrier_create>
200de34: 96 07 60 30 add %i5, 0x30, %o3
200de38: 80 a2 20 00 cmp %o0, 0
200de3c: 12 80 00 26 bne 200ded4 <fifo_open+0x1c8>
200de40: d0 4f 22 38 ldsb [ %i4 + 0x238 ], %o0
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
200de44: b4 16 a3 00 or %i2, 0x300, %i2
200de48: 92 10 20 01 mov 1, %o1
200de4c: 90 12 00 1a or %o0, %i2, %o0
200de50: 94 10 20 10 mov 0x10, %o2
200de54: 96 10 20 00 clr %o3
200de58: 7f ff eb a2 call 2008ce0 <rtems_semaphore_create>
200de5c: 98 07 60 28 add %i5, 0x28, %o4
200de60: 80 a2 20 00 cmp %o0, 0
200de64: 12 80 00 1a bne 200decc <fifo_open+0x1c0>
200de68: 94 07 bf fc add %fp, -4, %o2
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
200de6c: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
200de70: 31 00 80 8f sethi %hi(0x2023c00), %i0
200de74: 7f ff f2 dd call 200a9e8 <_Objects_Get>
200de78: 90 16 21 b0 or %i0, 0x1b0, %o0 ! 2023db0 <_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;
200de7c: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
200de80: 35 04 00 00 sethi %hi(0x10000000), %i2
200de84: 82 10 40 1a or %g1, %i2, %g1
_Thread_Enable_dispatch();
200de88: 7f ff f6 90 call 200b8c8 <_Thread_Enable_dispatch>
200de8c: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
200de90: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
200de94: 94 07 bf fc add %fp, -4, %o2
200de98: 7f ff f2 d4 call 200a9e8 <_Objects_Get>
200de9c: 90 16 21 b0 or %i0, 0x1b0, %o0
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
200dea0: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
200dea4: b4 10 40 1a or %g1, %i2, %i2
_Thread_Enable_dispatch();
200dea8: 7f ff f6 88 call 200b8c8 <_Thread_Enable_dispatch>
200deac: f4 22 20 4c st %i2, [ %o0 + 0x4c ]
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
200deb0: c2 0f 22 38 ldub [ %i4 + 0x238 ], %g1
200deb4: c4 4f 22 38 ldsb [ %i4 + 0x238 ], %g2
200deb8: 80 a0 a0 7a cmp %g2, 0x7a
200debc: 12 80 00 a7 bne 200e158 <fifo_open+0x44c>
200dec0: 82 00 60 01 inc %g1
c = 'a';
200dec4: 10 80 00 a5 b 200e158 <fifo_open+0x44c>
200dec8: 82 10 20 61 mov 0x61, %g1
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
200decc: 40 00 05 ef call 200f688 <rtems_barrier_delete>
200ded0: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
200ded4: 40 00 05 ed call 200f688 <rtems_barrier_delete>
200ded8: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
err_rbar:
free(pipe->Buffer);
200dedc: 7f ff da 57 call 2004838 <free>
200dee0: d0 07 40 00 ld [ %i5 ], %o0
err_buf:
free(pipe);
200dee4: 7f ff da 55 call 2004838 <free>
200dee8: 90 10 00 1d mov %i5, %o0
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
200deec: 10 80 00 13 b 200df38 <fifo_open+0x22c>
200def0: b0 10 3f f4 mov -12, %i0
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
200def4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200def8: 92 10 20 00 clr %o1
200defc: 7f ff ec 16 call 2008f54 <rtems_semaphore_obtain>
200df00: 94 10 20 00 clr %o2
err = -EINTR;
if (*pipep == NULL) {
200df04: c2 06 c0 00 ld [ %i3 ], %g1
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
200df08: 80 a0 00 08 cmp %g0, %o0
200df0c: b0 60 20 00 subx %g0, 0, %i0
err = -EINTR;
if (*pipep == NULL) {
200df10: 80 a0 60 00 cmp %g1, 0
200df14: 12 80 00 09 bne 200df38 <fifo_open+0x22c>
200df18: b0 0e 3f fc and %i0, -4, %i0
if (err)
200df1c: 80 a6 20 00 cmp %i0, 0
200df20: 22 80 00 06 be,a 200df38 <fifo_open+0x22c> <== ALWAYS TAKEN
200df24: fa 26 c0 00 st %i5, [ %i3 ]
pipe_free(pipe);
200df28: 7f ff ff 41 call 200dc2c <pipe_free> <== NOT EXECUTED
200df2c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
200df30: 10 80 00 03 b 200df3c <fifo_open+0x230> <== NOT EXECUTED
200df34: 03 00 80 8c sethi %hi(0x2023000), %g1 <== NOT EXECUTED
200df38: 03 00 80 8c sethi %hi(0x2023000), %g1
200df3c: 7f ff ec 4f call 2009078 <rtems_semaphore_release>
200df40: d0 00 61 80 ld [ %g1 + 0x180 ], %o0 ! 2023180 <pipe_semaphore>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
200df44: 80 a6 20 00 cmp %i0, 0
200df48: 12 80 00 86 bne 200e160 <fifo_open+0x454>
200df4c: 01 00 00 00 nop
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
200df50: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200df54: 82 08 60 06 and %g1, 6, %g1
200df58: 80 a0 60 04 cmp %g1, 4
200df5c: 02 80 00 2e be 200e014 <fifo_open+0x308>
200df60: fa 06 c0 00 ld [ %i3 ], %i5
200df64: 80 a0 60 06 cmp %g1, 6
200df68: 02 80 00 56 be 200e0c0 <fifo_open+0x3b4>
200df6c: 80 a0 60 02 cmp %g1, 2
200df70: 12 80 00 6a bne 200e118 <fifo_open+0x40c> <== NEVER TAKEN
200df74: 01 00 00 00 nop
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
200df78: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200df7c: 82 00 60 01 inc %g1
200df80: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
200df84: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200df88: 84 00 60 01 add %g1, 1, %g2
200df8c: 80 a0 60 00 cmp %g1, 0
200df90: 12 80 00 05 bne 200dfa4 <fifo_open+0x298> <== NEVER TAKEN
200df94: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
PIPE_WAKEUPWRITERS(pipe);
200df98: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200df9c: 40 00 05 e4 call 200f72c <rtems_barrier_release>
200dfa0: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Writers == 0) {
200dfa4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200dfa8: 80 a0 60 00 cmp %g1, 0
200dfac: 12 80 00 5b bne 200e118 <fifo_open+0x40c>
200dfb0: 01 00 00 00 nop
/* Not an error */
if (LIBIO_NODELAY(iop))
200dfb4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200dfb8: 80 88 60 01 btst 1, %g1
200dfbc: 12 80 00 57 bne 200e118 <fifo_open+0x40c>
200dfc0: 01 00 00 00 nop
break;
prevCounter = pipe->writerCounter;
200dfc4: f8 07 60 24 ld [ %i5 + 0x24 ], %i4
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
200dfc8: 7f ff ec 2c call 2009078 <rtems_semaphore_release>
200dfcc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_READWAIT(pipe))
200dfd0: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200dfd4: 40 00 05 ec call 200f784 <rtems_barrier_wait>
200dfd8: 92 10 20 00 clr %o1
200dfdc: 80 a2 20 00 cmp %o0, 0
200dfe0: 12 80 00 52 bne 200e128 <fifo_open+0x41c> <== NEVER TAKEN
200dfe4: 92 10 20 00 clr %o1
goto out_error;
if (! PIPE_LOCK(pipe))
200dfe8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200dfec: 7f ff eb da call 2008f54 <rtems_semaphore_obtain>
200dff0: 94 10 20 00 clr %o2
200dff4: 80 a2 20 00 cmp %o0, 0
200dff8: 32 80 00 4d bne,a 200e12c <fifo_open+0x420> <== NEVER TAKEN
200dffc: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->writerCounter);
200e000: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200e004: 80 a7 00 01 cmp %i4, %g1
200e008: 02 bf ff f0 be 200dfc8 <fifo_open+0x2bc> <== NEVER TAKEN
200e00c: 01 00 00 00 nop
200e010: 30 80 00 42 b,a 200e118 <fifo_open+0x40c>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
200e014: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200e018: 82 00 60 01 inc %g1
200e01c: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
200e020: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200e024: 84 00 60 01 add %g1, 1, %g2
200e028: 80 a0 60 00 cmp %g1, 0
200e02c: 12 80 00 05 bne 200e040 <fifo_open+0x334> <== NEVER TAKEN
200e030: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
200e034: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e038: 40 00 05 bd call 200f72c <rtems_barrier_release>
200e03c: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
200e040: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e044: 80 a0 60 00 cmp %g1, 0
200e048: 12 80 00 34 bne 200e118 <fifo_open+0x40c>
200e04c: 01 00 00 00 nop
200e050: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200e054: 80 88 60 01 btst 1, %g1
200e058: 22 80 00 07 be,a 200e074 <fifo_open+0x368>
200e05c: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
PIPE_UNLOCK(pipe);
200e060: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e064: 7f ff ec 05 call 2009078 <rtems_semaphore_release>
200e068: b0 10 3f fa mov -6, %i0
err = -ENXIO;
goto out_error;
200e06c: 10 80 00 31 b 200e130 <fifo_open+0x424>
200e070: 90 10 00 1b mov %i3, %o0
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
200e074: 7f ff ec 01 call 2009078 <rtems_semaphore_release>
200e078: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_WRITEWAIT(pipe))
200e07c: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e080: 40 00 05 c1 call 200f784 <rtems_barrier_wait>
200e084: 92 10 20 00 clr %o1
200e088: 80 a2 20 00 cmp %o0, 0
200e08c: 12 80 00 27 bne 200e128 <fifo_open+0x41c> <== NEVER TAKEN
200e090: 92 10 20 00 clr %o1
goto out_error;
if (! PIPE_LOCK(pipe))
200e094: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e098: 7f ff eb af call 2008f54 <rtems_semaphore_obtain>
200e09c: 94 10 20 00 clr %o2
200e0a0: 80 a2 20 00 cmp %o0, 0
200e0a4: 32 80 00 22 bne,a 200e12c <fifo_open+0x420> <== NEVER TAKEN
200e0a8: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->readerCounter);
200e0ac: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200e0b0: 80 a7 00 01 cmp %i4, %g1
200e0b4: 02 bf ff f0 be 200e074 <fifo_open+0x368> <== NEVER TAKEN
200e0b8: 01 00 00 00 nop
200e0bc: 30 80 00 17 b,a 200e118 <fifo_open+0x40c>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
200e0c0: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200e0c4: 82 00 60 01 inc %g1
200e0c8: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
200e0cc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e0d0: 84 00 60 01 add %g1, 1, %g2
200e0d4: 80 a0 60 00 cmp %g1, 0
200e0d8: 12 80 00 05 bne 200e0ec <fifo_open+0x3e0> <== NEVER TAKEN
200e0dc: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
PIPE_WAKEUPWRITERS(pipe);
200e0e0: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e0e4: 40 00 05 92 call 200f72c <rtems_barrier_release>
200e0e8: 92 07 bf f8 add %fp, -8, %o1
pipe->writerCounter ++;
200e0ec: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200e0f0: 82 00 60 01 inc %g1
200e0f4: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
200e0f8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200e0fc: 84 00 60 01 add %g1, 1, %g2
200e100: 80 a0 60 00 cmp %g1, 0
200e104: 12 80 00 05 bne 200e118 <fifo_open+0x40c> <== NEVER TAKEN
200e108: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
200e10c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e110: 40 00 05 87 call 200f72c <rtems_barrier_release>
200e114: 92 07 bf f8 add %fp, -8, %o1
break;
}
PIPE_UNLOCK(pipe);
200e118: 7f ff eb d8 call 2009078 <rtems_semaphore_release>
200e11c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
return 0;
200e120: 81 c7 e0 08 ret
200e124: 81 e8 00 00 restore
/* Not an error */
if (LIBIO_NODELAY(iop))
break;
prevCounter = pipe->writerCounter;
err = -EINTR;
200e128: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
200e12c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
200e130: 7f ff fe ca call 200dc58 <pipe_release>
200e134: 92 10 00 19 mov %i1, %o1
return err;
200e138: 81 c7 e0 08 ret
200e13c: 81 e8 00 00 restore
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
if (pipe == NULL) {
200e140: 80 a7 60 00 cmp %i5, 0
200e144: 32 bf ff 6d bne,a 200def8 <fifo_open+0x1ec>
200e148: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e14c: 30 bf ff 1a b,a 200ddb4 <fifo_open+0xa8>
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
200e150: 10 bf ff 7a b 200df38 <fifo_open+0x22c> <== NOT EXECUTED
200e154: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
200e158: 10 bf ff 67 b 200def4 <fifo_open+0x1e8>
200e15c: c2 2f 22 38 stb %g1, [ %i4 + 0x238 ]
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
200e160: 81 c7 e0 08 ret
200e164: 81 e8 00 00 restore
02009608 <fpathconf>:
*/
long fpathconf(
int fd,
int name
)
{
2009608: 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);
200960c: 03 00 80 48 sethi %hi(0x2012000), %g1
2009610: c2 00 61 c8 ld [ %g1 + 0x1c8 ], %g1 ! 20121c8 <rtems_libio_number_iops>
2009614: 80 a6 00 01 cmp %i0, %g1
2009618: 2a 80 00 03 bcs,a 2009624 <fpathconf+0x1c>
200961c: 83 2e 20 03 sll %i0, 3, %g1
2009620: 30 80 00 0a b,a 2009648 <fpathconf+0x40>
iop = rtems_libio_iop(fd);
2009624: b1 2e 20 06 sll %i0, 6, %i0
2009628: b0 26 00 01 sub %i0, %g1, %i0
200962c: 03 00 80 4a sethi %hi(0x2012800), %g1
2009630: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 20129f0 <rtems_libio_iops>
2009634: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_is_open(iop);
2009638: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
200963c: 80 88 61 00 btst 0x100, %g1
2009640: 32 80 00 06 bne,a 2009658 <fpathconf+0x50> <== ALWAYS TAKEN
2009644: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
2009648: 40 00 08 f5 call 200ba1c <__errno>
200964c: 01 00 00 00 nop
2009650: 10 80 00 32 b 2009718 <fpathconf+0x110>
2009654: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
2009658: 80 a6 60 0b cmp %i1, 0xb
200965c: 18 80 00 2c bgu 200970c <fpathconf+0x104>
2009660: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
2009664: b3 2e 60 02 sll %i1, 2, %i1
2009668: 05 00 80 25 sethi %hi(0x2009400), %g2
200966c: 84 10 a1 d8 or %g2, 0x1d8, %g2 ! 20095d8 <_close_r+0x10>
2009670: c4 00 80 19 ld [ %g2 + %i1 ], %g2
2009674: 81 c0 80 00 jmp %g2
2009678: 01 00 00 00 nop
case _PC_LINK_MAX:
return_value = the_limits->link_max;
200967c: f0 00 40 00 ld [ %g1 ], %i0
break;
2009680: 81 c7 e0 08 ret
2009684: 81 e8 00 00 restore
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
2009688: f0 00 60 04 ld [ %g1 + 4 ], %i0
break;
200968c: 81 c7 e0 08 ret
2009690: 81 e8 00 00 restore
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
2009694: f0 00 60 08 ld [ %g1 + 8 ], %i0
break;
2009698: 81 c7 e0 08 ret
200969c: 81 e8 00 00 restore
case _PC_NAME_MAX:
return_value = the_limits->name_max;
20096a0: f0 00 60 0c ld [ %g1 + 0xc ], %i0
break;
20096a4: 81 c7 e0 08 ret
20096a8: 81 e8 00 00 restore
case _PC_PATH_MAX:
return_value = the_limits->path_max;
20096ac: f0 00 60 10 ld [ %g1 + 0x10 ], %i0
break;
20096b0: 81 c7 e0 08 ret
20096b4: 81 e8 00 00 restore
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
20096b8: f0 00 60 14 ld [ %g1 + 0x14 ], %i0
break;
20096bc: 81 c7 e0 08 ret
20096c0: 81 e8 00 00 restore
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
20096c4: f0 00 60 1c ld [ %g1 + 0x1c ], %i0
break;
20096c8: 81 c7 e0 08 ret
20096cc: 81 e8 00 00 restore
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
20096d0: f0 00 60 20 ld [ %g1 + 0x20 ], %i0
break;
20096d4: 81 c7 e0 08 ret
20096d8: 81 e8 00 00 restore
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
20096dc: f0 00 60 2c ld [ %g1 + 0x2c ], %i0
break;
20096e0: 81 c7 e0 08 ret
20096e4: 81 e8 00 00 restore
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
20096e8: f0 00 60 18 ld [ %g1 + 0x18 ], %i0
break;
20096ec: 81 c7 e0 08 ret
20096f0: 81 e8 00 00 restore
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
20096f4: f0 00 60 24 ld [ %g1 + 0x24 ], %i0
break;
20096f8: 81 c7 e0 08 ret
20096fc: 81 e8 00 00 restore
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
2009700: f0 00 60 28 ld [ %g1 + 0x28 ], %i0
break;
2009704: 81 c7 e0 08 ret
2009708: 81 e8 00 00 restore
default:
rtems_set_errno_and_return_minus_one( EINVAL );
200970c: 40 00 08 c4 call 200ba1c <__errno>
2009710: 01 00 00 00 nop
2009714: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2009718: c2 22 00 00 st %g1, [ %o0 ]
break;
}
return return_value;
}
200971c: 81 c7 e0 08 ret
2009720: 91 e8 3f ff restore %g0, -1, %o0
020035b0 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
20035b0: 9d e3 bf a0 save %sp, -96, %sp
MSBUMP(free_calls, 1);
20035b4: 03 00 80 75 sethi %hi(0x201d400), %g1
20035b8: 82 10 60 50 or %g1, 0x50, %g1 ! 201d450 <rtems_malloc_statistics>
20035bc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
#include <stdlib.h>
void free(
void *ptr
)
{
20035c0: b2 10 00 18 mov %i0, %i1
MSBUMP(free_calls, 1);
20035c4: 84 00 a0 01 inc %g2
if ( !ptr )
20035c8: 80 a6 20 00 cmp %i0, 0
20035cc: 02 80 00 21 be 2003650 <free+0xa0>
20035d0: 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()) &&
20035d4: 03 00 80 76 sethi %hi(0x201d800), %g1
20035d8: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 201dae8 <_System_state_Current>
20035dc: 80 a0 60 03 cmp %g1, 3
20035e0: 12 80 00 09 bne 2003604 <free+0x54> <== NEVER TAKEN
20035e4: 03 00 80 74 sethi %hi(0x201d000), %g1
!malloc_is_system_state_OK() ) {
20035e8: 40 00 00 78 call 20037c8 <malloc_is_system_state_OK>
20035ec: 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()) &&
20035f0: 80 8a 20 ff btst 0xff, %o0
20035f4: 12 80 00 04 bne 2003604 <free+0x54>
20035f8: 03 00 80 74 sethi %hi(0x201d000), %g1
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
20035fc: 40 00 00 8c call 200382c <malloc_deferred_free>
2003600: 81 e8 00 00 restore
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
2003604: c2 00 61 90 ld [ %g1 + 0x190 ], %g1
2003608: 80 a0 60 00 cmp %g1, 0
200360c: 02 80 00 06 be 2003624 <free+0x74>
2003610: 3b 00 80 72 sethi %hi(0x201c800), %i5
(*rtems_malloc_statistics_helpers->at_free)(ptr);
2003614: c2 00 60 08 ld [ %g1 + 8 ], %g1
2003618: 9f c0 40 00 call %g1
200361c: 90 10 00 19 mov %i1, %o0
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
2003620: 3b 00 80 72 sethi %hi(0x201c800), %i5
2003624: d0 07 61 b0 ld [ %i5 + 0x1b0 ], %o0 ! 201c9b0 <RTEMS_Malloc_Heap>
2003628: 40 00 17 72 call 20093f0 <_Protected_heap_Free>
200362c: 92 10 00 19 mov %i1, %o1
2003630: 80 8a 20 ff btst 0xff, %o0
2003634: 12 80 00 07 bne 2003650 <free+0xa0>
2003638: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %g1
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
200363c: 31 00 80 6c sethi %hi(0x201b000), %i0
2003640: f4 00 60 18 ld [ %g1 + 0x18 ], %i2
2003644: f6 00 60 1c ld [ %g1 + 0x1c ], %i3
2003648: 40 00 03 68 call 20043e8 <printk>
200364c: 91 ee 23 08 restore %i0, 0x308, %o0
2003650: 81 c7 e0 08 ret
2003654: 81 e8 00 00 restore
02019c8c <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
2019c8c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
2019c90: 80 a6 60 00 cmp %i1, 0
2019c94: 32 80 00 06 bne,a 2019cac <fstat+0x20> <== ALWAYS TAKEN
2019c98: 03 00 80 72 sethi %hi(0x201c800), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
2019c9c: 7f ff d6 74 call 200f66c <__errno> <== NOT EXECUTED
2019ca0: 01 00 00 00 nop <== NOT EXECUTED
2019ca4: 10 80 00 12 b 2019cec <fstat+0x60> <== NOT EXECUTED
2019ca8: 82 10 20 0e mov 0xe, %g1 ! e <PROM_START+0xe> <== NOT EXECUTED
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
2019cac: c2 00 61 f4 ld [ %g1 + 0x1f4 ], %g1
2019cb0: 80 a6 00 01 cmp %i0, %g1
2019cb4: 1a 80 00 0b bcc 2019ce0 <fstat+0x54>
2019cb8: 83 2e 20 03 sll %i0, 3, %g1
2019cbc: b1 2e 20 06 sll %i0, 6, %i0
2019cc0: b0 26 00 01 sub %i0, %g1, %i0
2019cc4: 03 00 80 75 sethi %hi(0x201d400), %g1
2019cc8: c2 00 60 44 ld [ %g1 + 0x44 ], %g1 ! 201d444 <rtems_libio_iops>
2019ccc: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
2019cd0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
2019cd4: 80 88 61 00 btst 0x100, %g1
2019cd8: 12 80 00 08 bne 2019cf8 <fstat+0x6c>
2019cdc: 94 10 20 48 mov 0x48, %o2
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
2019ce0: 7f ff d6 63 call 200f66c <__errno>
2019ce4: 01 00 00 00 nop
2019ce8: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
2019cec: c2 22 00 00 st %g1, [ %o0 ]
2019cf0: 81 c7 e0 08 ret
2019cf4: 91 e8 3f ff restore %g0, -1, %o0
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
2019cf8: 90 10 00 19 mov %i1, %o0
2019cfc: 7f ff d8 ea call 20100a4 <memset>
2019d00: 92 10 20 00 clr %o1
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
2019d04: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
2019d08: 90 06 20 14 add %i0, 0x14, %o0
2019d0c: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
2019d10: 9f c0 40 00 call %g1
2019d14: 92 10 00 19 mov %i1, %o1
}
2019d18: 81 c7 e0 08 ret
2019d1c: 91 e8 00 08 restore %g0, %o0, %o0
020034c8 <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) {
20034c8: 03 00 80 85 sethi %hi(0x2021400), %g1
20034cc: c2 00 61 30 ld [ %g1 + 0x130 ], %g1 ! 2021530 <disktab_size>
20034d0: 80 a2 00 01 cmp %o0, %g1
20034d4: 1a 80 00 1e bcc 200354c <get_disk_entry+0x84> <== NEVER TAKEN
20034d8: 03 00 80 85 sethi %hi(0x2021400), %g1
20034dc: c2 00 61 34 ld [ %g1 + 0x134 ], %g1 ! 2021534 <disktab>
20034e0: 80 a0 60 00 cmp %g1, 0
20034e4: 22 80 00 1b be,a 2003550 <get_disk_entry+0x88> <== NEVER TAKEN
20034e8: 90 10 20 00 clr %o0 <== NOT EXECUTED
rtems_disk_device_table *dtab = disktab + major;
20034ec: 91 2a 20 03 sll %o0, 3, %o0
20034f0: 84 00 40 08 add %g1, %o0, %g2
if (minor < dtab->size && dtab->minor != NULL) {
20034f4: c4 00 a0 04 ld [ %g2 + 4 ], %g2
20034f8: 80 a2 40 02 cmp %o1, %g2
20034fc: 3a 80 00 15 bcc,a 2003550 <get_disk_entry+0x88> <== NEVER TAKEN
2003500: 90 10 20 00 clr %o0 <== NOT EXECUTED
2003504: c2 00 40 08 ld [ %g1 + %o0 ], %g1
2003508: 80 a0 60 00 cmp %g1, 0
200350c: 02 80 00 10 be 200354c <get_disk_entry+0x84> <== NEVER TAKEN
2003510: 93 2a 60 02 sll %o1, 2, %o1
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && !lookup_only) {
2003514: 80 a2 a0 01 cmp %o2, 1
2003518: 02 80 00 0e be 2003550 <get_disk_entry+0x88>
200351c: d0 00 40 09 ld [ %g1 + %o1 ], %o0
2003520: 80 a2 20 00 cmp %o0, 0
2003524: 02 80 00 0b be 2003550 <get_disk_entry+0x88> <== NEVER TAKEN
2003528: 01 00 00 00 nop
if (!dd->deleted) {
200352c: c2 0a 20 40 ldub [ %o0 + 0x40 ], %g1
2003530: 80 a0 60 00 cmp %g1, 0
2003534: 32 80 00 07 bne,a 2003550 <get_disk_entry+0x88>
2003538: 90 10 20 00 clr %o0
++dd->uses;
200353c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
2003540: 82 00 60 01 inc %g1
2003544: 81 c3 e0 08 retl
2003548: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
return dd;
}
}
return NULL;
200354c: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
2003550: 81 c3 e0 08 retl
020048b4 <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,
20048b4: 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);
20048b8: 40 00 05 85 call 2005ecc <malloc>
20048bc: 90 10 22 04 mov 0x204, %o0
if (s == NULL)
{
return RTEMS_NO_MEMORY;
20048c0: 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)
20048c4: 80 a2 20 00 cmp %o0, 0
20048c8: 02 80 00 0f be 2004904 <get_sector.part.0+0x50> <== NEVER TAKEN
20048cc: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);
20048d0: 90 10 00 18 mov %i0, %o0
20048d4: 92 07 60 04 add %i5, 4, %o1
20048d8: 40 00 08 43 call 20069e4 <read>
20048dc: 94 10 22 00 mov 0x200, %o2
if (n != RTEMS_IDE_SECTOR_SIZE)
20048e0: 80 a2 22 00 cmp %o0, 0x200
20048e4: 22 80 00 06 be,a 20048fc <get_sector.part.0+0x48> <== ALWAYS TAKEN
20048e8: f2 27 40 00 st %i1, [ %i5 ]
{
free(s);
20048ec: 40 00 03 e7 call 2005888 <free> <== NOT EXECUTED
20048f0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
20048f4: 10 80 00 04 b 2004904 <get_sector.part.0+0x50> <== NOT EXECUTED
20048f8: 82 10 20 1b mov 0x1b, %g1 <== NOT EXECUTED
}
s->sector_num = sector_num;
*sector = s;
20048fc: fa 26 80 00 st %i5, [ %i2 ]
return RTEMS_SUCCESSFUL;
2004900: 82 10 20 00 clr %g1
}
2004904: 81 c7 e0 08 ret
2004908: 91 e8 00 01 restore %g0, %g1, %o0
0202f964 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
202f964: 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 );
202f968: 03 00 80 d7 sethi %hi(0x2035c00), %g1
202f96c: c2 00 60 8c ld [ %g1 + 0x8c ], %g1 ! 2035c8c <rtems_libio_number_iops>
202f970: 80 a6 00 01 cmp %i0, %g1
202f974: 1a 80 00 08 bcc 202f994 <getdents+0x30> <== NEVER TAKEN
202f978: ba 10 20 00 clr %i5
202f97c: 83 2e 20 03 sll %i0, 3, %g1
202f980: b1 2e 20 06 sll %i0, 6, %i0
202f984: b0 26 00 01 sub %i0, %g1, %i0
202f988: 03 00 81 1a sethi %hi(0x2046800), %g1
202f98c: fa 00 60 38 ld [ %g1 + 0x38 ], %i5 ! 2046838 <rtems_libio_iops>
202f990: ba 07 40 18 add %i5, %i0, %i5
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
202f994: 7f ff 69 64 call 2009f24 <rtems_filesystem_node_type>
202f998: 90 07 60 14 add %i5, 0x14, %o0
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
202f99c: 80 a2 20 00 cmp %o0, 0
202f9a0: 22 80 00 08 be,a 202f9c0 <getdents+0x5c>
202f9a4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
rtems_set_errno_and_return_minus_one( ENOTDIR );
202f9a8: 7f ff c4 1e call 2020a20 <__errno>
202f9ac: b0 10 3f ff mov -1, %i0
202f9b0: 82 10 20 14 mov 0x14, %g1
202f9b4: c2 22 00 00 st %g1, [ %o0 ]
202f9b8: 81 c7 e0 08 ret
202f9bc: 81 e8 00 00 restore
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len );
202f9c0: 90 10 00 1d mov %i5, %o0
202f9c4: c2 00 60 08 ld [ %g1 + 8 ], %g1
202f9c8: 92 10 00 19 mov %i1, %o1
202f9cc: 9f c0 40 00 call %g1
202f9d0: 94 10 00 1a mov %i2, %o2
}
202f9d4: 81 c7 e0 08 ret
202f9d8: 91 e8 00 08 restore %g0, %o0, %o0
020242d0 <init_etc_passwd_group>:
/**
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
20242d0: 9d e3 bf a0 save %sp, -96, %sp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
20242d4: 03 00 81 86 sethi %hi(0x2061800), %g1
20242d8: c4 48 60 c0 ldsb [ %g1 + 0xc0 ], %g2 ! 20618c0 <etc_passwd_initted.7073>
20242dc: 80 a0 a0 00 cmp %g2, 0
20242e0: 12 80 00 2f bne 202439c <init_etc_passwd_group+0xcc>
20242e4: 84 10 20 01 mov 1, %g2
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
20242e8: 92 10 21 ff mov 0x1ff, %o1
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
20242ec: c4 28 60 c0 stb %g2, [ %g1 + 0xc0 ]
mkdir("/etc", 0777);
20242f0: 11 00 81 63 sethi %hi(0x2058c00), %o0
20242f4: 7f ff 7d 25 call 2003788 <mkdir>
20242f8: 90 12 20 28 or %o0, 0x28, %o0 ! 2058c28 <RTEMS_BDPART_MBR_MASTER_TYPE+0x6f8>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
20242fc: 3b 00 81 63 sethi %hi(0x2058c00), %i5
2024300: 13 00 81 75 sethi %hi(0x205d400), %o1
2024304: 90 17 60 30 or %i5, 0x30, %o0
2024308: 40 00 4c 83 call 2037514 <fopen>
202430c: 92 12 61 38 or %o1, 0x138, %o1
2024310: 80 a2 20 00 cmp %o0, 0
2024314: 22 80 00 03 be,a 2024320 <init_etc_passwd_group+0x50>
2024318: 90 17 60 30 or %i5, 0x30, %o0
202431c: 30 80 00 0b b,a 2024348 <init_etc_passwd_group+0x78>
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
2024320: 13 00 81 5a sethi %hi(0x2056800), %o1
2024324: 40 00 4c 7c call 2037514 <fopen>
2024328: 92 12 63 e0 or %o1, 0x3e0, %o1 ! 2056be0 <rtems_rtc_shell_usage+0x4e8>
202432c: ba 92 20 00 orcc %o0, 0, %i5
2024330: 02 80 00 08 be 2024350 <init_etc_passwd_group+0x80> <== NEVER TAKEN
2024334: 11 00 81 63 sethi %hi(0x2058c00), %o0
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
2024338: 92 10 00 1d mov %i5, %o1
202433c: 40 00 4c d9 call 20376a0 <fputs>
2024340: 90 12 20 40 or %o0, 0x40, %o0
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
2024344: 90 10 00 1d mov %i5, %o0
2024348: 40 00 4a 15 call 2036b9c <fclose>
202434c: 01 00 00 00 nop
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
2024350: 3b 00 81 63 sethi %hi(0x2058c00), %i5
2024354: 13 00 81 75 sethi %hi(0x205d400), %o1
2024358: 90 17 60 a8 or %i5, 0xa8, %o0
202435c: 40 00 4c 6e call 2037514 <fopen>
2024360: 92 12 61 38 or %o1, 0x138, %o1
2024364: b0 92 20 00 orcc %o0, 0, %i0
2024368: 12 80 00 0b bne 2024394 <init_etc_passwd_group+0xc4>
202436c: 90 17 60 a8 or %i5, 0xa8, %o0
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
2024370: 13 00 81 5a sethi %hi(0x2056800), %o1
2024374: 40 00 4c 68 call 2037514 <fopen>
2024378: 92 12 63 e0 or %o1, 0x3e0, %o1 ! 2056be0 <rtems_rtc_shell_usage+0x4e8>
202437c: b0 92 20 00 orcc %o0, 0, %i0
2024380: 02 80 00 07 be 202439c <init_etc_passwd_group+0xcc> <== NEVER TAKEN
2024384: 11 00 81 63 sethi %hi(0x2058c00), %o0
fprintf( fp, "root:x:0:root\n"
2024388: 92 10 00 18 mov %i0, %o1
202438c: 40 00 4c c5 call 20376a0 <fputs>
2024390: 90 12 20 b8 or %o0, 0xb8, %o0
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
2024394: 40 00 4a 02 call 2036b9c <fclose>
2024398: 81 e8 00 00 restore
202439c: 81 c7 e0 08 ret
20243a0: 81 e8 00 00 restore
0200614c <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
200614c: 9d e3 bf a0 save %sp, -96, %sp
if (tty->termios.c_iflag & ISTRIP)
2006150: c2 06 60 30 ld [ %i1 + 0x30 ], %g1
2006154: 80 88 60 20 btst 0x20, %g1
2006158: 32 80 00 02 bne,a 2006160 <iproc+0x14> <== NEVER TAKEN
200615c: b0 0e 20 7f and %i0, 0x7f, %i0 <== NOT EXECUTED
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
2006160: 80 88 62 00 btst 0x200, %g1
2006164: 02 80 00 0c be 2006194 <iproc+0x48>
2006168: 80 a6 20 0d cmp %i0, 0xd
c = tolower (c);
200616c: 05 00 80 73 sethi %hi(0x201cc00), %g2
2006170: c4 00 a0 58 ld [ %g2 + 0x58 ], %g2 ! 201cc58 <__ctype_ptr__>
2006174: 84 00 80 18 add %g2, %i0, %g2
2006178: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
200617c: 84 08 a0 03 and %g2, 3, %g2
2006180: 80 a0 a0 01 cmp %g2, 1
2006184: 22 80 00 02 be,a 200618c <iproc+0x40>
2006188: b0 06 20 20 add %i0, 0x20, %i0
200618c: b0 0e 20 ff and %i0, 0xff, %i0
if (c == '\r') {
2006190: 80 a6 20 0d cmp %i0, 0xd
2006194: 12 80 00 0b bne 20061c0 <iproc+0x74>
2006198: 80 a6 20 0a cmp %i0, 0xa
if (tty->termios.c_iflag & IGNCR)
200619c: 80 88 60 80 btst 0x80, %g1
20061a0: 02 80 00 04 be 20061b0 <iproc+0x64> <== ALWAYS TAKEN
20061a4: 80 88 61 00 btst 0x100, %g1
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
20061a8: 81 c7 e0 08 ret <== NOT EXECUTED
20061ac: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
20061b0: 32 80 00 0d bne,a 20061e4 <iproc+0x98> <== ALWAYS TAKEN
20061b4: 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)) {
20061b8: 10 80 00 0c b 20061e8 <iproc+0x9c> <== NOT EXECUTED
20061bc: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
20061c0: 12 80 00 07 bne 20061dc <iproc+0x90>
20061c4: 80 a6 20 00 cmp %i0, 0
20061c8: 80 88 60 40 btst 0x40, %g1
20061cc: 32 80 00 06 bne,a 20061e4 <iproc+0x98> <== NEVER TAKEN
20061d0: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
20061d4: 10 80 00 05 b 20061e8 <iproc+0x9c>
20061d8: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
20061dc: 02 80 00 51 be 2006320 <iproc+0x1d4> <== NEVER TAKEN
20061e0: 03 00 80 72 sethi %hi(0x201c800), %g1
20061e4: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
20061e8: 80 88 60 02 btst 2, %g1
20061ec: 22 80 00 4d be,a 2006320 <iproc+0x1d4>
20061f0: 03 00 80 72 sethi %hi(0x201c800), %g1
if (c == tty->termios.c_cc[VERASE]) {
20061f4: c4 0e 60 43 ldub [ %i1 + 0x43 ], %g2
20061f8: 80 a0 80 18 cmp %g2, %i0
20061fc: 32 80 00 08 bne,a 200621c <iproc+0xd0>
2006200: c4 0e 60 44 ldub [ %i1 + 0x44 ], %g2
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
2006204: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2006208: 80 a0 60 00 cmp %g1, 0
200620c: 02 80 00 57 be 2006368 <iproc+0x21c>
2006210: 90 10 00 19 mov %i1, %o0
2006214: 10 80 00 1d b 2006288 <iproc+0x13c>
2006218: 92 10 20 00 clr %o1
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
200621c: 80 a0 80 18 cmp %g2, %i0
2006220: 32 80 00 1d bne,a 2006294 <iproc+0x148>
2006224: c4 0e 60 45 ldub [ %i1 + 0x45 ], %g2
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
2006228: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
200622c: 80 a0 a0 00 cmp %g2, 0
2006230: 02 80 00 4e be 2006368 <iproc+0x21c> <== NEVER TAKEN
2006234: 80 88 60 08 btst 8, %g1
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
2006238: 12 80 00 04 bne 2006248 <iproc+0xfc> <== ALWAYS TAKEN
200623c: 90 10 00 19 mov %i1, %o0
tty->ccount = 0;
2006240: 10 80 00 4a b 2006368 <iproc+0x21c> <== NOT EXECUTED
2006244: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
2006248: 80 88 60 10 btst 0x10, %g1
200624c: 12 80 00 0f bne 2006288 <iproc+0x13c> <== ALWAYS TAKEN
2006250: 92 10 20 01 mov 1, %o1
tty->ccount = 0;
2006254: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
2006258: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200625c: 7f ff ff 2d call 2005f10 <echo> <== NOT EXECUTED
2006260: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
2006264: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
2006268: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
200626c: 22 80 00 42 be,a 2006374 <iproc+0x228> <== NOT EXECUTED
2006270: b0 10 20 00 clr %i0 <== NOT EXECUTED
echo ('\n', tty);
2006274: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
2006278: 7f ff ff 26 call 2005f10 <echo> <== NOT EXECUTED
200627c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
2006280: 81 c7 e0 08 ret <== NOT EXECUTED
2006284: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
2006288: 7f ff ff 43 call 2005f94 <erase.part.2>
200628c: b0 10 20 00 clr %i0
2006290: 30 80 00 39 b,a 2006374 <iproc+0x228>
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
2006294: 80 a0 80 18 cmp %g2, %i0
2006298: 02 80 00 36 be 2006370 <iproc+0x224> <== NEVER TAKEN
200629c: 80 a6 20 0a cmp %i0, 0xa
return 1;
} else if (c == '\n') {
20062a0: 32 80 00 0d bne,a 20062d4 <iproc+0x188>
20062a4: c4 0e 60 4c ldub [ %i1 + 0x4c ], %g2
if (tty->termios.c_lflag & (ECHO | ECHONL))
20062a8: 80 88 60 48 btst 0x48, %g1
20062ac: 22 80 00 06 be,a 20062c4 <iproc+0x178> <== NEVER TAKEN
20062b0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
20062b4: 90 10 20 0a mov 0xa, %o0
20062b8: 7f ff ff 16 call 2005f10 <echo>
20062bc: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
20062c0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20062c4: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
20062c8: 86 10 20 0a mov 0xa, %g3
20062cc: 10 80 00 12 b 2006314 <iproc+0x1c8>
20062d0: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
20062d4: 80 a0 80 18 cmp %g2, %i0
20062d8: 02 80 00 07 be 20062f4 <iproc+0x1a8> <== NEVER TAKEN
20062dc: 80 88 60 08 btst 8, %g1
20062e0: c4 0e 60 51 ldub [ %i1 + 0x51 ], %g2
20062e4: 80 a0 80 18 cmp %g2, %i0
20062e8: 32 80 00 0e bne,a 2006320 <iproc+0x1d4> <== ALWAYS TAKEN
20062ec: 03 00 80 72 sethi %hi(0x201c800), %g1
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
20062f0: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
20062f4: 22 80 00 06 be,a 200630c <iproc+0x1c0> <== NOT EXECUTED
20062f8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
20062fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2006300: 7f ff ff 04 call 2005f10 <echo> <== NOT EXECUTED
2006304: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
2006308: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
200630c: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED
2006310: f0 28 80 01 stb %i0, [ %g2 + %g1 ] <== NOT EXECUTED
2006314: 82 00 60 01 inc %g1
2006318: 10 80 00 16 b 2006370 <iproc+0x224>
200631c: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
2006320: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
2006324: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1
2006328: 82 00 7f ff add %g1, -1, %g1
200632c: 80 a0 80 01 cmp %g2, %g1
2006330: 3a 80 00 11 bcc,a 2006374 <iproc+0x228> <== NEVER TAKEN
2006334: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
2006338: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
200633c: 80 88 60 08 btst 8, %g1
2006340: 22 80 00 06 be,a 2006358 <iproc+0x20c> <== NEVER TAKEN
2006344: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
2006348: 90 10 00 18 mov %i0, %o0
200634c: 7f ff fe f1 call 2005f10 <echo>
2006350: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
2006354: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2006358: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
200635c: f0 28 80 01 stb %i0, [ %g2 + %g1 ]
2006360: 82 00 60 01 inc %g1
2006364: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
}
return 0;
2006368: 81 c7 e0 08 ret
200636c: 91 e8 20 00 restore %g0, 0, %o0
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
2006370: b0 10 20 01 mov 1, %i0
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
}
2006374: 81 c7 e0 08 ret
2006378: 81 e8 00 00 restore
02019f90 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
2019f90: 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() )
2019f94: 7f ff ff 68 call 2019d34 <getpid>
2019f98: 01 00 00 00 nop
2019f9c: 80 a6 00 08 cmp %i0, %o0
2019fa0: 02 80 00 06 be 2019fb8 <killinfo+0x28>
2019fa4: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
2019fa8: 7f ff d5 b1 call 200f66c <__errno>
2019fac: 01 00 00 00 nop
2019fb0: 10 80 00 a6 b 201a248 <killinfo+0x2b8>
2019fb4: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3>
/*
* Validate the signal passed.
*/
if ( !sig )
2019fb8: 32 80 00 03 bne,a 2019fc4 <killinfo+0x34>
2019fbc: ba 06 7f ff add %i1, -1, %i5
2019fc0: 30 80 00 04 b,a 2019fd0 <killinfo+0x40>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
2019fc4: 80 a7 60 1f cmp %i5, 0x1f
2019fc8: 28 80 00 06 bleu,a 2019fe0 <killinfo+0x50>
2019fcc: 83 2e 60 02 sll %i1, 2, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
2019fd0: 7f ff d5 a7 call 200f66c <__errno>
2019fd4: 01 00 00 00 nop
2019fd8: 10 80 00 9c b 201a248 <killinfo+0x2b8>
2019fdc: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
2019fe0: 85 2e 60 04 sll %i1, 4, %g2
2019fe4: 84 20 80 01 sub %g2, %g1, %g2
2019fe8: 03 00 80 76 sethi %hi(0x201d800), %g1
2019fec: 82 10 63 50 or %g1, 0x350, %g1 ! 201db50 <_POSIX_signals_Vectors>
2019ff0: 82 00 40 02 add %g1, %g2, %g1
2019ff4: c2 00 60 08 ld [ %g1 + 8 ], %g1
2019ff8: 80 a0 60 01 cmp %g1, 1
2019ffc: 02 80 00 9f be 201a278 <killinfo+0x2e8>
201a000: 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 ) )
201a004: 02 80 00 06 be 201a01c <killinfo+0x8c>
201a008: 80 a6 60 08 cmp %i1, 8
201a00c: 02 80 00 04 be 201a01c <killinfo+0x8c>
201a010: 80 a6 60 0b cmp %i1, 0xb
201a014: 12 80 00 08 bne 201a034 <killinfo+0xa4>
201a018: 82 10 20 01 mov 1, %g1
return pthread_kill( pthread_self(), sig );
201a01c: 40 00 01 33 call 201a4e8 <pthread_self>
201a020: 01 00 00 00 nop
201a024: 40 00 00 f4 call 201a3f4 <pthread_kill>
201a028: 92 10 00 19 mov %i1, %o1
201a02c: 81 c7 e0 08 ret
201a030: 91 e8 00 08 restore %g0, %o0, %o0
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
201a034: f2 27 bf f4 st %i1, [ %fp + -12 ]
siginfo->si_code = SI_USER;
201a038: c2 27 bf f8 st %g1, [ %fp + -8 ]
if ( !value ) {
201a03c: 80 a6 a0 00 cmp %i2, 0
201a040: 12 80 00 04 bne 201a050 <killinfo+0xc0>
201a044: bb 28 40 1d sll %g1, %i5, %i5
siginfo->si_value.sival_int = 0;
201a048: 10 80 00 04 b 201a058 <killinfo+0xc8>
201a04c: c0 27 bf fc clr [ %fp + -4 ]
} else {
siginfo->si_value = *value;
201a050: c2 06 80 00 ld [ %i2 ], %g1
201a054: 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;
201a058: 03 00 80 75 sethi %hi(0x201d400), %g1
201a05c: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 201d5d0 <_Thread_Dispatch_disable_level>
++level;
201a060: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
201a064: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ]
*/
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 );
201a068: 11 00 80 72 sethi %hi(0x201c800), %o0
201a06c: 7f ff b7 f9 call 2008050 <_API_extensions_Add_post_switch>
201a070: 90 12 23 a4 or %o0, 0x3a4, %o0 ! 201cba4 <_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;
201a074: 03 00 80 76 sethi %hi(0x201d800), %g1
201a078: d0 00 63 00 ld [ %g1 + 0x300 ], %o0 ! 201db00 <_Per_CPU_Information+0x10>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
201a07c: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
201a080: c4 00 a0 d0 ld [ %g2 + 0xd0 ], %g2
201a084: 80 af 40 02 andncc %i5, %g2, %g0
201a088: 12 80 00 52 bne 201a1d0 <killinfo+0x240>
201a08c: 03 00 80 77 sethi %hi(0x201dc00), %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 );
201a090: 05 00 80 77 sethi %hi(0x201dc00), %g2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
201a094: c2 00 60 dc ld [ %g1 + 0xdc ], %g1
201a098: 10 80 00 0a b 201a0c0 <killinfo+0x130>
201a09c: 84 10 a0 e0 or %g2, 0xe0, %g2
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
201a0a0: 80 8f 40 04 btst %i5, %g4
201a0a4: 12 80 00 4a bne 201a1cc <killinfo+0x23c>
201a0a8: c6 00 61 5c ld [ %g1 + 0x15c ], %g3
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
201a0ac: c6 00 e0 d0 ld [ %g3 + 0xd0 ], %g3
201a0b0: 80 af 40 03 andncc %i5, %g3, %g0
201a0b4: 12 80 00 47 bne 201a1d0 <killinfo+0x240>
201a0b8: 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 ) {
201a0bc: 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 );
201a0c0: 80 a0 40 02 cmp %g1, %g2
201a0c4: 32 bf ff f7 bne,a 201a0a0 <killinfo+0x110>
201a0c8: c8 00 60 30 ld [ %g1 + 0x30 ], %g4
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
201a0cc: 03 00 80 72 sethi %hi(0x201c800), %g1
201a0d0: c6 08 61 2c ldub [ %g1 + 0x12c ], %g3 ! 201c92c <rtems_maximum_priority>
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
201a0d4: b8 10 20 02 mov 2, %i4
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
201a0d8: 86 00 e0 01 inc %g3
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
201a0dc: 82 10 20 00 clr %g1
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
201a0e0: 1b 00 80 75 sethi %hi(0x201d400), %o5
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
201a0e4: 35 04 00 00 sethi %hi(0x10000000), %i2
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
201a0e8: 85 2f 20 02 sll %i4, 2, %g2
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
201a0ec: 88 13 61 34 or %o5, 0x134, %g4
201a0f0: c4 01 00 02 ld [ %g4 + %g2 ], %g2
201a0f4: 80 a0 a0 00 cmp %g2, 0
201a0f8: 22 80 00 2f be,a 201a1b4 <killinfo+0x224> <== NEVER TAKEN
201a0fc: b8 07 20 01 inc %i4 <== NOT EXECUTED
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
201a100: c4 00 a0 04 ld [ %g2 + 4 ], %g2
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201a104: b6 10 20 01 mov 1, %i3
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
201a108: d8 10 a0 10 lduh [ %g2 + 0x10 ], %o4
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201a10c: 10 80 00 26 b 201a1a4 <killinfo+0x214>
201a110: d6 00 a0 1c ld [ %g2 + 0x1c ], %o3
the_thread = (Thread_Control *) object_table[ index ];
201a114: c4 02 c0 02 ld [ %o3 + %g2 ], %g2
if ( !the_thread )
201a118: 80 a0 a0 00 cmp %g2, 0
201a11c: 22 80 00 22 be,a 201a1a4 <killinfo+0x214>
201a120: b6 06 e0 01 inc %i3
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
201a124: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
201a128: 80 a1 00 03 cmp %g4, %g3
201a12c: 38 80 00 1e bgu,a 201a1a4 <killinfo+0x214>
201a130: b6 06 e0 01 inc %i3
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
201a134: f0 00 a1 5c ld [ %g2 + 0x15c ], %i0
201a138: f0 06 20 d0 ld [ %i0 + 0xd0 ], %i0
201a13c: 80 af 40 18 andncc %i5, %i0, %g0
201a140: 22 80 00 19 be,a 201a1a4 <killinfo+0x214>
201a144: b6 06 e0 01 inc %i3
*
* NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1
* so we never have to worry about deferencing a NULL
* interested thread.
*/
if ( the_thread->current_priority < interested_priority ) {
201a148: 80 a1 00 03 cmp %g4, %g3
201a14c: 2a 80 00 14 bcs,a 201a19c <killinfo+0x20c>
201a150: 86 10 00 04 mov %g4, %g3
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
201a154: 80 a0 60 00 cmp %g1, 0
201a158: 22 80 00 13 be,a 201a1a4 <killinfo+0x214> <== NEVER TAKEN
201a15c: b6 06 e0 01 inc %i3 <== NOT EXECUTED
201a160: de 00 60 10 ld [ %g1 + 0x10 ], %o7
201a164: 80 a3 e0 00 cmp %o7, 0
201a168: 22 80 00 0f be,a 201a1a4 <killinfo+0x214> <== NEVER TAKEN
201a16c: b6 06 e0 01 inc %i3 <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
201a170: f0 00 a0 10 ld [ %g2 + 0x10 ], %i0
201a174: 80 a6 20 00 cmp %i0, 0
201a178: 22 80 00 09 be,a 201a19c <killinfo+0x20c>
201a17c: 86 10 00 04 mov %g4, %g3
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
201a180: 80 8b c0 1a btst %o7, %i2
201a184: 32 80 00 08 bne,a 201a1a4 <killinfo+0x214>
201a188: b6 06 e0 01 inc %i3
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
201a18c: 80 8e 00 1a btst %i0, %i2
201a190: 22 80 00 05 be,a 201a1a4 <killinfo+0x214>
201a194: b6 06 e0 01 inc %i3
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
201a198: 86 10 00 04 mov %g4, %g3
201a19c: 82 10 00 02 mov %g2, %g1
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201a1a0: b6 06 e0 01 inc %i3
201a1a4: 80 a6 c0 0c cmp %i3, %o4
201a1a8: 08 bf ff db bleu 201a114 <killinfo+0x184>
201a1ac: 85 2e e0 02 sll %i3, 2, %g2
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
201a1b0: b8 07 20 01 inc %i4
201a1b4: 80 a7 20 04 cmp %i4, 4
201a1b8: 12 bf ff cd bne 201a0ec <killinfo+0x15c>
201a1bc: 85 2f 20 02 sll %i4, 2, %g2
}
}
}
}
if ( interested ) {
201a1c0: 80 a0 60 00 cmp %g1, 0
201a1c4: 02 80 00 0c be 201a1f4 <killinfo+0x264>
201a1c8: 01 00 00 00 nop
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
201a1cc: 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 ) ) {
201a1d0: 92 10 00 19 mov %i1, %o1
201a1d4: 40 00 00 36 call 201a2ac <_POSIX_signals_Unblock_thread>
201a1d8: 94 07 bf f4 add %fp, -12, %o2
201a1dc: 80 8a 20 ff btst 0xff, %o0
201a1e0: 02 80 00 05 be 201a1f4 <killinfo+0x264>
201a1e4: 01 00 00 00 nop
_Thread_Enable_dispatch();
201a1e8: 7f ff bf 9a call 200a050 <_Thread_Enable_dispatch>
201a1ec: b0 10 20 00 clr %i0 ! 0 <PROM_START>
201a1f0: 30 80 00 23 b,a 201a27c <killinfo+0x2ec>
/*
* 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 );
201a1f4: 40 00 00 24 call 201a284 <_POSIX_signals_Set_process_signals>
201a1f8: 90 10 00 1d mov %i5, %o0
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
201a1fc: 83 2e 60 02 sll %i1, 2, %g1
201a200: b3 2e 60 04 sll %i1, 4, %i1
201a204: b2 26 40 01 sub %i1, %g1, %i1
201a208: 03 00 80 76 sethi %hi(0x201d800), %g1
201a20c: 82 10 63 50 or %g1, 0x350, %g1 ! 201db50 <_POSIX_signals_Vectors>
201a210: c2 00 40 19 ld [ %g1 + %i1 ], %g1
201a214: 80 a0 60 02 cmp %g1, 2
201a218: 12 bf ff f4 bne 201a1e8 <killinfo+0x258>
201a21c: 11 00 80 77 sethi %hi(0x201dc00), %o0
psiginfo = (POSIX_signals_Siginfo_node *)
201a220: 7f ff b7 f1 call 20081e4 <_Chain_Get>
201a224: 90 12 20 d0 or %o0, 0xd0, %o0 ! 201dcd0 <_POSIX_signals_Inactive_siginfo>
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
201a228: ba 92 20 00 orcc %o0, 0, %i5
201a22c: 12 80 00 0a bne 201a254 <killinfo+0x2c4>
201a230: 92 07 bf f4 add %fp, -12, %o1
_Thread_Enable_dispatch();
201a234: 7f ff bf 87 call 200a050 <_Thread_Enable_dispatch>
201a238: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EAGAIN );
201a23c: 7f ff d5 0c call 200f66c <__errno>
201a240: 01 00 00 00 nop
201a244: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
201a248: c2 22 00 00 st %g1, [ %o0 ]
201a24c: 81 c7 e0 08 ret
201a250: 91 e8 3f ff restore %g0, -1, %o0
}
psiginfo->Info = *siginfo;
201a254: 90 07 60 08 add %i5, 8, %o0
201a258: 7f ff d7 56 call 200ffb0 <memcpy>
201a25c: 94 10 20 0c mov 0xc, %o2
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
201a260: 11 00 80 77 sethi %hi(0x201dc00), %o0
201a264: 92 10 00 1d mov %i5, %o1
201a268: 90 12 21 48 or %o0, 0x148, %o0
201a26c: 7f ff b7 d2 call 20081b4 <_Chain_Append>
201a270: 90 02 00 19 add %o0, %i1, %o0
201a274: 30 bf ff dd b,a 201a1e8 <killinfo+0x258>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
return 0;
201a278: b0 10 20 00 clr %i0
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
201a27c: 81 c7 e0 08 ret
201a280: 81 e8 00 00 restore
02003e30 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
2003e30: 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()))
2003e34: 03 00 80 76 sethi %hi(0x201d800), %g1
2003e38: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 201dae8 <_System_state_Current>
2003e3c: 80 a0 60 03 cmp %g1, 3
2003e40: 12 80 00 16 bne 2003e98 <libc_wrapup+0x68> <== NEVER TAKEN
2003e44: 03 00 80 6f sethi %hi(0x201bc00), %g1
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
2003e48: 39 00 80 73 sethi %hi(0x201cc00), %i4
2003e4c: fa 00 62 a0 ld [ %g1 + 0x2a0 ], %i5
2003e50: c2 07 20 60 ld [ %i4 + 0x60 ], %g1
2003e54: 80 a0 40 1d cmp %g1, %i5
2003e58: 22 80 00 06 be,a 2003e70 <libc_wrapup+0x40>
2003e5c: 3b 00 80 73 sethi %hi(0x201cc00), %i5
_wrapup_reent(_global_impure_ptr);
2003e60: 40 00 31 32 call 2010328 <_wrapup_reent>
2003e64: 90 10 00 1d mov %i5, %o0
/* Don't reclaim this one, just in case we do printfs
* on the way out to ROM.
*/
_reclaim_reent(&libc_global_reent);
#endif
_REENT = _global_impure_ptr;
2003e68: fa 27 20 60 st %i5, [ %i4 + 0x60 ]
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
2003e6c: 3b 00 80 73 sethi %hi(0x201cc00), %i5
2003e70: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 ! 201cc60 <_impure_ptr>
2003e74: 40 00 2e 50 call 200f7b4 <fclose>
2003e78: d0 00 60 04 ld [ %g1 + 4 ], %o0
fclose (stdout);
2003e7c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2003e80: 40 00 2e 4d call 200f7b4 <fclose>
2003e84: d0 00 60 08 ld [ %g1 + 8 ], %o0
fclose (stderr);
2003e88: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2003e8c: f0 00 60 0c ld [ %g1 + 0xc ], %i0
2003e90: 40 00 2e 49 call 200f7b4 <fclose>
2003e94: 81 e8 00 00 restore
2003e98: 81 c7 e0 08 ret <== NOT EXECUTED
2003e9c: 81 e8 00 00 restore <== NOT EXECUTED
02003900 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
2003900: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
MSBUMP(malloc_calls, 1);
2003904: 03 00 80 75 sethi %hi(0x201d400), %g1
2003908: 82 10 60 50 or %g1, 0x50, %g1 ! 201d450 <rtems_malloc_statistics>
200390c: c4 00 60 04 ld [ %g1 + 4 ], %g2
2003910: 84 00 a0 01 inc %g2
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
2003914: 7f ff ff b9 call 20037f8 <malloc_deferred_frees_process>
2003918: c4 20 60 04 st %g2, [ %g1 + 4 ]
/*
* Validate the parameters
*/
if ( !size )
200391c: 80 a6 20 00 cmp %i0, 0
2003920: 12 80 00 04 bne 2003930 <malloc+0x30>
2003924: 03 00 80 76 sethi %hi(0x201d800), %g1
return (void *) 0;
2003928: 10 80 00 32 b 20039f0 <malloc+0xf0>
200392c: ba 10 20 00 clr %i5
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2003930: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1
2003934: 80 a0 60 03 cmp %g1, 3
2003938: 02 80 00 0c be 2003968 <malloc+0x68>
200393c: 39 00 80 72 sethi %hi(0x201c800), %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 );
2003940: d0 07 21 b0 ld [ %i4 + 0x1b0 ], %o0 ! 201c9b0 <RTEMS_Malloc_Heap>
2003944: 92 10 00 18 mov %i0, %o1
2003948: 94 10 20 00 clr %o2
200394c: 40 00 16 9b call 20093b8 <_Protected_heap_Allocate_aligned_with_boundary>
2003950: 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 ) {
2003954: ba 92 20 00 orcc %o0, 0, %i5
2003958: 12 80 00 18 bne 20039b8 <malloc+0xb8>
200395c: 03 00 80 74 sethi %hi(0x201d000), %g1
return_this = (*rtems_malloc_extend_handler)( RTEMS_Malloc_Heap, size );
2003960: 10 80 00 09 b 2003984 <malloc+0x84>
2003964: d0 07 21 b0 ld [ %i4 + 0x1b0 ], %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() )
2003968: 7f ff ff 98 call 20037c8 <malloc_is_system_state_OK>
200396c: 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()) &&
2003970: 80 8a 20 ff btst 0xff, %o0
2003974: 12 bf ff f3 bne 2003940 <malloc+0x40> <== ALWAYS TAKEN
2003978: 01 00 00 00 nop
200397c: 10 80 00 1d b 20039f0 <malloc+0xf0> <== NOT EXECUTED
2003980: ba 10 20 00 clr %i5 ! 0 <PROM_START> <== NOT EXECUTED
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
return_this = (*rtems_malloc_extend_handler)( RTEMS_Malloc_Heap, size );
2003984: 03 00 80 69 sethi %hi(0x201a400), %g1
2003988: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1 ! 201a7c0 <rtems_malloc_extend_handler>
200398c: 9f c0 40 00 call %g1
2003990: 92 10 00 18 mov %i0, %o1
if ( !return_this ) {
2003994: ba 92 20 00 orcc %o0, 0, %i5
2003998: 12 80 00 08 bne 20039b8 <malloc+0xb8> <== NEVER TAKEN
200399c: 03 00 80 74 sethi %hi(0x201d000), %g1
errno = ENOMEM;
20039a0: 40 00 2f 33 call 200f66c <__errno>
20039a4: b0 10 00 1d mov %i5, %i0
20039a8: 82 10 20 0c mov 0xc, %g1
20039ac: c2 22 00 00 st %g1, [ %o0 ]
20039b0: 81 c7 e0 08 ret
20039b4: 81 e8 00 00 restore
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
20039b8: c2 00 61 8c ld [ %g1 + 0x18c ], %g1
20039bc: 80 a0 60 00 cmp %g1, 0
20039c0: 02 80 00 04 be 20039d0 <malloc+0xd0>
20039c4: 90 10 00 1d mov %i5, %o0
(*rtems_malloc_dirty_helper)( return_this, size );
20039c8: 9f c0 40 00 call %g1
20039cc: 92 10 00 18 mov %i0, %o1
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
20039d0: 03 00 80 74 sethi %hi(0x201d000), %g1
20039d4: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 201d190 <rtems_malloc_statistics_helpers>
20039d8: 80 a0 60 00 cmp %g1, 0
20039dc: 22 80 00 06 be,a 20039f4 <malloc+0xf4>
20039e0: b0 10 00 1d mov %i5, %i0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
20039e4: c2 00 60 04 ld [ %g1 + 4 ], %g1
20039e8: 9f c0 40 00 call %g1
20039ec: 90 10 00 1d mov %i5, %o0
return return_this;
}
20039f0: b0 10 00 1d mov %i5, %i0
20039f4: 81 c7 e0 08 ret
20039f8: 81 e8 00 00 restore
0200dcc8 <memfile_alloc_block>:
* Allocate a block for an in-memory file.
*/
int memfile_blocks_allocated = 0;
void *memfile_alloc_block(void)
{
200dcc8: 9d e3 bf a0 save %sp, -96, %sp
void *memory;
memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);
200dccc: 03 00 80 74 sethi %hi(0x201d000), %g1
200dcd0: d2 00 61 b8 ld [ %g1 + 0x1b8 ], %o1 ! 201d1b8 <imfs_memfile_bytes_per_block>
200dcd4: 7f ff d5 84 call 20032e4 <calloc>
200dcd8: 90 10 20 01 mov 1, %o0
if ( memory )
200dcdc: b0 92 20 00 orcc %o0, 0, %i0
200dce0: 02 80 00 05 be 200dcf4 <memfile_alloc_block+0x2c> <== NEVER TAKEN
200dce4: 03 00 80 74 sethi %hi(0x201d000), %g1
memfile_blocks_allocated++;
200dce8: c4 00 62 cc ld [ %g1 + 0x2cc ], %g2 ! 201d2cc <memfile_blocks_allocated>
200dcec: 84 00 a0 01 inc %g2
200dcf0: c4 20 62 cc st %g2, [ %g1 + 0x2cc ]
return memory;
}
200dcf4: 81 c7 e0 08 ret
200dcf8: 81 e8 00 00 restore
0200e7f0 <memfile_ftruncate>:
int memfile_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
200e7f0: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
200e7f4: 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 )
200e7f8: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
200e7fc: 80 a0 40 19 cmp %g1, %i1
200e800: 06 80 00 09 bl 200e824 <memfile_ftruncate+0x34> <== NEVER TAKEN
200e804: 90 10 00 1d mov %i5, %o0
200e808: 32 80 00 0d bne,a 200e83c <memfile_ftruncate+0x4c> <== NEVER TAKEN
200e80c: f2 27 60 50 st %i1, [ %i5 + 0x50 ] <== NOT EXECUTED
200e810: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
200e814: 80 a0 40 1a cmp %g1, %i2
200e818: 3a 80 00 09 bcc,a 200e83c <memfile_ftruncate+0x4c>
200e81c: f2 27 60 50 st %i1, [ %i5 + 0x50 ]
return IMFS_memfile_extend( the_jnode, true, length );
200e820: 90 10 00 1d mov %i5, %o0
200e824: 92 10 20 01 mov 1, %o1
200e828: 94 10 00 19 mov %i1, %o2
200e82c: 7f ff fe df call 200e3a8 <IMFS_memfile_extend>
200e830: 96 10 00 1a mov %i2, %o3
200e834: 81 c7 e0 08 ret
200e838: 91 e8 00 08 restore %g0, %o0, %o0
/*
* The in-memory files do not currently reclaim memory until the file is
* deleted. So we leave the previously allocated blocks in place for
* future use and just set the length.
*/
the_jnode->info.file.size = length;
200e83c: f4 27 60 54 st %i2, [ %i5 + 0x54 ]
IMFS_update_atime( the_jnode );
200e840: 90 07 bf f8 add %fp, -8, %o0
200e844: 7f ff d3 85 call 2003658 <gettimeofday>
200e848: 92 10 20 00 clr %o1
200e84c: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e850: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
return 0;
}
200e854: 81 c7 e0 08 ret
200e858: 91 e8 20 00 restore %g0, 0, %o0
0200e774 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
200e774: 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)
200e778: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
200e77c: 80 88 60 04 btst 4, %g1
200e780: 12 80 00 04 bne 200e790 <memfile_open+0x1c>
200e784: d0 06 20 1c ld [ %i0 + 0x1c ], %o0
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
return 0;
200e788: 81 c7 e0 08 ret
200e78c: 91 e8 20 00 restore %g0, 0, %o0
200e790: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
200e794: c2 00 40 00 ld [ %g1 ], %g1
200e798: 80 a0 60 05 cmp %g1, 5
200e79c: 12 bf ff fb bne 200e788 <memfile_open+0x14> <== ALWAYS TAKEN
200e7a0: 03 00 80 6d sethi %hi(0x201b400), %g1
uint32_t count = the_jnode->info.linearfile.size;
200e7a4: d8 02 20 54 ld [ %o0 + 0x54 ], %o4 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
200e7a8: d6 02 20 58 ld [ %o0 + 0x58 ], %o3 <== NOT EXECUTED
the_jnode->control = &IMFS_node_control_memfile;
the_jnode->info.file.size = 0;
200e7ac: 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;
200e7b0: 82 10 63 34 or %g1, 0x334, %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
200e7b4: c0 22 20 54 clr [ %o0 + 0x54 ] <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->control = &IMFS_node_control_memfile;
200e7b8: c2 22 20 4c st %g1, [ %o0 + 0x4c ] <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
200e7bc: c0 22 20 58 clr [ %o0 + 0x58 ] <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
200e7c0: c0 22 20 5c clr [ %o0 + 0x5c ] <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
200e7c4: 80 a3 20 00 cmp %o4, 0 <== NOT EXECUTED
200e7c8: 02 bf ff f0 be 200e788 <memfile_open+0x14> <== NOT EXECUTED
200e7cc: c0 22 20 60 clr [ %o0 + 0x60 ] <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
200e7d0: 92 10 20 00 clr %o1 <== NOT EXECUTED
200e7d4: 7f ff ff 5d call 200e548 <IMFS_memfile_write> <== NOT EXECUTED
200e7d8: 94 10 20 00 clr %o2 <== NOT EXECUTED
return -1;
200e7dc: 90 38 00 08 xnor %g0, %o0, %o0 <== NOT EXECUTED
200e7e0: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
200e7e4: b0 40 3f ff addx %g0, -1, %i0 <== NOT EXECUTED
}
return 0;
}
200e7e8: 81 c7 e0 08 ret <== NOT EXECUTED
200e7ec: 81 e8 00 00 restore <== NOT EXECUTED
02003b1c <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
2003b1c: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
2003b20: 80 a6 e0 01 cmp %i3, 1
2003b24: 18 80 00 b4 bgu 2003df4 <mount+0x2d8>
2003b28: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
2003b2c: 40 00 21 90 call 200c16c <rtems_filesystem_get_mount_handler>
2003b30: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
2003b34: a6 92 20 00 orcc %o0, 0, %l3
2003b38: 02 80 00 af be 2003df4 <mount+0x2d8>
2003b3c: a2 96 60 00 orcc %i1, 0, %l1
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
2003b40: 12 80 00 04 bne 2003b50 <mount+0x34>
2003b44: 01 00 00 00 nop
2003b48: 23 00 80 6c sethi %hi(0x201b000), %l1
2003b4c: a2 14 63 40 or %l1, 0x340, %l1 ! 201b340 <rtems_status_assoc+0x1a0>
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
2003b50: 40 00 34 4e call 2010c88 <strlen>
2003b54: 90 10 00 1a mov %i2, %o0
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2003b58: 80 a6 20 00 cmp %i0, 0
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
2003b5c: ba 10 00 08 mov %o0, %i5
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2003b60: 02 80 00 06 be 2003b78 <mount+0x5c>
2003b64: ac 02 20 01 add %o0, 1, %l6
2003b68: 40 00 34 48 call 2010c88 <strlen>
2003b6c: 90 10 00 18 mov %i0, %o0
2003b70: 10 80 00 03 b 2003b7c <mount+0x60>
2003b74: a0 02 20 01 add %o0, 1, %l0
2003b78: a0 10 20 00 clr %l0
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
2003b7c: ba 07 60 65 add %i5, 0x65, %i5
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
2003b80: 40 00 34 42 call 2010c88 <strlen>
2003b84: 90 10 00 11 mov %l1, %o0
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
2003b88: 92 07 40 10 add %i5, %l0, %o1
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
2003b8c: aa 02 20 01 add %o0, 1, %l5
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 );
2003b90: 90 10 20 01 mov 1, %o0
2003b94: 7f ff fd d4 call 20032e4 <calloc>
2003b98: 92 02 40 15 add %o1, %l5, %o1
if ( mt_entry != NULL ) {
2003b9c: ba 92 20 00 orcc %o0, 0, %i5
2003ba0: 02 80 00 9d be 2003e14 <mount+0x2f8> <== NEVER TAKEN
2003ba4: a4 07 60 64 add %i5, 0x64, %l2
rtems_filesystem_global_location_t *mt_fs_root =
(rtems_filesystem_global_location_t *)
((char *) mt_entry + sizeof( *mt_entry ));
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
memcpy( str, filesystemtype, filesystemtype_size );
2003ba8: 92 10 00 1a mov %i2, %o1
2003bac: 90 10 00 12 mov %l2, %o0
2003bb0: 40 00 31 00 call 200ffb0 <memcpy>
2003bb4: 94 10 00 16 mov %l6, %o2
mt_entry->type = str;
2003bb8: e4 27 60 34 st %l2, [ %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 =
2003bbc: a8 07 60 40 add %i5, 0x40, %l4
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
if ( source_or_null != NULL ) {
2003bc0: 80 a6 20 00 cmp %i0, 0
2003bc4: 02 80 00 08 be 2003be4 <mount+0xc8>
2003bc8: b4 04 80 16 add %l2, %l6, %i2
memcpy( str, source_or_null, source_size );
2003bcc: 90 10 00 1a mov %i2, %o0
2003bd0: 92 10 00 18 mov %i0, %o1
2003bd4: 40 00 30 f7 call 200ffb0 <memcpy>
2003bd8: 94 10 00 10 mov %l0, %o2
mt_entry->dev = str;
2003bdc: f4 27 60 38 st %i2, [ %i5 + 0x38 ]
str += source_size;
2003be0: b4 06 80 10 add %i2, %l0, %i2
}
memcpy( str, target, target_size );
2003be4: 92 10 00 11 mov %l1, %o1
2003be8: 94 10 00 15 mov %l5, %o2
2003bec: 40 00 30 f1 call 200ffb0 <memcpy>
2003bf0: 90 10 00 1a mov %i2, %o0
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
2003bf4: 82 10 20 01 mov 1, %g1
2003bf8: 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;
2003bfc: 03 00 80 6c sethi %hi(0x201b000), %g1
2003c00: 82 10 63 44 or %g1, 0x344, %g1 ! 201b344 <rtems_filesystem_default_pathconf>
2003c04: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->location.mt_entry = mt_entry;
mt_fs_root->reference_count = 1;
2003c08: 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 );
2003c0c: 90 07 60 14 add %i5, 0x14, %o0
2003c10: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
2003c14: 92 10 00 14 mov %l4, %o1
2003c18: 94 10 20 01 mov 1, %o2
2003c1c: 96 10 20 24 mov 0x24, %o3
mt_entry->dev = str;
str += source_size;
}
memcpy( str, target, target_size );
mt_entry->target = str;
2003c20: f4 27 60 30 st %i2, [ %i5 + 0x30 ]
str += target_size;
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
2003c24: e8 27 60 24 st %l4, [ %i5 + 0x24 ]
2003c28: 40 00 11 7e call 2008220 <_Chain_Initialize>
2003c2c: fa 27 60 54 st %i5, [ %i5 + 0x54 ]
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
2003c30: b6 0e e0 01 and %i3, 1, %i3
rv = (*fsmount_me_h)( mt_entry, data );
2003c34: 90 10 00 1d mov %i5, %o0
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
2003c38: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
rv = (*fsmount_me_h)( mt_entry, data );
2003c3c: 9f c4 c0 00 call %l3
2003c40: 92 10 00 1c mov %i4, %o1
if ( rv == 0 ) {
2003c44: b0 92 20 00 orcc %o0, 0, %i0
2003c48: 12 80 00 6f bne 2003e04 <mount+0x2e8>
2003c4c: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
2003c50: 02 80 00 38 be 2003d30 <mount+0x214>
2003c54: 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 =
2003c58: 94 10 20 1f mov 0x1f, %o2
2003c5c: 40 00 02 fd call 2004850 <rtems_filesystem_eval_path_start>
2003c60: 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;
2003c64: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
return (*mt_entry->ops->are_nodes_equal_h)(
2003c68: c4 00 60 0c ld [ %g1 + 0xc ], %g2
2003c6c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
2003c70: 9f c0 80 00 call %g2
2003c74: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
2003c78: 80 8a 20 ff btst 0xff, %o0
2003c7c: 12 80 00 22 bne 2003d04 <mount+0x1e8>
2003c80: 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(
2003c84: 40 00 03 ed call 2004c38 <rtems_filesystem_location_copy_and_detach>
2003c88: 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 );
2003c8c: 40 00 04 63 call 2004e18 <rtems_filesystem_location_transform_to_global>
2003c90: 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 );
2003c94: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
mt_entry->mt_point_node = mt_point_node;
2003c98: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
2003c9c: c2 00 60 0c ld [ %g1 + 0xc ], %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 );
2003ca0: 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 );
2003ca4: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
2003ca8: 9f c0 40 00 call %g1
2003cac: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
2003cb0: b0 92 20 00 orcc %o0, 0, %i0
2003cb4: 12 80 00 11 bne 2003cf8 <mount+0x1dc>
2003cb8: 92 10 20 00 clr %o1
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
2003cbc: 39 00 80 75 sethi %hi(0x201d400), %i4
2003cc0: d0 07 20 4c ld [ %i4 + 0x4c ], %o0 ! 201d44c <rtems_libio_semaphore>
2003cc4: 40 00 0e 80 call 20076c4 <rtems_semaphore_obtain>
2003cc8: 94 10 20 00 clr %o2
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
2003ccc: 03 00 80 72 sethi %hi(0x201c800), %g1
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2003cd0: d0 07 20 4c ld [ %i4 + 0x4c ], %o0
2003cd4: 82 10 62 c8 or %g1, 0x2c8, %g1
2003cd8: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
2003cdc: 86 00 60 04 add %g1, 4, %g3
2003ce0: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
2003ce4: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
2003ce8: fa 20 80 00 st %i5, [ %g2 ]
2003cec: 40 00 0e bf call 20077e8 <rtems_semaphore_release>
2003cf0: c4 27 60 04 st %g2, [ %i5 + 4 ]
2003cf4: 30 80 00 08 b,a 2003d14 <mount+0x1f8>
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
2003cf8: 40 00 03 f5 call 2004ccc <rtems_filesystem_global_location_release>
2003cfc: 90 10 00 1c mov %i4, %o0
2003d00: 30 80 00 05 b,a 2003d14 <mount+0x1f8>
}
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
2003d04: 90 07 bf c8 add %fp, -56, %o0
2003d08: 92 10 20 10 mov 0x10, %o1
2003d0c: 40 00 02 3b call 20045f8 <rtems_filesystem_eval_path_error>
2003d10: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2003d14: 40 00 03 0b call 2004940 <rtems_filesystem_eval_path_cleanup>
2003d18: 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 ) {
2003d1c: 80 a6 20 00 cmp %i0, 0
2003d20: 02 80 00 42 be 2003e28 <mount+0x30c>
2003d24: 01 00 00 00 nop
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
2003d28: 10 80 00 2f b 2003de4 <mount+0x2c8>
2003d2c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
2003d30: 03 00 80 75 sethi %hi(0x201d400), %g1
2003d34: d0 00 60 4c ld [ %g1 + 0x4c ], %o0 ! 201d44c <rtems_libio_semaphore>
2003d38: 92 10 20 00 clr %o1
2003d3c: 40 00 0e 62 call 20076c4 <rtems_semaphore_obtain>
2003d40: 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;
2003d44: 05 00 80 72 sethi %hi(0x201c800), %g2
)
{
int rv = 0;
rtems_filesystem_mt_lock();
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
2003d48: c6 00 a2 c8 ld [ %g2 + 0x2c8 ], %g3 ! 201cac8 <rtems_filesystem_mount_table>
2003d4c: 82 10 a2 c8 or %g2, 0x2c8, %g1
2003d50: 84 00 60 04 add %g1, 4, %g2
2003d54: 80 a0 c0 02 cmp %g3, %g2
2003d58: 12 80 00 08 bne 2003d78 <mount+0x25c> <== NEVER TAKEN
2003d5c: 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;
2003d60: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
2003d64: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
2003d68: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
2003d6c: fa 20 80 00 st %i5, [ %g2 ]
the_node->previous = old_last;
2003d70: 10 80 00 06 b 2003d88 <mount+0x26c>
2003d74: c4 27 60 04 st %g2, [ %i5 + 4 ]
rtems_chain_append_unprotected(
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
} else {
errno = EINVAL;
2003d78: 40 00 2e 3d call 200f66c <__errno> <== NOT EXECUTED
2003d7c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003d80: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2003d84: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2003d88: 03 00 80 75 sethi %hi(0x201d400), %g1
2003d8c: 40 00 0e 97 call 20077e8 <rtems_semaphore_release>
2003d90: d0 00 60 4c ld [ %g1 + 0x4c ], %o0 ! 201d44c <rtems_libio_semaphore>
rv = -1;
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
2003d94: 80 a6 20 00 cmp %i0, 0
2003d98: 32 80 00 13 bne,a 2003de4 <mount+0x2c8> <== NEVER TAKEN
2003d9c: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
rtems_filesystem_global_location_t *new_fs_root =
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
2003da0: 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 =
2003da4: 40 00 03 eb call 2004d50 <rtems_filesystem_global_location_obtain>
2003da8: 90 10 00 1d mov %i5, %o0
2003dac: 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 =
2003db0: 40 00 03 e8 call 2004d50 <rtems_filesystem_global_location_obtain>
2003db4: 90 10 00 1d mov %i5, %o0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
2003db8: 3b 00 80 72 sethi %hi(0x201c800), %i5
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_t *new_fs_current =
2003dbc: b8 10 00 08 mov %o0, %i4
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
2003dc0: d0 07 62 e8 ld [ %i5 + 0x2e8 ], %o0
2003dc4: 92 10 00 1b mov %i3, %o1
2003dc8: 40 00 03 d9 call 2004d2c <rtems_filesystem_global_location_assign>
2003dcc: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_fs_root
);
rtems_filesystem_global_location_assign(
2003dd0: d0 07 62 e8 ld [ %i5 + 0x2e8 ], %o0
2003dd4: 40 00 03 d6 call 2004d2c <rtems_filesystem_global_location_assign>
2003dd8: 92 10 00 1c mov %i4, %o1
2003ddc: 81 c7 e0 08 ret
2003de0: 81 e8 00 00 restore
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
2003de4: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
2003de8: 9f c0 40 00 call %g1
2003dec: 90 10 00 1d mov %i5, %o0
2003df0: 30 80 00 05 b,a 2003e04 <mount+0x2e8>
} else {
errno = EINVAL;
rv = -1;
}
} else {
errno = EINVAL;
2003df4: 40 00 2e 1e call 200f66c <__errno>
2003df8: 01 00 00 00 nop
2003dfc: 10 80 00 09 b 2003e20 <mount+0x304>
2003e00: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
}
}
if ( rv != 0 ) {
free( mt_entry );
2003e04: 7f ff fd eb call 20035b0 <free>
2003e08: 90 10 00 1d mov %i5, %o0
2003e0c: 81 c7 e0 08 ret
2003e10: 81 e8 00 00 restore
}
} else {
errno = ENOMEM;
2003e14: 40 00 2e 16 call 200f66c <__errno> <== NOT EXECUTED
2003e18: 01 00 00 00 nop <== NOT EXECUTED
2003e1c: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
2003e20: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
2003e24: b0 10 3f ff mov -1, %i0
errno = EINVAL;
rv = -1;
}
return rv;
}
2003e28: 81 c7 e0 08 ret
2003e2c: 81 e8 00 00 restore
02008844 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
2008844: 9d e3 bf a0 save %sp, -96, %sp
int rv = -1;
if (target != NULL) {
2008848: 90 96 60 00 orcc %i1, 0, %o0
200884c: 02 80 00 09 be 2008870 <mount_and_make_target_path+0x2c>
2008850: 01 00 00 00 nop
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
2008854: 40 00 02 f1 call 2009418 <rtems_mkdir>
2008858: 92 10 21 ff mov 0x1ff, %o1 ! 1ff <PROM_START+0x1ff>
if (rv == 0) {
200885c: 80 a2 20 00 cmp %o0, 0
2008860: 12 80 00 09 bne 2008884 <mount_and_make_target_path+0x40> <== NEVER TAKEN
2008864: 01 00 00 00 nop
rv = mount(
2008868: 40 00 00 09 call 200888c <mount>
200886c: 81 e8 00 00 restore
options,
data
);
}
} else {
errno = EINVAL;
2008870: 40 00 60 6c call 2020a20 <__errno>
2008874: 01 00 00 00 nop
2008878: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
200887c: c2 22 00 00 st %g1, [ %o0 ]
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
2008880: 90 10 3f ff mov -1, %o0
} else {
errno = EINVAL;
}
return rv;
}
2008884: 81 c7 e0 08 ret
2008888: 91 e8 00 08 restore %g0, %o0, %o0
020176f0 <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
20176f0: 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;
20176f4: 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);
20176f8: 92 10 20 00 clr %o1
mode_t mode,
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
20176fc: f8 00 60 08 ld [ %g1 + 8 ], %i4
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2017700: 82 10 3f ff mov -1, %g1
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2017704: 94 10 20 20 mov 0x20, %o2
2017708: c2 27 bf 78 st %g1, [ %fp + -136 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
201770c: c2 27 bf 7c st %g1, [ %fp + -132 ]
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
2017710: e0 06 20 08 ld [ %i0 + 8 ], %l0
fat_file_fd_t *fat_fd = NULL;
2017714: c0 27 bf 6c clr [ %fp + -148 ]
time_t time_ret = 0;
uint16_t time_val = 0;
2017718: c0 37 bf 68 clrh [ %fp + -152 ]
uint16_t date = 0;
201771c: 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;
2017720: c0 27 bf 70 clr [ %fp + -144 ]
dir_pos->sname.ofs = 0;
2017724: c0 27 bf 74 clr [ %fp + -140 ]
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2017728: 40 00 12 9d call 201c19c <memset>
201772c: 90 07 bf 80 add %fp, -128, %o0
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
2017730: 90 07 bf c0 add %fp, -64, %o0
2017734: 92 10 20 00 clr %o1
2017738: 40 00 12 99 call 201c19c <memset>
201773c: 94 10 20 40 mov 0x40, %o2
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
2017740: 80 a6 e1 04 cmp %i3, 0x104
2017744: 24 80 00 06 ble,a 201775c <msdos_creat_node+0x6c> <== ALWAYS TAKEN
2017748: 90 10 00 1a mov %i2, %o0
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
201774c: 40 00 0f 98 call 201b5ac <__errno> <== NOT EXECUTED
2017750: 01 00 00 00 nop <== NOT EXECUTED
2017754: 10 80 00 0c b 2017784 <msdos_creat_node+0x94> <== NOT EXECUTED
2017758: 82 10 20 5b mov 0x5b, %g1 ! 5b <PROM_START+0x5b> <== NOT EXECUTED
}
name_type = msdos_long_to_short (name, name_len,
201775c: 92 10 00 1b mov %i3, %o1
2017760: 94 07 bf 80 add %fp, -128, %o2
2017764: 40 00 01 45 call 2017c78 <msdos_long_to_short>
2017768: 96 10 20 0b mov 0xb, %o3
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
201776c: a4 92 20 00 orcc %o0, 0, %l2
2017770: 32 80 00 08 bne,a 2017790 <msdos_creat_node+0xa0> <== ALWAYS TAKEN
2017774: c0 2f bf 8c clrb [ %fp + -116 ]
rtems_set_errno_and_return_minus_one(EINVAL);
2017778: 40 00 0f 8d call 201b5ac <__errno> <== NOT EXECUTED
201777c: 01 00 00 00 nop <== NOT EXECUTED
2017780: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2017784: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2017788: 10 80 00 ce b 2017ac0 <msdos_creat_node+0x3d0> <== NOT EXECUTED
201778c: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
/* set up last write date and time */
time_ret = time(NULL);
2017790: 40 00 23 07 call 20203ac <time>
2017794: 90 10 20 00 clr %o0
if ( time_ret == -1 )
2017798: 80 a2 3f ff cmp %o0, -1
201779c: 12 80 00 04 bne 20177ac <msdos_creat_node+0xbc> <== ALWAYS TAKEN
20177a0: 92 07 bf 6a add %fp, -150, %o1
20177a4: 10 80 00 c7 b 2017ac0 <msdos_creat_node+0x3d0> <== NOT EXECUTED
20177a8: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
20177ac: 40 00 0b bd call 201a6a0 <msdos_date_unix2dos>
20177b0: 94 07 bf 68 add %fp, -152, %o2
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
20177b4: c2 17 bf 68 lduh [ %fp + -152 ], %g1
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
20177b8: 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);
20177bc: 83 28 60 10 sll %g1, 0x10, %g1
20177c0: 85 30 60 08 srl %g1, 8, %g2
20177c4: 83 30 60 18 srl %g1, 0x18, %g1
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
20177c8: 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);
20177cc: 84 10 80 01 or %g2, %g1, %g2
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
20177d0: c0 27 bf 9c clr [ %fp + -100 ]
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
20177d4: 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);
20177d8: c4 37 bf 8e sth %g2, [ %fp + -114 ]
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
20177dc: 87 30 e0 18 srl %g3, 0x18, %g3
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
20177e0: 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);
20177e4: 82 10 40 03 or %g1, %g3, %g1
20177e8: 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);
20177ec: c2 37 bf 98 sth %g1, [ %fp + -104 ]
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
20177f0: 80 a6 60 00 cmp %i1, 0
20177f4: 12 80 00 05 bne 2017808 <msdos_creat_node+0x118>
20177f8: c2 37 bf 92 sth %g1, [ %fp + -110 ]
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
20177fc: c2 0f bf 8b ldub [ %fp + -117 ], %g1
2017800: 10 80 00 2f b 20178bc <msdos_creat_node+0x1cc>
2017804: 82 10 60 10 or %g1, 0x10, %g1
}
else if (type == MSDOS_HARD_LINK) {
2017808: 80 a6 60 02 cmp %i1, 2
201780c: 12 80 00 2b bne 20178b8 <msdos_creat_node+0x1c8> <== ALWAYS TAKEN
2017810: c2 0f bf 8b ldub [ %fp + -117 ], %g1
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
2017814: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2017818: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
201781c: 32 80 00 08 bne,a 201783c <msdos_creat_node+0x14c> <== NOT EXECUTED
2017820: c2 0f 20 05 ldub [ %i4 + 5 ], %g1 <== NOT EXECUTED
2017824: c2 0f 20 0e ldub [ %i4 + 0xe ], %g1 <== NOT EXECUTED
2017828: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
201782c: 22 80 00 04 be,a 201783c <msdos_creat_node+0x14c> <== NOT EXECUTED
2017830: c2 0f 20 05 ldub [ %i4 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2017834: 10 80 00 06 b 201784c <msdos_creat_node+0x15c> <== NOT EXECUTED
2017838: c4 07 20 20 ld [ %i4 + 0x20 ], %g2 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
201783c: 84 00 bf fe add %g2, -2, %g2 <== NOT EXECUTED
2017840: 85 28 80 01 sll %g2, %g1, %g2 <== NOT EXECUTED
2017844: c2 07 20 34 ld [ %i4 + 0x34 ], %g1 <== NOT EXECUTED
2017848: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
201784c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
2017850: d2 0f 20 02 ldub [ %i4 + 2 ], %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
2017854: d4 17 00 00 lduh [ %i4 ], %o2 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2017858: 93 30 40 09 srl %g1, %o1, %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
201785c: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
2017860: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2017864: 92 00 80 09 add %g2, %o1, %o1 <== NOT EXECUTED
2017868: 94 0a 80 01 and %o2, %g1, %o2 <== NOT EXECUTED
201786c: 96 10 20 20 mov 0x20, %o3 <== NOT EXECUTED
2017870: 7f ff ed e4 call 2013000 <_fat_block_read> <== NOT EXECUTED
2017874: 98 07 bf a0 add %fp, -96, %o4 <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
2017878: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201787c: 06 bf ff c3 bl 2017788 <msdos_creat_node+0x98> <== NOT EXECUTED
2017880: c2 0f bf ad ldub [ %fp + -83 ], %g1 <== NOT EXECUTED
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
2017884: c2 2f bf 8d stb %g1, [ %fp + -115 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
2017888: c2 17 bf ae lduh [ %fp + -82 ], %g1 <== NOT EXECUTED
201788c: c2 37 bf 8e sth %g1, [ %fp + -114 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
2017890: c2 17 bf b0 lduh [ %fp + -80 ], %g1 <== NOT EXECUTED
2017894: c2 37 bf 90 sth %g1, [ %fp + -112 ] <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
2017898: c2 07 bf bc ld [ %fp + -68 ], %g1 <== NOT EXECUTED
201789c: c2 27 bf 9c st %g1, [ %fp + -100 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
20178a0: c2 17 bf ba lduh [ %fp + -70 ], %g1 <== NOT EXECUTED
20178a4: c2 37 bf 9a sth %g1, [ %fp + -102 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
20178a8: c2 17 bf b4 lduh [ %fp + -76 ], %g1 <== NOT EXECUTED
20178ac: c2 37 bf 94 sth %g1, [ %fp + -108 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
20178b0: 10 80 00 02 b 20178b8 <msdos_creat_node+0x1c8> <== NOT EXECUTED
20178b4: c2 0f bf ab ldub [ %fp + -85 ], %g1 <== NOT EXECUTED
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
20178b8: 82 10 60 20 or %g1, 0x20, %g1
20178bc: c2 2f bf 8b stb %g1, [ %fp + -117 ]
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
name_type, &dir_pos, short_node);
20178c0: a2 07 bf 80 add %fp, -128, %l1
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
20178c4: 90 10 00 18 mov %i0, %o0
20178c8: e2 23 a0 5c st %l1, [ %sp + 0x5c ]
20178cc: 92 10 20 01 mov 1, %o1
20178d0: 94 10 00 1a mov %i2, %o2
20178d4: 96 10 00 1b mov %i3, %o3
20178d8: 98 10 00 12 mov %l2, %o4
20178dc: 40 00 05 fc call 20190cc <msdos_get_name_node>
20178e0: 9a 07 bf 70 add %fp, -144, %o5
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
20178e4: ba 92 20 00 orcc %o0, 0, %i5
20178e8: 12 80 00 76 bne 2017ac0 <msdos_creat_node+0x3d0>
20178ec: 80 a6 60 00 cmp %i1, 0
/*
* if we create a new file we are done, if directory there are more steps
* to do
*/
if (type == MSDOS_DIRECTORY)
20178f0: 32 80 00 75 bne,a 2017ac4 <msdos_creat_node+0x3d4>
20178f4: b0 10 00 1d mov %i5, %i0
{
/* open new directory as fat-file */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
20178f8: 90 10 00 1c mov %i4, %o0
20178fc: 92 07 bf 70 add %fp, -144, %o1
2017900: 7f ff ea 22 call 2012188 <fat_file_open>
2017904: 94 07 bf 6c add %fp, -148, %o2
if (rc != RC_OK)
2017908: ba 92 20 00 orcc %o0, 0, %i5
201790c: 32 80 00 6a bne,a 2017ab4 <msdos_creat_node+0x3c4> <== NEVER TAKEN
2017910: 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;
2017914: fa 07 bf 6c ld [ %fp + -148 ], %i5
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2017918: 03 00 08 00 sethi %hi(0x200000), %g1
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
201791c: 92 10 00 11 mov %l1, %o1
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2017920: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
2017924: 94 10 20 20 mov 0x20, %o2
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
2017928: c0 27 60 18 clr [ %i5 + 0x18 ]
fat_fd->fat_file_type = FAT_DIRECTORY;
201792c: c0 27 60 10 clr [ %i5 + 0x10 ]
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
2017930: 40 00 11 de call 201c0a8 <memcpy>
2017934: 90 07 bf c0 add %fp, -64, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
2017938: 92 10 00 11 mov %l1, %o1
201793c: 94 10 20 20 mov 0x20, %o2
2017940: 40 00 11 da call 201c0a8 <memcpy>
2017944: 90 07 bf e0 add %fp, -32, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
2017948: 03 00 80 af sethi %hi(0x202bc00), %g1
201794c: d2 00 60 dc ld [ %g1 + 0xdc ], %o1 ! 202bcdc <MSDOS_DOT_NAME>
2017950: 94 10 20 0b mov 0xb, %o2
2017954: 40 00 11 d5 call 201c0a8 <memcpy>
2017958: 90 07 bf c0 add %fp, -64, %o0
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
201795c: 03 00 80 af sethi %hi(0x202bc00), %g1
2017960: d2 00 60 d8 ld [ %g1 + 0xd8 ], %o1 ! 202bcd8 <MSDOS_DOTDOT_NAME>
2017964: 90 07 bf e0 add %fp, -32, %o0
2017968: 40 00 11 d0 call 201c0a8 <memcpy>
201796c: 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)) &&
2017970: c2 04 20 20 ld [ %l0 + 0x20 ], %g1
2017974: 80 a0 60 01 cmp %g1, 1
2017978: 32 80 00 0e bne,a 20179b0 <msdos_creat_node+0x2c0>
201797c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
2017980: c2 04 20 24 ld [ %l0 + 0x24 ], %g1
2017984: 80 a0 60 00 cmp %g1, 0
2017988: 32 80 00 0a bne,a 20179b0 <msdos_creat_node+0x2c0> <== NEVER TAKEN
201798c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & FAT_FAT32))
2017990: c2 0f 20 0e ldub [ %i4 + 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)) &&
2017994: 82 08 60 04 and %g1, 4, %g1
2017998: 80 88 60 ff btst 0xff, %g1
201799c: 22 80 00 05 be,a 20179b0 <msdos_creat_node+0x2c0> <== ALWAYS TAKEN
20179a0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
(fs_info->fat.vol.type & FAT_FAT32))
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
20179a4: c0 37 bf fa clrh [ %fp + -6 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
20179a8: 10 80 00 10 b 20179e8 <msdos_creat_node+0x2f8> <== NOT EXECUTED
20179ac: c0 37 bf f4 clrh [ %fp + -12 ] <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
20179b0: 05 00 00 3f sethi %hi(0xfc00), %g2
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
20179b4: 87 28 60 10 sll %g1, 0x10, %g3
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
20179b8: 84 10 a3 ff or %g2, 0x3ff, %g2
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
20179bc: 87 30 e0 18 srl %g3, 0x18, %g3
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
20179c0: 88 08 40 02 and %g1, %g2, %g4
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
20179c4: 83 30 60 10 srl %g1, 0x10, %g1
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
20179c8: 89 29 20 08 sll %g4, 8, %g4
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
20179cc: 84 08 40 02 and %g1, %g2, %g2
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
20179d0: 86 11 00 03 or %g4, %g3, %g3
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
20179d4: 85 28 a0 08 sll %g2, 8, %g2
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
20179d8: 83 30 60 08 srl %g1, 8, %g1
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
20179dc: c6 37 bf fa sth %g3, [ %fp + -6 ]
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
20179e0: 82 10 80 01 or %g2, %g1, %g1
20179e4: c2 37 bf f4 sth %g1, [ %fp + -12 ]
/*
* write dot and dotdot entries to new fat-file: currently fat-file
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
20179e8: 90 10 00 1c mov %i4, %o0
20179ec: 92 10 00 1d mov %i5, %o1
20179f0: 94 10 20 00 clr %o2
20179f4: 96 10 20 40 mov 0x40, %o3
20179f8: 7f ff eb f1 call 20129bc <fat_file_write>
20179fc: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
2017a00: 80 a2 20 00 cmp %o0, 0
2017a04: 06 80 00 27 bl 2017aa0 <msdos_creat_node+0x3b0> <== NEVER TAKEN
2017a08: 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;
2017a0c: c2 17 20 06 lduh [ %i4 + 6 ], %g1
2017a10: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
2017a14: 90 10 00 1c mov %i4, %o0
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
2017a18: 82 00 80 01 add %g2, %g1, %g1
2017a1c: c2 22 60 18 st %g1, [ %o1 + 0x18 ]
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
2017a20: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
2017a24: 05 00 00 3f sethi %hi(0xfc00), %g2
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
2017a28: 87 28 60 10 sll %g1, 0x10, %g3
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
2017a2c: 84 10 a3 ff or %g2, 0x3ff, %g2
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
2017a30: 87 30 e0 18 srl %g3, 0x18, %g3
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
2017a34: 88 08 40 02 and %g1, %g2, %g4
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
2017a38: 83 30 60 10 srl %g1, 0x10, %g1
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
2017a3c: 89 29 20 08 sll %g4, 8, %g4
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
2017a40: 84 08 40 02 and %g1, %g2, %g2
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
2017a44: 86 11 00 03 or %g4, %g3, %g3
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
2017a48: 85 28 a0 08 sll %g2, 8, %g2
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
2017a4c: 83 30 60 08 srl %g1, 8, %g1
2017a50: 82 10 80 01 or %g2, %g1, %g1
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
2017a54: c6 37 bf da sth %g3, [ %fp + -38 ]
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
2017a58: c2 37 bf d4 sth %g1, [ %fp + -44 ]
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
2017a5c: 94 10 20 00 clr %o2
2017a60: 96 10 20 20 mov 0x20, %o3
2017a64: 7f ff eb d6 call 20129bc <fat_file_write>
2017a68: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
2017a6c: 80 a2 20 00 cmp %o0, 0
2017a70: 06 80 00 0d bl 2017aa4 <msdos_creat_node+0x3b4> <== NEVER TAKEN
2017a74: 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);
2017a78: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
2017a7c: 40 00 01 45 call 2017f90 <msdos_set_first_cluster_num>
2017a80: d2 07 bf 6c ld [ %fp + -148 ], %o1
if (rc != RC_OK)
2017a84: ba 92 20 00 orcc %o0, 0, %i5
2017a88: 12 80 00 08 bne 2017aa8 <msdos_creat_node+0x3b8> <== NEVER TAKEN
2017a8c: d2 07 bf 6c ld [ %fp + -148 ], %o1
goto error;
fat_file_close(&fs_info->fat, fat_fd);
2017a90: 7f ff ea d4 call 20125e0 <fat_file_close>
2017a94: 90 10 00 1c mov %i4, %o0
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
2017a98: 81 c7 e0 08 ret
2017a9c: 91 e8 00 1d restore %g0, %i5, %o0
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
{
rc = -1;
2017aa0: 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);
2017aa4: d2 07 bf 6c ld [ %fp + -148 ], %o1 <== NOT EXECUTED
2017aa8: 7f ff ea ce call 20125e0 <fat_file_close> <== NOT EXECUTED
2017aac: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
2017ab0: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 <== NOT EXECUTED
2017ab4: 92 07 bf 70 add %fp, -144, %o1 <== NOT EXECUTED
2017ab8: 40 00 01 81 call 20180bc <msdos_set_first_char4file_name> <== NOT EXECUTED
2017abc: 94 10 20 e5 mov 0xe5, %o2 <== NOT EXECUTED
return rc;
}
2017ac0: b0 10 00 1d mov %i5, %i0
2017ac4: 81 c7 e0 08 ret
2017ac8: 81 e8 00 00 restore
0201a7ec <msdos_date_dos2unix>:
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
201a7ec: 85 32 60 0b srl %o1, 0xb, %g2
201a7f0: 84 08 a0 1f and %g2, 0x1f, %g2
201a7f4: 87 28 a0 03 sll %g2, 3, %g3
201a7f8: 83 28 a0 07 sll %g2, 7, %g1
201a7fc: 82 20 40 03 sub %g1, %g3, %g1
201a800: 85 28 60 04 sll %g1, 4, %g2
201a804: 84 20 80 01 sub %g2, %g1, %g2
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
201a808: 82 0a 67 e0 and %o1, 0x7e0, %g1
201a80c: 87 30 60 04 srl %g1, 4, %g3
201a810: 82 20 40 03 sub %g1, %g3, %g1
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
201a814: 82 00 80 01 add %g2, %g1, %g1
uint32_t m, month;
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
201a818: 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;
201a81c: 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) {
201a820: 03 00 80 b5 sethi %hi(0x202d400), %g1
201a824: c4 10 63 3a lduh [ %g1 + 0x33a ], %g2 ! 202d73a <lastdosdate>
201a828: 80 a0 80 08 cmp %g2, %o0
201a82c: 02 80 00 34 be 201a8fc <msdos_date_dos2unix+0x110>
201a830: 93 2a 60 01 sll %o1, 1, %o1
lastdosdate = dd;
201a834: d0 30 63 3a sth %o0, [ %g1 + 0x33a ]
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
201a838: 89 32 20 09 srl %o0, 9, %g4
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
201a83c: 82 10 20 00 clr %g1
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
201a840: 88 09 20 7f and %g4, 0x7f, %g4
for (y = 0; y < year; y++)
201a844: 10 80 00 07 b 201a860 <msdos_date_dos2unix+0x74>
201a848: 84 10 20 00 clr %g2
days += y & 0x03 ? 365 : 366;
201a84c: 80 a0 00 03 cmp %g0, %g3
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
201a850: 84 00 a0 01 inc %g2
days += y & 0x03 ? 365 : 366;
201a854: 86 60 3f ff subx %g0, -1, %g3
201a858: 86 00 e1 6d add %g3, 0x16d, %g3
201a85c: 82 00 40 03 add %g1, %g3, %g1
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
201a860: 80 a0 80 04 cmp %g2, %g4
201a864: 12 bf ff fa bne 201a84c <msdos_date_dos2unix+0x60>
201a868: 86 08 a0 03 and %g2, 3, %g3
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
201a86c: 80 a0 e0 00 cmp %g3, 0
201a870: 22 80 00 05 be,a 201a884 <msdos_date_dos2unix+0x98> <== ALWAYS TAKEN
201a874: 09 00 80 b3 sethi %hi(0x202cc00), %g4
201a878: 09 00 80 b3 sethi %hi(0x202cc00), %g4 <== NOT EXECUTED
201a87c: 10 80 00 03 b 201a888 <msdos_date_dos2unix+0x9c> <== NOT EXECUTED
201a880: 88 11 23 d8 or %g4, 0x3d8, %g4 ! 202cfd8 <regyear> <== NOT EXECUTED
201a884: 88 11 23 f0 or %g4, 0x3f0, %g4
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
201a888: 86 0a 21 e0 and %o0, 0x1e0, %g3
201a88c: 87 30 e0 05 srl %g3, 5, %g3
if (month == 0) {
201a890: 80 a0 e0 00 cmp %g3, 0
201a894: 22 80 00 02 be,a 201a89c <msdos_date_dos2unix+0xb0> <== NEVER TAKEN
201a898: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
month = 1;
}
for (m = 0; m < month - 1; m++)
201a89c: 84 10 20 00 clr %g2
201a8a0: 10 80 00 05 b 201a8b4 <msdos_date_dos2unix+0xc8>
201a8a4: 86 00 ff ff add %g3, -1, %g3
days += months[m];
201a8a8: da 11 00 0d lduh [ %g4 + %o5 ], %o5 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
201a8ac: 84 00 a0 01 inc %g2 <== NOT EXECUTED
days += months[m];
201a8b0: 82 00 40 0d add %g1, %o5, %g1 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
201a8b4: 80 a0 80 03 cmp %g2, %g3
201a8b8: 0a bf ff fc bcs 201a8a8 <msdos_date_dos2unix+0xbc> <== NEVER TAKEN
201a8bc: 9b 28 a0 01 sll %g2, 1, %o5
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
201a8c0: 90 0a 20 1f and %o0, 0x1f, %o0
201a8c4: 90 02 3f ff add %o0, -1, %o0
201a8c8: 82 02 00 01 add %o0, %g1, %g1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
201a8cc: 85 28 60 07 sll %g1, 7, %g2
201a8d0: 83 28 60 09 sll %g1, 9, %g1
201a8d4: 82 20 40 02 sub %g1, %g2, %g1
201a8d8: 85 28 60 04 sll %g1, 4, %g2
201a8dc: 82 20 80 01 sub %g2, %g1, %g1
201a8e0: 85 28 60 04 sll %g1, 4, %g2
201a8e4: 82 20 80 01 sub %g2, %g1, %g1
201a8e8: 05 04 b3 a9 sethi %hi(0x12cea400), %g2
201a8ec: 84 10 a2 00 or %g2, 0x200, %g2 ! 12cea600 <RAM_END+0x108ea600>
201a8f0: 82 00 40 02 add %g1, %g2, %g1
201a8f4: 05 00 80 b5 sethi %hi(0x202d400), %g2
201a8f8: c2 20 a3 3c st %g1, [ %g2 + 0x33c ] ! 202d73c <lastseconds>
}
return seconds + lastseconds;
201a8fc: 03 00 80 b5 sethi %hi(0x202d400), %g1
201a900: d0 00 63 3c ld [ %g1 + 0x33c ], %o0 ! 202d73c <lastseconds>
}
201a904: 81 c3 e0 08 retl
201a908: 90 02 40 08 add %o1, %o0, %o0
0201a6a0 <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)
{
201a6a0: 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) {
201a6a4: 03 00 80 b5 sethi %hi(0x202d400), %g1
201a6a8: c4 00 63 2c ld [ %g1 + 0x32c ], %g2 ! 202d72c <lasttime>
201a6ac: 80 a0 80 18 cmp %g2, %i0
201a6b0: 02 80 00 47 be 201a7cc <msdos_date_unix2dos+0x12c>
201a6b4: 92 10 20 3c mov 0x3c, %o1
lasttime = t;
201a6b8: f0 20 63 2c st %i0, [ %g1 + 0x32c ]
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
201a6bc: 7f ff a0 1f call 2002738 <.udiv>
201a6c0: 90 10 00 18 mov %i0, %o0
201a6c4: 40 00 39 26 call 2028b5c <.urem>
201a6c8: 92 10 20 3c mov 0x3c, %o1
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
201a6cc: 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)
201a6d0: bb 2a 20 05 sll %o0, 5, %i5
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
201a6d4: 7f ff a0 19 call 2002738 <.udiv>
201a6d8: 90 10 00 18 mov %i0, %o0
201a6dc: 40 00 39 20 call 2028b5c <.urem>
201a6e0: 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)
201a6e4: 91 2a 20 0b sll %o0, 0xb, %o0
201a6e8: 92 10 20 3c mov 0x3c, %o1
201a6ec: ba 07 40 08 add %i5, %o0, %i5
201a6f0: 40 00 39 1b call 2028b5c <.urem>
201a6f4: 90 10 00 18 mov %i0, %o0
201a6f8: 03 00 80 b5 sethi %hi(0x202d400), %g1
201a6fc: 91 32 20 01 srl %o0, 1, %o0
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
201a700: 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)
201a704: ba 07 40 08 add %i5, %o0, %i5
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
201a708: 92 12 61 80 or %o1, 0x180, %o1
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
201a70c: fa 30 63 30 sth %i5, [ %g1 + 0x330 ]
/*
* 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);
201a710: 7f ff a0 0a call 2002738 <.udiv>
201a714: 90 10 00 18 mov %i0, %o0
if (days != lastday) {
201a718: 03 00 80 b5 sethi %hi(0x202d400), %g1
201a71c: c4 00 63 34 ld [ %g1 + 0x334 ], %g2 ! 202d734 <lastday>
201a720: 80 a2 00 02 cmp %o0, %g2
201a724: 22 80 00 2b be,a 201a7d0 <msdos_date_unix2dos+0x130>
201a728: 03 00 80 b5 sethi %hi(0x202d400), %g1
lastday = days;
201a72c: d0 20 63 34 st %o0, [ %g1 + 0x334 ] ! 202d734 <lastday>
for (year = 1970;; year++) {
201a730: 82 10 27 b2 mov 0x7b2, %g1
inc = year & 0x03 ? 365 : 366;
201a734: 84 08 60 03 and %g1, 3, %g2
201a738: 80 a0 00 02 cmp %g0, %g2
201a73c: 86 60 3f ff subx %g0, -1, %g3
201a740: 86 00 e1 6d add %g3, 0x16d, %g3
if (days < inc)
201a744: 80 a2 00 03 cmp %o0, %g3
201a748: 0a 80 00 05 bcs 201a75c <msdos_date_unix2dos+0xbc>
201a74c: 80 a0 a0 00 cmp %g2, 0
break;
days -= inc;
201a750: 90 22 00 03 sub %o0, %g3, %o0
}
201a754: 10 bf ff f8 b 201a734 <msdos_date_unix2dos+0x94>
201a758: 82 00 60 01 inc %g1
months = year & 0x03 ? regyear : leapyear;
201a75c: 22 80 00 05 be,a 201a770 <msdos_date_unix2dos+0xd0> <== ALWAYS TAKEN
201a760: 09 00 80 b3 sethi %hi(0x202cc00), %g4
201a764: 09 00 80 b3 sethi %hi(0x202cc00), %g4 <== NOT EXECUTED
201a768: 10 80 00 03 b 201a774 <msdos_date_unix2dos+0xd4> <== NOT EXECUTED
201a76c: 88 11 23 d8 or %g4, 0x3d8, %g4 ! 202cfd8 <regyear> <== NOT EXECUTED
201a770: 88 11 23 f0 or %g4, 0x3f0, %g4
for (month = 0; month < 12; month++) {
201a774: 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,
201a778: 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])
201a77c: c6 11 00 03 lduh [ %g4 + %g3 ], %g3
201a780: 80 a2 00 03 cmp %o0, %g3
201a784: 2a 80 00 07 bcs,a 201a7a0 <msdos_date_unix2dos+0x100> <== ALWAYS TAKEN
201a788: 90 02 20 01 inc %o0
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
201a78c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
201a790: 80 a0 a0 0c cmp %g2, 0xc <== NOT EXECUTED
201a794: 12 bf ff f9 bne 201a778 <msdos_date_unix2dos+0xd8> <== NOT EXECUTED
201a798: 90 22 00 03 sub %o0, %g3, %o0 <== NOT EXECUTED
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
201a79c: 90 02 20 01 inc %o0 <== NOT EXECUTED
201a7a0: 84 00 a0 01 inc %g2
201a7a4: 07 00 80 b5 sethi %hi(0x202d400), %g3
201a7a8: 85 28 a0 05 sll %g2, 5, %g2
201a7ac: 90 02 00 02 add %o0, %g2, %o0
* Remember dos's idea of time is relative to 1980.
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
201a7b0: 80 a0 67 bc cmp %g1, 0x7bc
201a7b4: 08 80 00 06 bleu 201a7cc <msdos_date_unix2dos+0x12c> <== NEVER TAKEN
201a7b8: d0 30 e3 38 sth %o0, [ %g3 + 0x338 ]
lastddate += (year - 1980) <<
201a7bc: 82 00 78 44 add %g1, -1980, %g1
201a7c0: 83 28 60 09 sll %g1, 9, %g1
201a7c4: 90 02 00 01 add %o0, %g1, %o0
201a7c8: d0 30 e3 38 sth %o0, [ %g3 + 0x338 ]
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
201a7cc: 03 00 80 b5 sethi %hi(0x202d400), %g1
201a7d0: c2 10 63 30 lduh [ %g1 + 0x330 ], %g1 ! 202d730 <lastdtime>
201a7d4: c2 36 80 00 sth %g1, [ %i2 ]
*ddp = lastddate;
201a7d8: 03 00 80 b5 sethi %hi(0x202d400), %g1
201a7dc: c2 10 63 38 lduh [ %g1 + 0x338 ], %g1 ! 202d738 <lastddate>
201a7e0: c2 36 40 00 sth %g1, [ %i1 ]
201a7e4: 81 c7 e0 08 ret
201a7e8: 81 e8 00 00 restore
020181f0 <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
)
{
20181f0: 9d e3 bf a0 save %sp, -96, %sp
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
20181f4: 23 00 80 af sethi %hi(0x202bc00), %l1
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
20181f8: fa 06 20 08 ld [ %i0 + 8 ], %i5
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
20181fc: 25 00 80 af sethi %hi(0x202bc00), %l2
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
2018200: 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;
2018204: b6 10 20 00 clr %i3
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
2018208: a2 14 60 98 or %l1, 0x98, %l1
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
201820c: 10 80 00 33 b 20182d8 <msdos_dir_is_empty+0xe8>
2018210: a4 14 a0 a8 or %l2, 0xa8, %l2
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2018214: 04 80 00 2a ble 20182bc <msdos_dir_is_empty+0xcc> <== NEVER TAKEN
2018218: b0 10 3f ff mov -1, %i0
return -1;
assert(ret == fs_info->fat.vol.bps);
201821c: c2 17 40 00 lduh [ %i5 ], %g1
2018220: 80 a2 00 01 cmp %o0, %g1
2018224: 02 80 00 28 be 20182c4 <msdos_dir_is_empty+0xd4> <== ALWAYS TAKEN
2018228: b8 10 20 00 clr %i4
201822c: 11 00 80 af sethi %hi(0x202bc00), %o0 <== NOT EXECUTED
2018230: 15 00 80 af sethi %hi(0x202bc00), %o2 <== NOT EXECUTED
2018234: 17 00 80 af sethi %hi(0x202bc00), %o3 <== NOT EXECUTED
2018238: 90 12 20 28 or %o0, 0x28, %o0 <== NOT EXECUTED
201823c: 92 10 23 65 mov 0x365, %o1 <== NOT EXECUTED
2018240: 94 12 a0 e0 or %o2, 0xe0, %o2 <== NOT EXECUTED
2018244: 7f ff f1 36 call 201471c <__assert_func> <== NOT EXECUTED
2018248: 96 12 e0 78 or %o3, 0x78, %o3 <== NOT EXECUTED
* then consider it as empty.
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
201824c: e0 08 40 1c ldub [ %g1 + %i4 ], %l0
2018250: 80 a4 20 e5 cmp %l0, 0xe5
2018254: 02 80 00 14 be 20182a4 <msdos_dir_is_empty+0xb4> <== NEVER TAKEN
2018258: b0 00 40 1c add %g1, %i4, %i0
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
201825c: c2 0e 20 0b ldub [ %i0 + 0xb ], %g1
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
2018260: 82 08 60 3f and %g1, 0x3f, %g1
2018264: 80 a0 60 0f cmp %g1, 0xf
2018268: 02 80 00 0f be 20182a4 <msdos_dir_is_empty+0xb4> <== NEVER TAKEN
201826c: 90 10 00 18 mov %i0, %o0
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
2018270: 92 10 00 11 mov %l1, %o1
2018274: 40 00 16 0a call 201da9c <strncmp>
2018278: 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) ||
201827c: 80 a2 20 00 cmp %o0, 0
2018280: 22 80 00 12 be,a 20182c8 <msdos_dir_is_empty+0xd8>
2018284: 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)),
2018288: 90 10 00 18 mov %i0, %o0
201828c: 92 10 00 12 mov %l2, %o1
2018290: 40 00 16 03 call 201da9c <strncmp>
2018294: 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) ||
2018298: 80 a2 20 00 cmp %o0, 0
201829c: 12 80 00 04 bne 20182ac <msdos_dir_is_empty+0xbc>
20182a0: 80 a4 20 00 cmp %l0, 0
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
i < fs_info->fat.vol.bps;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
20182a4: 10 80 00 09 b 20182c8 <msdos_dir_is_empty+0xd8>
20182a8: b8 07 20 20 add %i4, 0x20, %i4
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
20182ac: 12 80 00 04 bne 20182bc <msdos_dir_is_empty+0xcc>
20182b0: b0 10 20 00 clr %i0
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
20182b4: 82 10 20 01 mov 1, %g1
20182b8: c2 2e 80 00 stb %g1, [ %i2 ]
return RC_OK;
20182bc: 81 c7 e0 08 ret
20182c0: 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;
20182c4: a6 10 00 08 mov %o0, %l3
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
20182c8: 80 a7 00 13 cmp %i4, %l3
20182cc: 2a bf ff e0 bcs,a 201824c <msdos_dir_is_empty+0x5c> <== ALWAYS TAKEN
20182d0: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
20182d4: b6 06 e0 01 inc %i3 <== NOT EXECUTED
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
20182d8: f8 17 40 00 lduh [ %i5 ], %i4
20182dc: 90 10 00 1b mov %i3, %o0
20182e0: 7f ff a8 dc call 2002650 <.umul>
20182e4: 92 10 00 1c mov %i4, %o1
20182e8: d8 07 60 a0 ld [ %i5 + 0xa0 ], %o4
20182ec: 94 10 00 08 mov %o0, %o2
20182f0: 92 10 00 19 mov %i1, %o1
20182f4: 90 10 00 1d mov %i5, %o0
20182f8: 7f ff e8 07 call 2012314 <fat_file_read>
20182fc: 96 10 00 1c mov %i4, %o3
2018300: 80 a2 20 00 cmp %o0, 0
2018304: 32 bf ff c4 bne,a 2018214 <msdos_dir_is_empty+0x24> <== ALWAYS TAKEN
2018308: 80 a2 20 1f cmp %o0, 0x1f
*/
return RC_OK;
}
j++;
}
*ret_val = true;
201830c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2018310: c2 2e 80 00 stb %g1, [ %i2 ] <== NOT EXECUTED
2018314: b0 10 20 00 clr %i0 <== NOT EXECUTED
return RC_OK;
}
2018318: 81 c7 e0 08 ret <== NOT EXECUTED
201831c: 81 e8 00 00 restore <== NOT EXECUTED
0201aa88 <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)
{
201aa88: 9d e3 be 68 save %sp, -408, %sp <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
201aa8c: 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);
201aa90: d0 1e 20 08 ldd [ %i0 + 8 ], %o0 <== NOT EXECUTED
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
201aa94: ec 00 60 08 ld [ %g1 + 8 ], %l6 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
201aa98: 94 10 20 00 clr %o2 <== NOT EXECUTED
201aa9c: 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)
{
201aaa0: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
fat_file_fd_t *tmp_fat_fd = NULL;
201aaa4: c0 27 be d0 clr [ %fp + -304 ] <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
201aaa8: 7f ff 9d ff call 20022a4 <__divdi3> <== NOT EXECUTED
201aaac: c0 27 be d4 clr [ %fp + -300 ] <== NOT EXECUTED
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
201aab0: e0 06 20 1c ld [ %i0 + 0x1c ], %l0 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
201aab4: a6 10 00 09 mov %o1, %l3 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
201aab8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
201aabc: 7f ff 9f 1f call 2002738 <.udiv> <== NOT EXECUTED
201aac0: 92 10 21 18 mov 0x118, %o1 <== NOT EXECUTED
201aac4: a5 2a 20 03 sll %o0, 3, %l2 <== NOT EXECUTED
201aac8: 91 2a 20 05 sll %o0, 5, %o0 <== NOT EXECUTED
201aacc: a4 04 80 08 add %l2, %o0, %l2 <== NOT EXECUTED
201aad0: 85 2c a0 03 sll %l2, 3, %g2 <== NOT EXECUTED
201aad4: a4 20 80 12 sub %g2, %l2, %l2 <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
201aad8: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED
201aadc: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
201aae0: 32 80 00 0b bne,a 201ab0c <msdos_dir_read+0x84> <== NOT EXECUTED
201aae4: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
201aae8: c4 04 20 24 ld [ %l0 + 0x24 ], %g2 <== NOT EXECUTED
201aaec: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
201aaf0: 32 80 00 07 bne,a 201ab0c <msdos_dir_read+0x84> <== NOT EXECUTED
201aaf4: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
201aaf8: c4 0d a0 0e ldub [ %l6 + 0xe ], %g2 <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
201aafc: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
201ab00: 22 80 00 03 be,a 201ab0c <msdos_dir_read+0x84> <== NOT EXECUTED
201ab04: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== NOT EXECUTED
201ab08: ea 04 20 18 ld [ %l0 + 0x18 ], %l5 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201ab0c: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
201ab10: 92 10 20 00 clr %o1 <== NOT EXECUTED
201ab14: 7f ff bb 5c call 2009884 <rtems_semaphore_obtain> <== NOT EXECUTED
201ab18: 94 10 20 00 clr %o2 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201ab1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201ab20: 22 80 00 fe be,a 201af18 <msdos_dir_read+0x490> <== NOT EXECUTED
201ab24: a2 10 20 00 clr %l1 <== NOT EXECUTED
201ab28: 30 80 00 0b b,a 201ab54 <msdos_dir_read+0xcc> <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
201ab2c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
201ab30: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201ab34: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
201ab38: 7f ff dd f7 call 2012314 <fat_file_read> <== NOT EXECUTED
201ab3c: 96 10 00 15 mov %l5, %o3 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
201ab40: 80 a2 20 1f cmp %o0, 0x1f <== NOT EXECUTED
201ab44: 14 80 00 ee bg 201aefc <msdos_dir_read+0x474> <== NOT EXECUTED
201ab48: d0 27 be cc st %o0, [ %fp + -308 ] <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
201ab4c: 7f ff bb 97 call 20099a8 <rtems_semaphore_release> <== NOT EXECUTED
201ab50: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
201ab54: 40 00 02 96 call 201b5ac <__errno> <== NOT EXECUTED
201ab58: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
201ab5c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201ab60: 10 80 01 07 b 201af7c <msdos_dir_read+0x4f4> <== NOT EXECUTED
201ab64: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
201ab68: ae 00 c0 1c add %g3, %i4, %l7 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
201ab6c: c6 08 c0 1c ldub [ %g3 + %i4 ], %g3 <== NOT EXECUTED
201ab70: 88 88 e0 ff andcc %g3, 0xff, %g4 <== NOT EXECUTED
201ab74: 12 80 00 04 bne 201ab84 <msdos_dir_read+0xfc> <== NOT EXECUTED
201ab78: 80 a1 20 e5 cmp %g4, 0xe5 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
201ab7c: 10 80 00 ef b 201af38 <msdos_dir_read+0x4b0> <== NOT EXECUTED
201ab80: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
201ab84: 22 80 00 df be,a 201af00 <msdos_dir_read+0x478> <== NOT EXECUTED
201ab88: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
201ab8c: c8 0d e0 0b ldub [ %l7 + 0xb ], %g4 <== NOT EXECUTED
201ab90: 9e 09 20 08 and %g4, 8, %o7 <== NOT EXECUTED
201ab94: 80 8b e0 ff btst 0xff, %o7 <== NOT EXECUTED
201ab98: 22 80 00 07 be,a 201abb4 <msdos_dir_read+0x12c> <== NOT EXECUTED
201ab9c: 88 09 20 3f and %g4, 0x3f, %g4 <== NOT EXECUTED
201aba0: 9e 09 20 3f and %g4, 0x3f, %o7 <== NOT EXECUTED
201aba4: 80 a3 e0 0f cmp %o7, 0xf <== NOT EXECUTED
201aba8: 32 80 00 d6 bne,a 201af00 <msdos_dir_read+0x478> <== NOT EXECUTED
201abac: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
/*
* Check the attribute to see if the entry is for a long file
* name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
201abb0: 88 09 20 3f and %g4, 0x3f, %g4 <== NOT EXECUTED
201abb4: 80 a1 20 0f cmp %g4, 0xf <== NOT EXECUTED
201abb8: 12 80 00 3e bne 201acb0 <msdos_dir_read+0x228> <== NOT EXECUTED
201abbc: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
201abc0: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
201abc4: 32 80 00 0f bne,a 201ac00 <msdos_dir_read+0x178> <== NOT EXECUTED
201abc8: c6 0d c0 00 ldub [ %l7 ], %g3 <== NOT EXECUTED
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
201abcc: 88 08 e0 40 and %g3, 0x40, %g4 <== NOT EXECUTED
201abd0: 80 89 20 ff btst 0xff, %g4 <== NOT EXECUTED
201abd4: 22 80 00 cb be,a 201af00 <msdos_dir_read+0x478> <== NOT EXECUTED
201abd8: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
201abdc: b6 07 00 11 add %i4, %l1, %i3 <== NOT EXECUTED
/*
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
201abe0: ba 08 e0 3f and %g3, 0x3f, %i5 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
201abe4: b7 36 e0 05 srl %i3, 5, %i3 <== NOT EXECUTED
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
201abe8: e8 0d e0 0d ldub [ %l7 + 0xd ], %l4 <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
201abec: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
201abf0: 92 10 20 00 clr %o1 <== NOT EXECUTED
201abf4: 40 00 05 6a call 201c19c <memset> <== NOT EXECUTED
201abf8: 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) &
201abfc: c6 0d c0 00 ldub [ %l7 ], %g3 <== NOT EXECUTED
201ac00: 86 08 e0 3f and %g3, 0x3f, %g3 <== NOT EXECUTED
201ac04: 80 a7 40 03 cmp %i5, %g3 <== NOT EXECUTED
201ac08: 32 80 00 bb bne,a 201aef4 <msdos_dir_read+0x46c> <== NOT EXECUTED
201ac0c: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
201ac10: c6 0d e0 0d ldub [ %l7 + 0xd ], %g3 <== NOT EXECUTED
201ac14: 88 0d 20 ff and %l4, 0xff, %g4 <== NOT EXECUTED
201ac18: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED
201ac1c: 32 80 00 b6 bne,a 201aef4 <msdos_dir_read+0x46c> <== NOT EXECUTED
201ac20: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
* The DOS maximum length is 255 characters without the
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
201ac24: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
201ac28: 87 2f 60 02 sll %i5, 2, %g3 <== NOT EXECUTED
201ac2c: 89 2f 60 04 sll %i5, 4, %g4 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
201ac30: 82 07 be e8 add %fp, -280, %g1 <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
201ac34: 88 21 00 03 sub %g4, %g3, %g4 <== NOT EXECUTED
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
201ac38: 84 05 e0 01 add %l7, 1, %g2 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
201ac3c: 88 01 00 1d add %g4, %i5, %g4 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
201ac40: 86 10 20 00 clr %g3 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
201ac44: 9e 00 40 04 add %g1, %g4, %o7 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
201ac48: 9a 00 c0 04 add %g3, %g4, %o5 <== NOT EXECUTED
201ac4c: 80 a3 60 fe cmp %o5, 0xfe <== NOT EXECUTED
201ac50: 18 80 00 a3 bgu 201aedc <msdos_dir_read+0x454> <== NOT EXECUTED
201ac54: 9a 03 c0 03 add %o7, %g3, %o5 <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
201ac58: d8 08 80 00 ldub [ %g2 ], %o4 <== NOT EXECUTED
201ac5c: d8 2b 60 14 stb %o4, [ %o5 + 0x14 ] <== NOT EXECUTED
if (*p == '\0')
201ac60: da 48 80 00 ldsb [ %g2 ], %o5 <== NOT EXECUTED
201ac64: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
201ac68: 02 80 00 9d be 201aedc <msdos_dir_read+0x454> <== NOT EXECUTED
201ac6c: 80 a0 e0 04 cmp %g3, 4 <== NOT EXECUTED
break;
switch (q)
201ac70: 02 80 00 06 be 201ac88 <msdos_dir_read+0x200> <== NOT EXECUTED
201ac74: 80 a0 e0 0a cmp %g3, 0xa <== NOT EXECUTED
201ac78: 32 80 00 08 bne,a 201ac98 <msdos_dir_read+0x210> <== NOT EXECUTED
201ac7c: 84 00 a0 02 add %g2, 2, %g2 <== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
201ac80: 10 80 00 04 b 201ac90 <msdos_dir_read+0x208> <== NOT EXECUTED
201ac84: 84 00 a0 04 add %g2, 4, %g2 <== NOT EXECUTED
switch (q)
{
case 4:
p += 5;
break;
201ac88: 10 80 00 04 b 201ac98 <msdos_dir_read+0x210> <== NOT EXECUTED
201ac8c: 84 00 a0 05 add %g2, 5, %g2 <== NOT EXECUTED
case 10:
p += 4;
break;
201ac90: 10 80 00 03 b 201ac9c <msdos_dir_read+0x214> <== NOT EXECUTED
201ac94: 86 00 e0 01 inc %g3 <== NOT EXECUTED
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
201ac98: 86 00 e0 01 inc %g3 <== NOT EXECUTED
201ac9c: 80 a0 e0 0d cmp %g3, 0xd <== NOT EXECUTED
201aca0: 12 bf ff eb bne 201ac4c <msdos_dir_read+0x1c4> <== NOT EXECUTED
201aca4: 9a 00 c0 04 add %g3, %g4, %o5 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
201aca8: 10 80 00 8e b 201aee0 <msdos_dir_read+0x458> <== NOT EXECUTED
201acac: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
201acb0: 02 80 00 04 be 201acc0 <msdos_dir_read+0x238> <== NOT EXECUTED
201acb4: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
201acb8: 10 80 00 8e b 201aef0 <msdos_dir_read+0x468> <== NOT EXECUTED
201acbc: a6 04 ff ff add %l3, -1, %l3 <== NOT EXECUTED
* unfortunately there is no method to extract ino except to
* open fat-file descriptor :( ... so, open it
*/
/* get number of cluster we are working with */
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
201acc0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201acc4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
201acc8: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
201accc: 7f ff de 72 call 2012694 <fat_file_ioctl> <== NOT EXECUTED
201acd0: 98 07 be d4 add %fp, -300, %o4 <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
201acd4: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
201acd8: 12 80 00 7d bne 201aecc <msdos_dir_read+0x444> <== NOT EXECUTED
201acdc: c6 07 be d4 ld [ %fp + -300 ], %g3 <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
201ace0: 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;
201ace4: c6 27 be d8 st %g3, [ %fp + -296 ] <== NOT EXECUTED
201ace8: c2 27 be e0 st %g1, [ %fp + -288 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
201acec: c2 27 be e4 st %g1, [ %fp + -284 ] <== NOT EXECUTED
dir_pos.sname.ofs = i;
201acf0: f8 27 be dc st %i4, [ %fp + -292 ] <== NOT EXECUTED
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
201acf4: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
201acf8: 92 07 be d8 add %fp, -296, %o1 <== NOT EXECUTED
201acfc: 7f ff dd 23 call 2012188 <fat_file_open> <== NOT EXECUTED
201ad00: 94 07 be d0 add %fp, -304, %o2 <== NOT EXECUTED
if (rc != RC_OK)
201ad04: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
201ad08: 12 80 00 71 bne 201aecc <msdos_dir_read+0x444> <== NOT EXECUTED
201ad0c: c6 07 be d0 ld [ %fp + -304 ], %g3 <== NOT EXECUTED
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
201ad10: 82 10 21 18 mov 0x118, %g1 <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
201ad14: c6 00 e0 0c ld [ %g3 + 0xc ], %g3 <== NOT EXECUTED
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
201ad18: c0 27 be f0 clr [ %fp + -272 ] <== NOT EXECUTED
201ad1c: f4 27 be f4 st %i2, [ %fp + -268 ] <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
201ad20: 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)
201ad24: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
201ad28: 02 80 00 1d be 201ad9c <msdos_dir_read+0x314> <== NOT EXECUTED
201ad2c: c6 27 be e8 st %g3, [ %fp + -280 ] <== NOT EXECUTED
201ad30: 88 10 20 00 clr %g4 <== NOT EXECUTED
201ad34: 86 10 20 00 clr %g3 <== NOT EXECUTED
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
201ad38: da 0d c0 04 ldub [ %l7 + %g4 ], %o5 <== NOT EXECUTED
201ad3c: 9e 08 e0 01 and %g3, 1, %o7 <== NOT EXECUTED
201ad40: 80 a0 00 0f cmp %g0, %o7 <== NOT EXECUTED
201ad44: 86 08 e0 ff and %g3, 0xff, %g3 <== NOT EXECUTED
201ad48: 9e 40 3f ff addx %g0, -1, %o7 <== NOT EXECUTED
201ad4c: 87 30 e0 01 srl %g3, 1, %g3 <== NOT EXECUTED
201ad50: 9e 0b e0 80 and %o7, 0x80, %o7 <== NOT EXECUTED
201ad54: 86 03 40 03 add %o5, %g3, %g3 <== NOT EXECUTED
201ad58: 9e 03 ff 80 add %o7, -128, %o7 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
201ad5c: 88 01 20 01 inc %g4 <== NOT EXECUTED
201ad60: 80 a1 20 0b cmp %g4, 0xb <== NOT EXECUTED
201ad64: 12 bf ff f5 bne 201ad38 <msdos_dir_read+0x2b0> <== NOT EXECUTED
201ad68: 86 00 c0 0f add %g3, %o7, %g3 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
201ad6c: 86 18 c0 14 xor %g3, %l4, %g3 <== NOT EXECUTED
201ad70: 80 88 e0 ff btst 0xff, %g3 <== NOT EXECUTED
201ad74: 12 80 00 0b bne 201ada0 <msdos_dir_read+0x318> <== NOT EXECUTED
201ad78: 86 10 20 08 mov 8, %g3 <== NOT EXECUTED
201ad7c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
201ad80: 12 80 00 09 bne 201ada4 <msdos_dir_read+0x31c> <== NOT EXECUTED
201ad84: 88 05 c0 03 add %l7, %g3, %g4 <== NOT EXECUTED
201ad88: 30 80 00 70 b,a 201af48 <msdos_dir_read+0x4c0> <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
201ad8c: 32 80 00 06 bne,a 201ada4 <msdos_dir_read+0x31c> <== NOT EXECUTED
201ad90: 88 05 c0 03 add %l7, %g3, %g4 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
201ad94: 10 80 00 09 b 201adb8 <msdos_dir_read+0x330> <== NOT EXECUTED
201ad98: 03 00 80 b4 sethi %hi(0x202d000), %g1 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
201ad9c: 86 10 20 08 mov 8, %g3 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
201ada0: 88 05 c0 03 add %l7, %g3, %g4 <== NOT EXECUTED
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
201ada4: c8 49 3f ff ldsb [ %g4 + -1 ], %g4 <== NOT EXECUTED
201ada8: 80 a1 20 20 cmp %g4, 0x20 <== NOT EXECUTED
201adac: 22 bf ff f8 be,a 201ad8c <msdos_dir_read+0x304> <== NOT EXECUTED
201adb0: 86 80 ff ff addcc %g3, -1, %g3 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
201adb4: 03 00 80 b4 sethi %hi(0x202d000), %g1 <== NOT EXECUTED
201adb8: b6 10 20 00 clr %i3 <== NOT EXECUTED
201adbc: da 00 60 08 ld [ %g1 + 8 ], %o5 <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
201adc0: 10 80 00 0b b 201adec <msdos_dir_read+0x364> <== NOT EXECUTED
201adc4: 88 07 be fc add %fp, -260, %g4 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
201adc8: 98 03 40 0f add %o5, %o7, %o4 <== NOT EXECUTED
201adcc: d8 0b 20 01 ldub [ %o4 + 1 ], %o4 <== NOT EXECUTED
201add0: 98 0b 20 03 and %o4, 3, %o4 <== NOT EXECUTED
201add4: 80 a3 20 01 cmp %o4, 1 <== NOT EXECUTED
201add8: 22 80 00 02 be,a 201ade0 <msdos_dir_read+0x358> <== NOT EXECUTED
201addc: 9e 03 e0 20 add %o7, 0x20, %o7 <== NOT EXECUTED
201ade0: de 29 00 00 stb %o7, [ %g4 ] <== NOT EXECUTED
201ade4: b6 06 e0 01 inc %i3 <== NOT EXECUTED
201ade8: 88 01 20 01 inc %g4 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
201adec: 9e 20 c0 1b sub %g3, %i3, %o7 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
201adf0: 80 a3 e0 00 cmp %o7, 0 <== NOT EXECUTED
201adf4: 34 bf ff f5 bg,a 201adc8 <msdos_dir_read+0x340> <== NOT EXECUTED
201adf8: de 0d c0 1b ldub [ %l7 + %i3 ], %o7 <== NOT EXECUTED
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
201adfc: f6 4d e0 0a ldsb [ %l7 + 0xa ], %i3 <== NOT EXECUTED
201ae00: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
201ae04: 12 80 00 55 bne 201af58 <msdos_dir_read+0x4d0> <== NOT EXECUTED
201ae08: b6 10 20 03 mov 3, %i3 <== NOT EXECUTED
201ae0c: f6 4d e0 09 ldsb [ %l7 + 9 ], %i3 <== NOT EXECUTED
201ae10: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
201ae14: 12 80 00 51 bne 201af58 <msdos_dir_read+0x4d0> <== NOT EXECUTED
201ae18: b6 10 20 02 mov 2, %i3 <== NOT EXECUTED
201ae1c: f6 4d e0 08 ldsb [ %l7 + 8 ], %i3 <== NOT EXECUTED
201ae20: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
201ae24: 22 80 00 18 be,a 201ae84 <msdos_dir_read+0x3fc> <== NOT EXECUTED
201ae28: c0 29 00 00 clrb [ %g4 ] <== NOT EXECUTED
201ae2c: 10 80 00 4b b 201af58 <msdos_dir_read+0x4d0> <== NOT EXECUTED
201ae30: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
201ae34: da 0b 60 08 ldub [ %o5 + 8 ], %o5 <== NOT EXECUTED
201ae38: 94 03 00 0d add %o4, %o5, %o2 <== NOT EXECUTED
201ae3c: d4 0a a0 01 ldub [ %o2 + 1 ], %o2 <== NOT EXECUTED
201ae40: 94 0a a0 03 and %o2, 3, %o2 <== NOT EXECUTED
201ae44: 80 a2 a0 01 cmp %o2, 1 <== NOT EXECUTED
201ae48: 22 80 00 02 be,a 201ae50 <msdos_dir_read+0x3c8> <== NOT EXECUTED
201ae4c: 9a 03 60 20 add %o5, 0x20, %o5 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
201ae50: 94 01 00 0f add %g4, %o7, %o2 <== NOT EXECUTED
201ae54: 9e 03 e0 01 inc %o7 <== NOT EXECUTED
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
201ae58: da 2a a0 01 stb %o5, [ %o2 + 1 ] <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
201ae5c: 9a 26 c0 0f sub %i3, %o7, %o5 <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
201ae60: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
201ae64: 14 bf ff f4 bg 201ae34 <msdos_dir_read+0x3ac> <== NOT EXECUTED
201ae68: 9a 05 c0 0f add %l7, %o7, %o5 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
201ae6c: 84 38 00 1b xnor %g0, %i3, %g2 <== NOT EXECUTED
201ae70: 85 38 a0 1f sra %g2, 0x1f, %g2 <== NOT EXECUTED
201ae74: b6 0e c0 02 and %i3, %g2, %i3 <== NOT EXECUTED
201ae78: 88 02 c0 1b add %o3, %i3, %g4 <== NOT EXECUTED
201ae7c: 86 00 c0 1b add %g3, %i3, %g3 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
201ae80: c0 29 00 00 clrb [ %g4 ] <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
201ae84: c6 37 be fa sth %g3, [ %fp + -262 ] <== NOT EXECUTED
201ae88: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
201ae8c: c2 07 a0 48 ld [ %fp + 0x48 ], %g1 <== NOT EXECUTED
201ae90: 92 07 be e8 add %fp, -280, %o1 <== NOT EXECUTED
201ae94: 90 00 40 1a add %g1, %i2, %o0 <== NOT EXECUTED
201ae98: 40 00 04 84 call 201c0a8 <memcpy> <== NOT EXECUTED
201ae9c: 94 10 21 18 mov 0x118, %o2 <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
201aea0: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
201aea4: 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);
201aea8: 9a 80 e1 18 addcc %g3, 0x118, %o5 <== NOT EXECUTED
201aeac: 98 40 a0 00 addx %g2, 0, %o4 <== 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);
201aeb0: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
201aeb4: d8 3e 20 08 std %o4, [ %i0 + 8 ] <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
201aeb8: 7f ff dd ca call 20125e0 <fat_file_close> <== NOT EXECUTED
201aebc: b4 06 a1 18 add %i2, 0x118, %i2 <== NOT EXECUTED
if (rc != RC_OK)
201aec0: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
201aec4: 02 80 00 06 be 201aedc <msdos_dir_read+0x454> <== NOT EXECUTED
201aec8: a4 04 be e8 add %l2, -280, %l2 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
201aecc: 7f ff ba b7 call 20099a8 <rtems_semaphore_release> <== NOT EXECUTED
201aed0: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
201aed4: 81 c7 e0 08 ret <== NOT EXECUTED
201aed8: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
201aedc: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
201aee0: 32 80 00 08 bne,a 201af00 <msdos_dir_read+0x478> <== NOT EXECUTED
201aee4: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
201aee8: 10 80 00 10 b 201af28 <msdos_dir_read+0x4a0> <== NOT EXECUTED
201aeec: a2 04 40 15 add %l1, %l5, %l1 <== NOT EXECUTED
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
lfn_start = FAT_FILE_SHORT_NAME;
201aef0: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
201aef4: 10 80 00 03 b 201af00 <msdos_dir_read+0x478> <== NOT EXECUTED
201aef8: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
201aefc: b8 10 20 00 clr %i4 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
201af00: c2 07 be cc ld [ %fp + -308 ], %g1 <== NOT EXECUTED
201af04: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
201af08: 2a bf ff 18 bcs,a 201ab68 <msdos_dir_read+0xe0> <== NOT EXECUTED
201af0c: c6 05 a0 a0 ld [ %l6 + 0xa0 ], %g3 <== NOT EXECUTED
201af10: 10 80 00 06 b 201af28 <msdos_dir_read+0x4a0> <== NOT EXECUTED
201af14: a2 04 40 15 add %l1, %l5, %l1 <== NOT EXECUTED
fat_fd->fat_file_size :
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201af18: ba 10 20 00 clr %i5 <== NOT EXECUTED
201af1c: a8 10 20 00 clr %l4 <== NOT EXECUTED
201af20: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
201af24: b4 10 20 00 clr %i2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
201af28: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
201af2c: 32 bf ff 00 bne,a 201ab2c <msdos_dir_read+0xa4> <== NOT EXECUTED
201af30: d8 05 a0 a0 ld [ %l6 + 0xa0 ], %o4 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
201af34: d0 05 a0 9c ld [ %l6 + 0x9c ], %o0 <== NOT EXECUTED
201af38: 7f ff ba 9c call 20099a8 <rtems_semaphore_release> <== NOT EXECUTED
201af3c: b2 10 00 1a mov %i2, %i1 <== NOT EXECUTED
return cmpltd;
}
201af40: 81 c7 e0 08 ret <== NOT EXECUTED
201af44: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
tmp_dirent.d_name, entry); /* src text */
}
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
201af48: 40 00 0a a3 call 201d9d4 <strlen> <== NOT EXECUTED
201af4c: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
201af50: 10 bf ff cf b 201ae8c <msdos_dir_read+0x404> <== NOT EXECUTED
201af54: d0 37 be fa sth %o0, [ %fp + -262 ] <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
201af58: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED
len += i + 1; /* extension + dot */
201af5c: 9e 06 e0 01 add %i3, 1, %o7 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
201af60: c2 29 00 00 stb %g1, [ %g4 ] <== NOT EXECUTED
len += i + 1; /* extension + dot */
201af64: 86 00 c0 0f add %g3, %o7, %g3 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
201af68: 03 00 80 b4 sethi %hi(0x202d000), %g1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
201af6c: 96 01 20 01 add %g4, 1, %o3 <== NOT EXECUTED
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
201af70: d8 00 60 08 ld [ %g1 + 8 ], %o4 <== NOT EXECUTED
201af74: 10 bf ff ba b 201ae5c <msdos_dir_read+0x3d4> <== NOT EXECUTED
201af78: 9e 10 20 00 clr %o7 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
201af7c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
201af80: 81 c7 e0 08 ret <== NOT EXECUTED
201af84: 81 e8 00 00 restore <== NOT EXECUTED
0201af88 <msdos_dir_stat>:
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
201af88: 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;
201af8c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
201af90: 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;
201af94: 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,
201af98: 92 10 20 00 clr %o1
201af9c: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
201afa0: 7f ff ba 39 call 2009884 <rtems_semaphore_obtain>
201afa4: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201afa8: 80 a2 20 00 cmp %o0, 0
201afac: 22 80 00 08 be,a 201afcc <msdos_dir_stat+0x44> <== ALWAYS TAKEN
201afb0: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
201afb4: 40 00 01 7e call 201b5ac <__errno> <== NOT EXECUTED
201afb8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201afbc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201afc0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201afc4: 81 c7 e0 08 ret <== NOT EXECUTED
201afc8: 81 e8 00 00 restore <== NOT EXECUTED
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
buf->st_mtime = fat_fd->mtime;
rtems_semaphore_release(fs_info->vol_sema);
201afcc: 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);
201afd0: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
201afd4: c2 07 20 0c ld [ %i4 + 0xc ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
201afd8: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
201afdc: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
201afe0: 03 00 00 10 sethi %hi(0x4000), %g1
201afe4: 82 10 61 ff or %g1, 0x1ff, %g1 ! 41ff <PROM_START+0x41ff>
201afe8: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
201afec: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
201aff0: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
201aff4: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
201aff8: 83 30 60 09 srl %g1, 9, %g1
201affc: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
buf->st_blksize = fs_info->fat.vol.bps;
201b000: c2 17 40 00 lduh [ %i5 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
201b004: c0 26 60 1c clr [ %i1 + 0x1c ]
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
201b008: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
201b00c: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
201b010: c0 26 60 20 clr [ %i1 + 0x20 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
buf->st_mtime = fat_fd->mtime;
201b014: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
201b018: 7f ff ba 64 call 20099a8 <rtems_semaphore_release>
201b01c: b0 10 20 00 clr %i0
return RC_OK;
}
201b020: 81 c7 e0 08 ret
201b024: 81 e8 00 00 restore
02017ae0 <msdos_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
2017ae0: 9d e3 bf a0 save %sp, -96, %sp
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
2017ae4: 82 10 20 00 clr %g1
2017ae8: 80 a6 e0 01 cmp %i3, 1
2017aec: 12 80 00 06 bne 2017b04 <msdos_eval_token+0x24>
2017af0: ba 10 00 18 mov %i0, %i5
2017af4: c2 4e 80 00 ldsb [ %i2 ], %g1
2017af8: 82 18 60 2e xor %g1, 0x2e, %g1
2017afc: 80 a0 00 01 cmp %g0, %g1
2017b00: 82 60 3f ff subx %g0, -1, %g1
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
2017b04: 80 a0 60 00 cmp %g1, 0
2017b08: 02 80 00 05 be 2017b1c <msdos_eval_token+0x3c>
2017b0c: b0 10 20 00 clr %i0
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
2017b10: c0 27 60 0c clr [ %i5 + 0xc ]
2017b14: 81 c7 e0 08 ret
2017b18: 81 e8 00 00 restore
rtems_filesystem_eval_path_clear_token(ctx);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
} else {
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc(ctx);
int rc = msdos_find_name(currentloc, token, tokenlen);
2017b1c: 90 07 60 18 add %i5, 0x18, %o0
2017b20: 92 10 00 1a mov %i2, %o1
2017b24: 40 00 05 aa call 20191cc <msdos_find_name>
2017b28: 94 10 00 1b mov %i3, %o2
if (rc == RC_OK) {
2017b2c: 80 a2 20 00 cmp %o0, 0
2017b30: 12 80 00 12 bne 2017b78 <msdos_eval_token+0x98>
2017b34: 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)
2017b38: 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;
2017b3c: 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)
2017b40: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
2017b44: c0 27 60 0c clr [ %i5 + 0xc ]
2017b48: 80 a0 a0 00 cmp %g2, 0
2017b4c: 12 80 00 04 bne 2017b5c <msdos_eval_token+0x7c>
2017b50: c2 00 60 08 ld [ %g1 + 8 ], %g1
loc->handlers = fs_info->directory_handlers;
2017b54: 10 80 00 03 b 2017b60 <msdos_eval_token+0x80>
2017b58: c2 00 60 94 ld [ %g1 + 0x94 ], %g1
else
loc->handlers = fs_info->file_handlers;
2017b5c: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
2017b60: 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)) {
2017b64: c2 07 60 04 ld [ %i5 + 4 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
2017b68: 80 a0 00 01 cmp %g0, %g1
2017b6c: b0 60 3f ff subx %g0, -1, %i0
2017b70: 81 c7 e0 08 ret
2017b74: 81 e8 00 00 restore
rtems_filesystem_eval_path_clear_token(ctx);
msdos_set_handlers(currentloc);
if (rtems_filesystem_eval_path_has_path(ctx)) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else if (rc == MSDOS_NAME_NOT_FOUND_ERR) {
2017b78: 82 10 61 01 or %g1, 0x101, %g1
2017b7c: 80 a2 00 01 cmp %o0, %g1
2017b80: 02 bf ff e5 be 2017b14 <msdos_eval_token+0x34> <== ALWAYS TAKEN
2017b84: b0 10 20 02 mov 2, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
} else {
rtems_filesystem_eval_path_error(ctx, 0);
2017b88: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2017b8c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2017b90: 7f ff ba 79 call 2006574 <rtems_filesystem_eval_path_error><== NOT EXECUTED
2017b94: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
}
return status;
}
2017b98: 81 c7 e0 08 ret <== NOT EXECUTED
2017b9c: 81 e8 00 00 restore <== NOT EXECUTED
0201b084 <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)
{
201b084: 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;
201b088: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201b08c: 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;
201b090: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201b094: 94 10 20 00 clr %o2
201b098: 7f ff b9 fb call 2009884 <rtems_semaphore_obtain>
201b09c: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201b0a0: 80 a2 20 00 cmp %o0, 0
201b0a4: 02 80 00 08 be 201b0c4 <msdos_file_close+0x40> <== ALWAYS TAKEN
201b0a8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
201b0ac: 40 00 01 40 call 201b5ac <__errno> <== NOT EXECUTED
201b0b0: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
201b0b4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201b0b8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201b0bc: 81 c7 e0 08 ret <== NOT EXECUTED
201b0c0: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_file_update(iop);
201b0c4: 7f ff ff d9 call 201b028 <msdos_file_update>
201b0c8: 90 10 00 18 mov %i0, %o0
201b0cc: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
201b0d0: 7f ff ba 36 call 20099a8 <rtems_semaphore_release>
201b0d4: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
201b0d8: 81 c7 e0 08 ret
201b0dc: 81 e8 00 00 restore
0201b2e8 <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)
{
201b2e8: 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;
201b2ec: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
201b2f0: 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;
201b2f4: 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,
201b2f8: 92 10 20 00 clr %o1
201b2fc: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
201b300: 7f ff b9 61 call 2009884 <rtems_semaphore_obtain>
201b304: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201b308: 80 a2 20 00 cmp %o0, 0
201b30c: 02 80 00 08 be 201b32c <msdos_file_ftruncate+0x44> <== ALWAYS TAKEN
201b310: 80 a2 00 19 cmp %o0, %i1
rtems_set_errno_and_return_minus_one(EIO);
201b314: 40 00 00 a6 call 201b5ac <__errno> <== NOT EXECUTED
201b318: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201b31c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201b320: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201b324: 81 c7 e0 08 ret <== NOT EXECUTED
201b328: 81 e8 00 00 restore <== NOT EXECUTED
old_length = fat_fd->fat_file_size;
if (length < old_length) {
201b32c: 14 80 00 08 bg 201b34c <msdos_file_ftruncate+0x64> <== NEVER TAKEN
201b330: f6 07 20 18 ld [ %i4 + 0x18 ], %i3
201b334: 80 a2 00 19 cmp %o0, %i1
201b338: 12 80 00 0d bne 201b36c <msdos_file_ftruncate+0x84> <== NEVER TAKEN
201b33c: 90 10 00 1d mov %i5, %o0
201b340: 80 a6 c0 1a cmp %i3, %i2
201b344: 08 80 00 0b bleu 201b370 <msdos_file_ftruncate+0x88>
201b348: 92 10 00 1c mov %i4, %o1
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
201b34c: 90 10 00 1d mov %i5, %o0
201b350: 92 10 00 1c mov %i4, %o1
201b354: 7f ff dc 5e call 20124cc <fat_file_truncate>
201b358: 94 10 00 1a mov %i2, %o2
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK) {
201b35c: b0 92 20 00 orcc %o0, 0, %i0
201b360: 22 80 00 18 be,a 201b3c0 <msdos_file_ftruncate+0xd8> <== ALWAYS TAKEN
201b364: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
201b368: 30 80 00 16 b,a 201b3c0 <msdos_file_ftruncate+0xd8> <== NOT EXECUTED
if (length < old_length) {
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
} else {
uint32_t new_length;
rc = fat_file_extend(&fs_info->fat,
201b36c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201b370: 94 10 20 01 mov 1, %o2
201b374: 96 10 00 1a mov %i2, %o3
201b378: 7f ff dc fb call 2012764 <fat_file_extend>
201b37c: 98 07 bf fc add %fp, -4, %o4
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
201b380: b0 92 20 00 orcc %o0, 0, %i0
201b384: 12 80 00 0f bne 201b3c0 <msdos_file_ftruncate+0xd8> <== NEVER TAKEN
201b388: 80 a6 60 00 cmp %i1, 0
201b38c: 12 80 00 05 bne 201b3a0 <msdos_file_ftruncate+0xb8> <== NEVER TAKEN
201b390: c2 07 bf fc ld [ %fp + -4 ], %g1
201b394: 80 a6 80 01 cmp %i2, %g1
201b398: 22 80 00 0a be,a 201b3c0 <msdos_file_ftruncate+0xd8> <== ALWAYS TAKEN
201b39c: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
201b3a0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201b3a4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
201b3a8: 7f ff dc 49 call 20124cc <fat_file_truncate> <== NOT EXECUTED
201b3ac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
errno = ENOSPC;
201b3b0: 40 00 00 7f call 201b5ac <__errno> <== NOT EXECUTED
201b3b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201b3b8: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
201b3bc: 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);
201b3c0: 7f ff b9 7a call 20099a8 <rtems_semaphore_release>
201b3c4: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
201b3c8: 81 c7 e0 08 ret
201b3cc: 81 e8 00 00 restore
0201b0e0 <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)
{
201b0e0: 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;
201b0e4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
201b0e8: 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;
201b0ec: 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,
201b0f0: 92 10 20 00 clr %o1
201b0f4: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
201b0f8: 7f ff b9 e3 call 2009884 <rtems_semaphore_obtain>
201b0fc: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201b100: 80 a2 20 00 cmp %o0, 0
201b104: 22 80 00 07 be,a 201b120 <msdos_file_read+0x40> <== ALWAYS TAKEN
201b108: d4 06 20 0c ld [ %i0 + 0xc ], %o2
rtems_set_errno_and_return_minus_one(EIO);
201b10c: 40 00 01 28 call 201b5ac <__errno> <== NOT EXECUTED
201b110: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
201b114: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201b118: 10 80 00 10 b 201b158 <msdos_file_read+0x78> <== NOT EXECUTED
201b11c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
201b120: 98 10 00 19 mov %i1, %o4
201b124: 90 10 00 10 mov %l0, %o0
201b128: 92 10 00 1d mov %i5, %o1
201b12c: 7f ff dc 7a call 2012314 <fat_file_read>
201b130: 96 10 00 1a mov %i2, %o3
buffer);
if (ret > 0)
201b134: b2 92 20 00 orcc %o0, 0, %i1
201b138: 04 80 00 06 ble 201b150 <msdos_file_read+0x70>
201b13c: 85 3e 60 1f sra %i1, 0x1f, %g2
iop->offset += ret;
201b140: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
201b144: b6 87 40 19 addcc %i5, %i1, %i3
201b148: b4 47 00 02 addx %i4, %g2, %i2
201b14c: f4 3e 20 08 std %i2, [ %i0 + 8 ]
rtems_semaphore_release(fs_info->vol_sema);
201b150: 7f ff ba 16 call 20099a8 <rtems_semaphore_release>
201b154: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
return ret;
}
201b158: 81 c7 e0 08 ret
201b15c: 91 e8 00 19 restore %g0, %i1, %o0
0201b238 <msdos_file_stat>:
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
201b238: 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;
201b23c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
201b240: 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;
201b244: 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,
201b248: 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;
201b24c: f6 17 60 06 lduh [ %i5 + 6 ], %i3
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201b250: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
201b254: 94 10 20 00 clr %o2
201b258: 7f ff b9 8b call 2009884 <rtems_semaphore_obtain>
201b25c: b6 06 ff ff add %i3, -1, %i3
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201b260: 80 a2 20 00 cmp %o0, 0
201b264: 22 80 00 08 be,a 201b284 <msdos_file_stat+0x4c> <== ALWAYS TAKEN
201b268: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
201b26c: 40 00 00 d0 call 201b5ac <__errno> <== NOT EXECUTED
201b270: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201b274: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201b278: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201b27c: 81 c7 e0 08 ret <== NOT EXECUTED
201b280: 81 e8 00 00 restore <== NOT EXECUTED
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;
rtems_semaphore_release(fs_info->vol_sema);
201b284: 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);
201b288: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
201b28c: c2 07 20 0c ld [ %i4 + 0xc ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
201b290: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
201b294: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
201b298: 03 00 00 20 sethi %hi(0x8000), %g1
201b29c: 82 10 61 ff or %g1, 0x1ff, %g1 ! 81ff <PROM_START+0x81ff>
201b2a0: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
201b2a4: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
201b2a8: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
201b2ac: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
201b2b0: 82 06 c0 01 add %i3, %g1, %g1
201b2b4: b6 28 40 1b andn %g1, %i3, %i3
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
201b2b8: c2 17 60 06 lduh [ %i5 + 6 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
201b2bc: c0 26 60 1c clr [ %i1 + 0x1c ]
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;
201b2c0: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
201b2c4: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
201b2c8: c0 26 60 20 clr [ %i1 + 0x20 ]
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
201b2cc: b7 36 e0 09 srl %i3, 9, %i3
buf->st_blksize = fs_info->fat.vol.bpc;
buf->st_mtime = fat_fd->mtime;
201b2d0: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
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;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
201b2d4: f6 26 60 44 st %i3, [ %i1 + 0x44 ]
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
buf->st_mtime = fat_fd->mtime;
rtems_semaphore_release(fs_info->vol_sema);
201b2d8: 7f ff b9 b4 call 20099a8 <rtems_semaphore_release>
201b2dc: b0 10 20 00 clr %i0
return RC_OK;
}
201b2e0: 81 c7 e0 08 ret
201b2e4: 81 e8 00 00 restore
0201b3d0 <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
201b3d0: 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;
201b3d4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201b3d8: 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;
201b3dc: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
201b3e0: 94 10 20 00 clr %o2
201b3e4: 7f ff b9 28 call 2009884 <rtems_semaphore_obtain>
201b3e8: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201b3ec: 80 a2 20 00 cmp %o0, 0
201b3f0: 02 80 00 08 be 201b410 <msdos_file_sync+0x40> <== ALWAYS TAKEN
201b3f4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
201b3f8: 40 00 00 6d call 201b5ac <__errno> <== NOT EXECUTED
201b3fc: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
201b400: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201b404: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201b408: 81 c7 e0 08 ret <== NOT EXECUTED
201b40c: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_file_update(iop);
201b410: 7f ff ff 06 call 201b028 <msdos_file_update>
201b414: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
201b418: b0 92 20 00 orcc %o0, 0, %i0
201b41c: 12 80 00 04 bne 201b42c <msdos_file_sync+0x5c> <== NEVER TAKEN
201b420: 01 00 00 00 nop
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = fat_sync(&fs_info->fat);
201b424: 7f ff e1 c0 call 2013b24 <fat_sync>
201b428: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release(fs_info->vol_sema);
201b42c: 7f ff b9 5f call 20099a8 <rtems_semaphore_release>
201b430: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return RC_OK;
}
201b434: 81 c7 e0 08 ret
201b438: 81 e8 00 00 restore
0201b028 <msdos_file_update>:
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
201b028: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
201b02c: 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))
201b030: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
201b034: 80 88 60 01 btst 1, %g1
201b038: 12 80 00 11 bne 201b07c <msdos_file_update+0x54> <== NEVER TAKEN
201b03c: 90 10 20 00 clr %o0
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
201b040: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
201b044: 7f ff f3 d3 call 2017f90 <msdos_set_first_cluster_num>
201b048: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
201b04c: 80 a2 20 00 cmp %o0, 0
201b050: 12 80 00 0b bne 201b07c <msdos_file_update+0x54> <== NEVER TAKEN
201b054: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
201b058: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
201b05c: 7f ff f3 ff call 2018058 <msdos_set_file_size>
201b060: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
201b064: 80 a2 20 00 cmp %o0, 0
201b068: 12 80 00 05 bne 201b07c <msdos_file_update+0x54> <== NEVER TAKEN
201b06c: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
201b070: f0 06 20 28 ld [ %i0 + 0x28 ], %i0
201b074: 7f ff f3 8c call 2017ea4 <msdos_set_dir_wrt_time_and_date>
201b078: 81 e8 00 00 restore
return rc;
}
}
return rc;
}
201b07c: 81 c7 e0 08 ret <== NOT EXECUTED
201b080: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
0201b160 <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)
{
201b160: 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;
201b164: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
201b168: 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;
201b16c: 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,
201b170: 92 10 20 00 clr %o1
201b174: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
201b178: 7f ff b9 c3 call 2009884 <rtems_semaphore_obtain>
201b17c: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201b180: 80 a2 20 00 cmp %o0, 0
201b184: 22 80 00 07 be,a 201b1a0 <msdos_file_write+0x40> <== ALWAYS TAKEN
201b188: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
201b18c: 40 00 01 08 call 201b5ac <__errno> <== NOT EXECUTED
201b190: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
201b194: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
201b198: 10 80 00 14 b 201b1e8 <msdos_file_write+0x88> <== NOT EXECUTED
201b19c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
201b1a0: 80 88 62 00 btst 0x200, %g1
201b1a4: 22 80 00 06 be,a 201b1bc <msdos_file_write+0x5c>
201b1a8: d4 06 20 0c ld [ %i0 + 0xc ], %o2
iop->offset = fat_fd->fat_file_size;
201b1ac: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
201b1b0: c0 26 20 08 clr [ %i0 + 8 ]
201b1b4: c2 26 20 0c st %g1, [ %i0 + 0xc ]
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
201b1b8: d4 06 20 0c ld [ %i0 + 0xc ], %o2
201b1bc: 98 10 00 19 mov %i1, %o4
201b1c0: 90 10 00 10 mov %l0, %o0
201b1c4: 92 10 00 11 mov %l1, %o1
201b1c8: 7f ff dd fd call 20129bc <fat_file_write>
201b1cc: 96 10 00 1a mov %i2, %o3
buffer);
if (ret < 0)
201b1d0: b2 92 20 00 orcc %o0, 0, %i1
201b1d4: 36 80 00 07 bge,a 201b1f0 <msdos_file_write+0x90> <== ALWAYS TAKEN
201b1d8: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
{
rtems_semaphore_release(fs_info->vol_sema);
201b1dc: 7f ff b9 f3 call 20099a8 <rtems_semaphore_release> <== NOT EXECUTED
201b1e0: d0 04 20 9c ld [ %l0 + 0x9c ], %o0 <== NOT EXECUTED
return -1;
201b1e4: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
201b1e8: 81 c7 e0 08 ret <== NOT EXECUTED
201b1ec: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
201b1f0: b9 3e 60 1f sra %i1, 0x1f, %i4
201b1f4: 86 86 40 1b addcc %i1, %i3, %g3
201b1f8: 84 47 00 1a addx %i4, %i2, %g2
201b1fc: c4 3e 20 08 std %g2, [ %i0 + 8 ]
if (iop->offset > fat_fd->fat_file_size)
201b200: 80 a0 a0 00 cmp %g2, 0
201b204: 14 80 00 07 bg 201b220 <msdos_file_write+0xc0> <== NEVER TAKEN
201b208: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
201b20c: 80 a0 a0 00 cmp %g2, 0
201b210: 12 80 00 05 bne 201b224 <msdos_file_write+0xc4> <== NEVER TAKEN
201b214: 80 a0 c0 01 cmp %g3, %g1
201b218: 08 80 00 03 bleu 201b224 <msdos_file_write+0xc4>
201b21c: 01 00 00 00 nop
fat_fd->fat_file_size = iop->offset;
201b220: c6 24 60 18 st %g3, [ %l1 + 0x18 ]
rtems_semaphore_release(fs_info->vol_sema);
201b224: 7f ff b9 e1 call 20099a8 <rtems_semaphore_release>
201b228: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
return ret;
}
201b22c: b0 10 00 19 mov %i1, %i0
201b230: 81 c7 e0 08 ret
201b234: 81 e8 00 00 restore
0201a90c <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
201a90c: 82 10 20 00 clr %g1
dn[i] = ' ';
201a910: 84 10 20 20 mov 0x20, %g2
201a914: 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++)
201a918: 82 00 60 01 inc %g1
201a91c: 80 a0 60 0b cmp %g1, 0xb
201a920: 32 bf ff fe bne,a 201a918 <msdos_filename_unix2dos+0xc>
201a924: 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) {
201a928: c2 4a 00 00 ldsb [ %o0 ], %g1
201a92c: 80 a0 60 2e cmp %g1, 0x2e
201a930: 12 80 00 12 bne 201a978 <msdos_filename_unix2dos+0x6c> <== ALWAYS TAKEN
201a934: 80 a2 60 00 cmp %o1, 0
201a938: 80 a2 60 01 cmp %o1, 1 <== NOT EXECUTED
201a93c: 32 80 00 04 bne,a 201a94c <msdos_filename_unix2dos+0x40> <== NOT EXECUTED
201a940: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
dn[0] = '.';
return 0;
201a944: 10 80 00 4f b 201aa80 <msdos_filename_unix2dos+0x174> <== NOT EXECUTED
201a948: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
201a94c: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
201a950: 12 80 00 0a bne 201a978 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED
201a954: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
201a958: 80 a2 60 02 cmp %o1, 2 <== NOT EXECUTED
201a95c: 12 80 00 07 bne 201a978 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED
201a960: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
dn[0] = '.';
201a964: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
dn[1] = '.';
return 0;
201a968: 10 80 00 46 b 201aa80 <msdos_filename_unix2dos+0x174> <== NOT EXECUTED
201a96c: c2 2a a0 01 stb %g1, [ %o2 + 1 ] <== NOT EXECUTED
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
un++;
unlen--;
201a970: 92 02 7f ff add %o1, -1, %o1 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
201a974: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
201a978: 32 80 00 05 bne,a 201a98c <msdos_filename_unix2dos+0x80> <== ALWAYS TAKEN
201a97c: c2 4a 00 00 ldsb [ %o0 ], %g1
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
201a980: 82 10 20 00 clr %g1 <== NOT EXECUTED
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
201a984: 10 80 00 0d b 201a9b8 <msdos_filename_unix2dos+0xac>
201a988: 1b 00 80 af sethi %hi(0x202bc00), %o5
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
201a98c: 80 a0 60 2e cmp %g1, 0x2e
201a990: 22 bf ff f8 be,a 201a970 <msdos_filename_unix2dos+0x64> <== NEVER TAKEN
201a994: 90 02 20 01 inc %o0 <== NOT EXECUTED
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
201a998: 10 bf ff fb b 201a984 <msdos_filename_unix2dos+0x78>
201a99c: 82 10 20 00 clr %g1
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
201a9a0: c8 0b 00 04 ldub [ %o4 + %g4 ], %g4
201a9a4: 80 89 20 ff btst 0xff, %g4
201a9a8: 02 80 00 1a be 201aa10 <msdos_filename_unix2dos+0x104>
201a9ac: 80 a0 a0 00 cmp %g2, 0
break;
dn[i] = msdos_map[c];
201a9b0: c8 2a 80 01 stb %g4, [ %o2 + %g1 ]
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
201a9b4: 82 00 60 01 inc %g1
201a9b8: 84 a2 40 01 subcc %o1, %g1, %g2
201a9bc: 02 80 00 14 be 201aa0c <msdos_filename_unix2dos+0x100>
201a9c0: 86 02 00 01 add %o0, %g1, %g3
201a9c4: 80 a0 60 07 cmp %g1, 7
201a9c8: 04 80 00 03 ble 201a9d4 <msdos_filename_unix2dos+0xc8>
201a9cc: 88 10 20 01 mov 1, %g4
201a9d0: 88 10 20 00 clr %g4
201a9d4: 80 89 20 ff btst 0xff, %g4
201a9d8: 02 80 00 0e be 201aa10 <msdos_filename_unix2dos+0x104>
201a9dc: 80 a0 a0 00 cmp %g2, 0
201a9e0: c8 0a 00 01 ldub [ %o0 + %g1 ], %g4
201a9e4: 80 a1 20 00 cmp %g4, 0
201a9e8: 02 80 00 09 be 201aa0c <msdos_filename_unix2dos+0x100> <== NEVER TAKEN
201a9ec: 80 a1 20 2e cmp %g4, 0x2e
201a9f0: 12 bf ff ec bne 201a9a0 <msdos_filename_unix2dos+0x94>
201a9f4: 98 13 62 e8 or %o5, 0x2e8, %o4
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
201a9f8: 10 80 00 06 b 201aa10 <msdos_filename_unix2dos+0x104>
201a9fc: 80 a0 a0 00 cmp %g2, 0
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
201aa00: 80 a0 60 2e cmp %g1, 0x2e
201aa04: 02 80 00 09 be 201aa28 <msdos_filename_unix2dos+0x11c>
201aa08: 84 00 bf ff add %g2, -1, %g2
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
201aa0c: 80 a0 a0 00 cmp %g2, 0
201aa10: 02 80 00 07 be 201aa2c <msdos_filename_unix2dos+0x120>
201aa14: 82 10 20 08 mov 8, %g1
201aa18: c2 08 c0 00 ldub [ %g3 ], %g1
201aa1c: 80 a0 60 00 cmp %g1, 0
201aa20: 32 bf ff f8 bne,a 201aa00 <msdos_filename_unix2dos+0xf4> <== ALWAYS TAKEN
201aa24: 86 00 e0 01 inc %g3
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
201aa28: 82 10 20 08 mov 8, %g1
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
if (msdos_map[c] == 0)
201aa2c: 10 80 00 08 b 201aa4c <msdos_filename_unix2dos+0x140>
201aa30: 1b 00 80 af sethi %hi(0x202bc00), %o5
201aa34: c8 0b 00 04 ldub [ %o4 + %g4 ], %g4
201aa38: 80 89 20 ff btst 0xff, %g4
201aa3c: 02 80 00 11 be 201aa80 <msdos_filename_unix2dos+0x174>
201aa40: 84 00 bf ff add %g2, -1, %g2
break;
dn[i] = msdos_map[c];
201aa44: c8 2a 80 01 stb %g4, [ %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++) {
201aa48: 82 00 60 01 inc %g1
201aa4c: 80 a0 a0 00 cmp %g2, 0
201aa50: 02 80 00 0c be 201aa80 <msdos_filename_unix2dos+0x174>
201aa54: 80 a0 60 0a cmp %g1, 0xa
201aa58: 04 80 00 03 ble 201aa64 <msdos_filename_unix2dos+0x158> <== ALWAYS TAKEN
201aa5c: 88 10 20 01 mov 1, %g4
201aa60: 88 10 20 00 clr %g4 <== NOT EXECUTED
201aa64: 80 89 20 ff btst 0xff, %g4
201aa68: 02 80 00 06 be 201aa80 <msdos_filename_unix2dos+0x174> <== NEVER TAKEN
201aa6c: 88 00 c0 01 add %g3, %g1, %g4
201aa70: c8 09 3f f8 ldub [ %g4 + -8 ], %g4
201aa74: 80 a1 20 00 cmp %g4, 0
201aa78: 12 bf ff ef bne 201aa34 <msdos_filename_unix2dos+0x128> <== ALWAYS TAKEN
201aa7c: 98 13 62 e8 or %o5, 0x2e8, %o4
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
201aa80: 81 c3 e0 08 retl
201aa84: 90 10 20 00 clr %o0
020191cc <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
20191cc: 9d e3 bf 60 save %sp, -160, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
20191d0: 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);
20191d4: b8 07 bf e0 add %fp, -32, %i4
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
20191d8: fa 00 60 08 ld [ %g1 + 8 ], %i5
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
20191dc: 92 10 20 00 clr %o1
20191e0: 94 10 20 20 mov 0x20, %o2
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
20191e4: 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);
20191e8: 40 00 0b ed call 201c19c <memset>
20191ec: 90 10 00 1c mov %i4, %o0
name_type = msdos_long_to_short (name,
20191f0: 92 10 00 1a mov %i2, %o1
20191f4: 94 10 00 1c mov %i4, %o2
20191f8: 96 10 20 0b mov 0xb, %o3
20191fc: 7f ff fa 9f call 2017c78 <msdos_long_to_short>
2019200: 90 10 00 19 mov %i1, %o0
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
2019204: b6 10 00 18 mov %i0, %i3
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
name_type = msdos_long_to_short (name,
2019208: 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,
201920c: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
2019210: 90 10 00 18 mov %i0, %o0
2019214: 92 10 20 00 clr %o1
2019218: 94 10 00 19 mov %i1, %o2
201921c: 96 10 00 1a mov %i2, %o3
2019220: 7f ff ff ab call 20190cc <msdos_get_name_node>
2019224: 9a 07 bf d0 add %fp, -48, %o5
&dir_pos, node_entry);
if (rc != RC_OK)
2019228: b0 92 20 00 orcc %o0, 0, %i0
201922c: 12 80 00 68 bne 20193cc <msdos_find_name+0x200>
2019230: 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;
2019234: 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) ||
2019238: 84 08 60 08 and %g1, 8, %g2
201923c: 80 88 a0 ff btst 0xff, %g2
2019240: 12 80 00 63 bne 20193cc <msdos_find_name+0x200> <== NEVER TAKEN
2019244: b0 16 21 01 or %i0, 0x101, %i0
2019248: 82 08 60 3f and %g1, 0x3f, %g1
201924c: 80 a0 60 0f cmp %g1, 0xf
2019250: 02 80 00 5f be 20193cc <msdos_find_name+0x200> <== NEVER TAKEN
2019254: 90 10 00 1d mov %i5, %o0
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
/* open fat-file corresponded to the found node */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
2019258: 92 07 bf d0 add %fp, -48, %o1
201925c: 7f ff e3 cb call 2012188 <fat_file_open>
2019260: 94 07 bf cc add %fp, -52, %o2
if (rc != RC_OK)
2019264: b0 92 20 00 orcc %o0, 0, %i0
2019268: 12 80 00 59 bne 20193cc <msdos_find_name+0x200> <== NEVER TAKEN
201926c: f8 07 bf cc ld [ %fp + -52 ], %i4
return rc;
fat_fd->dir_pos = dir_pos;
2019270: 92 07 bf d0 add %fp, -48, %o1
2019274: 90 07 20 20 add %i4, 0x20, %o0
2019278: 40 00 0b 8c call 201c0a8 <memcpy>
201927c: 94 10 20 10 mov 0x10, %o2
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
2019280: c2 07 20 08 ld [ %i4 + 8 ], %g1
2019284: 80 a0 60 01 cmp %g1, 1
2019288: 32 80 00 49 bne,a 20193ac <msdos_find_name+0x1e0>
201928c: d2 06 e0 08 ld [ %i3 + 8 ], %o1
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
2019290: c2 17 bf f4 lduh [ %fp + -12 ], %g1
2019294: 83 28 60 10 sll %g1, 0x10, %g1
2019298: 85 30 60 18 srl %g1, 0x18, %g2
201929c: 87 30 60 08 srl %g1, 8, %g3
20192a0: 03 00 00 3f sethi %hi(0xfc00), %g1
20192a4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
20192a8: 86 08 c0 01 and %g3, %g1, %g3
20192ac: 86 10 80 03 or %g2, %g3, %g3
20192b0: c4 17 bf fa lduh [ %fp + -6 ], %g2
20192b4: 87 28 e0 10 sll %g3, 0x10, %g3
20192b8: 85 28 a0 10 sll %g2, 0x10, %g2
20192bc: 89 30 a0 18 srl %g2, 0x18, %g4
20192c0: 85 30 a0 08 srl %g2, 8, %g2
20192c4: 84 08 80 01 and %g2, %g1, %g2
20192c8: 84 11 00 02 or %g4, %g2, %g2
20192cc: 84 10 c0 02 or %g3, %g2, %g2
20192d0: c4 27 20 1c st %g2, [ %i4 + 0x1c ]
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
20192d4: c4 17 bf f8 lduh [ %fp + -8 ], %g2
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
20192d8: 85 28 a0 10 sll %g2, 0x10, %g2
20192dc: 91 30 a0 18 srl %g2, 0x18, %o0
20192e0: 85 30 a0 08 srl %g2, 8, %g2
20192e4: 86 08 80 01 and %g2, %g1, %g3
20192e8: c4 17 bf f6 lduh [ %fp + -10 ], %g2
20192ec: 90 12 00 03 or %o0, %g3, %o0
20192f0: 85 28 a0 10 sll %g2, 0x10, %g2
20192f4: 93 30 a0 18 srl %g2, 0x18, %o1
20192f8: 85 30 a0 08 srl %g2, 8, %g2
20192fc: 82 08 80 01 and %g2, %g1, %g1
2019300: 40 00 05 3b call 201a7ec <msdos_date_dos2unix>
2019304: 92 12 40 01 or %o1, %g1, %o1
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
2019308: c2 0f bf eb ldub [ %fp + -21 ], %g1
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
201930c: d0 27 20 40 st %o0, [ %i4 + 0x40 ]
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
2019310: 82 08 60 10 and %g1, 0x10, %g1
2019314: 80 88 60 ff btst 0xff, %g1
2019318: 02 80 00 0e be 2019350 <msdos_find_name+0x184>
201931c: f8 07 bf cc ld [ %fp + -52 ], %i4
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2019320: 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;
2019324: c0 27 20 10 clr [ %i4 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2019328: c2 27 20 14 st %g1, [ %i4 + 0x14 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
201932c: 90 10 00 1d mov %i5, %o0
2019330: 7f ff e6 43 call 2012c3c <fat_file_size>
2019334: 92 10 00 1c mov %i4, %o1
if (rc != RC_OK)
2019338: b0 92 20 00 orcc %o0, 0, %i0
201933c: 02 80 00 0d be 2019370 <msdos_find_name+0x1a4> <== ALWAYS TAKEN
2019340: c2 07 bf cc ld [ %fp + -52 ], %g1
{
fat_file_close(&fs_info->fat, fat_fd);
2019344: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2019348: 10 80 00 1f b 20193c4 <msdos_find_name+0x1f8> <== NOT EXECUTED
201934c: d2 07 bf cc ld [ %fp + -52 ], %o1 <== NOT EXECUTED
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
2019350: 7f ff fa 30 call 2017c10 <CPU_swap_u32>
2019354: d0 07 bf fc ld [ %fp + -4 ], %o0
fat_fd->fat_file_type = FAT_FILE;
2019358: 82 10 20 04 mov 4, %g1
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
201935c: d0 27 20 18 st %o0, [ %i4 + 0x18 ]
fat_fd->fat_file_type = FAT_FILE;
2019360: c2 27 20 10 st %g1, [ %i4 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
2019364: 82 10 3f ff mov -1, %g1
2019368: c2 27 20 14 st %g1, [ %i4 + 0x14 ]
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
201936c: c2 07 bf cc ld [ %fp + -52 ], %g1
fat_fd->map.disk_cln = fat_fd->cln;
2019370: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
if ((fat_fd->fat_file_size != 0) &&
2019374: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
fat_fd->fat_file_type = FAT_FILE;
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
2019378: c0 20 60 34 clr [ %g1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
201937c: 80 a0 e0 00 cmp %g3, 0
2019380: 02 80 00 08 be 20193a0 <msdos_find_name+0x1d4>
2019384: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
2019388: c8 17 60 06 lduh [ %i5 + 6 ], %g4
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
201938c: 80 a0 c0 04 cmp %g3, %g4
2019390: 38 80 00 05 bgu,a 20193a4 <msdos_find_name+0x1d8>
2019394: 84 10 3f ff mov -1, %g2
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
2019398: 10 80 00 04 b 20193a8 <msdos_find_name+0x1dc>
201939c: c4 20 60 3c st %g2, [ %g1 + 0x3c ]
20193a0: 84 10 3f ff mov -1, %g2
20193a4: c4 20 60 3c st %g2, [ %g1 + 0x3c ]
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
20193a8: d2 06 e0 08 ld [ %i3 + 8 ], %o1
20193ac: 7f ff e4 8d call 20125e0 <fat_file_close>
20193b0: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
20193b4: b0 92 20 00 orcc %o0, 0, %i0
20193b8: 02 80 00 07 be 20193d4 <msdos_find_name+0x208> <== ALWAYS TAKEN
20193bc: d2 07 bf cc ld [ %fp + -52 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
20193c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20193c4: 7f ff e4 87 call 20125e0 <fat_file_close> <== NOT EXECUTED
20193c8: 01 00 00 00 nop <== NOT EXECUTED
20193cc: 81 c7 e0 08 ret
20193d0: 81 e8 00 00 restore
return rc;
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
20193d4: d2 26 e0 08 st %o1, [ %i3 + 8 ]
return rc;
}
20193d8: 81 c7 e0 08 ret
20193dc: 81 e8 00 00 restore
02018320 <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
)
{
2018320: 9d e3 bf 60 save %sp, -160, %sp
2018324: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2018328: 84 10 00 1a mov %i2, %g2
201832c: e4 07 a0 5c ld [ %fp + 0x5c ], %l2
2018330: e8 07 a0 60 ld [ %fp + 0x60 ], %l4
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
2018334: 80 a7 20 00 cmp %i4, 0
2018338: 14 80 00 0a bg 2018360 <msdos_find_name_in_fat_file+0x40> <== ALWAYS TAKEN
201833c: e0 06 20 08 ld [ %i0 + 8 ], %l0
2018340: 11 00 80 af sethi %hi(0x202bc00), %o0 <== NOT EXECUTED
2018344: 15 00 80 af sethi %hi(0x202bc00), %o2 <== NOT EXECUTED
2018348: 17 00 80 af sethi %hi(0x202bc00), %o3 <== NOT EXECUTED
201834c: 90 12 20 28 or %o0, 0x28, %o0 <== NOT EXECUTED
2018350: 92 10 23 c9 mov 0x3c9, %o1 <== NOT EXECUTED
2018354: 94 12 a0 f8 or %o2, 0xf8, %o2 <== NOT EXECUTED
2018358: 10 80 00 3e b 2018450 <msdos_find_name_in_fat_file+0x130> <== NOT EXECUTED
201835c: 96 12 e0 b8 or %o3, 0xb8, %o3 <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2018360: 82 10 3f ff mov -1, %g1
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
2018364: c0 24 80 00 clr [ %l2 ]
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2018368: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
201836c: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
2018370: c2 27 bf fc st %g1, [ %fp + -4 ]
2018374: c2 27 bf f8 st %g1, [ %fp + -8 ]
* is short still check for possible long entries with the short name.
*
* In PR1491 we need to have a LFN for a short file name entry. To
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
2018378: 82 1f 60 01 xor %i5, 1, %g1
201837c: 80 a0 00 01 cmp %g0, %g1
2018380: b4 60 3f ff subx %g0, -1, %i2
2018384: 80 8e a0 ff btst 0xff, %i2
2018388: 02 80 00 05 be 201839c <msdos_find_name_in_fat_file+0x7c>
201838c: c0 24 a0 04 clr [ %l2 + 4 ]
2018390: 80 a0 a0 00 cmp %g2, 0
2018394: 12 80 00 08 bne 20183b4 <msdos_find_name_in_fat_file+0x94>
2018398: a6 10 20 00 clr %l3
lfn_entries = 0;
else
lfn_entries =
201839c: c4 27 bf d0 st %g2, [ %fp + -48 ]
20183a0: 90 07 20 0c add %i4, 0xc, %o0
20183a4: 7f ff a8 e7 call 2002740 <.div>
20183a8: 92 10 20 0d mov 0xd, %o1
20183ac: c4 07 bf d0 ld [ %fp + -48 ], %g2
20183b0: a6 10 00 08 mov %o0, %l3
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
20183b4: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20183b8: 80 a0 60 01 cmp %g1, 1
20183bc: 32 80 00 0b bne,a 20183e8 <msdos_find_name_in_fat_file+0xc8>
20183c0: e2 14 20 06 lduh [ %l0 + 6 ], %l1
20183c4: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
20183c8: 80 a0 60 00 cmp %g1, 0
20183cc: 32 80 00 07 bne,a 20183e8 <msdos_find_name_in_fat_file+0xc8><== NEVER TAKEN
20183d0: e2 14 20 06 lduh [ %l0 + 6 ], %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
20183d4: c2 0c 20 0e ldub [ %l0 + 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) &&
20183d8: 80 88 60 03 btst 3, %g1
20183dc: 22 80 00 03 be,a 20183e8 <msdos_find_name_in_fat_file+0xc8>
20183e0: e2 14 20 06 lduh [ %l0 + 6 ], %l1
20183e4: e2 06 60 18 ld [ %i1 + 0x18 ], %l1
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
20183e8: b4 0e a0 ff and %i2, 0xff, %i2
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
20183ec: 82 04 e0 01 add %l3, 1, %g1
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
20183f0: 88 10 20 00 clr %g4
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
20183f4: c0 2f bf e7 clrb [ %fp + -25 ]
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
20183f8: b0 10 20 00 clr %i0
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
20183fc: ae 10 20 00 clr %l7
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
2018400: ac 10 20 00 clr %l6
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
2018404: 86 10 20 00 clr %g3
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
2018408: c0 2f bf ef clrb [ %fp + -17 ]
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
201840c: 9a 10 20 00 clr %o5
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
2018410: b6 10 20 00 clr %i3
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
2018414: f4 27 bf dc st %i2, [ %fp + -36 ]
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
2018418: 10 80 00 eb b 20187c4 <msdos_find_name_in_fat_file+0x4a4>
201841c: c2 27 bf d8 st %g1, [ %fp + -40 ]
bool remainder_empty = false;
#if MSDOS_FIND_PRINT
printf ("MSFS:[2] dir_offset:%li\n", dir_offset);
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2018420: 80 a2 20 1f cmp %o0, 0x1f
2018424: 04 80 02 02 ble 2018c2c <msdos_find_name_in_fat_file+0x90c><== NEVER TAKEN
2018428: 80 a2 00 11 cmp %o0, %l1
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
201842c: 22 80 00 0b be,a 2018458 <msdos_find_name_in_fat_file+0x138><== ALWAYS TAKEN
2018430: ea 04 20 a0 ld [ %l0 + 0xa0 ], %l5
2018434: 11 00 80 af sethi %hi(0x202bc00), %o0 <== NOT EXECUTED
2018438: 15 00 80 af sethi %hi(0x202bc00), %o2 <== NOT EXECUTED
201843c: 17 00 80 af sethi %hi(0x202bc00), %o3 <== NOT EXECUTED
2018440: 90 12 20 28 or %o0, 0x28, %o0 <== NOT EXECUTED
2018444: 92 10 23 f9 mov 0x3f9, %o1 <== NOT EXECUTED
2018448: 94 12 a0 f8 or %o2, 0xf8, %o2 <== NOT EXECUTED
201844c: 96 12 e0 c8 or %o3, 0xc8, %o3 <== NOT EXECUTED
2018450: 7f ff f0 b3 call 201471c <__assert_func> <== NOT EXECUTED
2018454: 01 00 00 00 nop <== NOT EXECUTED
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
2018458: b4 10 20 00 clr %i2 ! 0 <PROM_START>
* to here and write the long file name if this is the start of
* a series of empty entries. If empty_space_count is 0 then
* we are currently not inside an empty series of entries. It
* is a count of empty entries.
*/
if (empty_space_count == 0)
201845c: 80 a6 20 00 cmp %i0, 0
2018460: 12 80 00 04 bne 2018470 <msdos_find_name_in_fat_file+0x150>
2018464: de 0d 40 00 ldub [ %l5 ], %o7
2018468: ae 10 00 1a mov %i2, %l7
201846c: ac 10 00 1b mov %i3, %l6
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
2018470: 98 8b e0 ff andcc %o7, 0xff, %o4
2018474: 12 80 00 11 bne 20184b8 <msdos_find_name_in_fat_file+0x198>
2018478: 80 a3 20 e5 cmp %o4, 0xe5
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
201847c: 80 a0 a0 00 cmp %g2, 0
2018480: 12 80 00 06 bne 2018498 <msdos_find_name_in_fat_file+0x178>
2018484: c4 0f bf e7 ldub [ %fp + -25 ], %g2
return MSDOS_NAME_NOT_FOUND_ERR;
2018488: 31 00 00 1f sethi %hi(0x7c00), %i0
201848c: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01>
2018490: 81 c7 e0 08 ret
2018494: 81 e8 00 00 restore
* Lets go and write the directory entries. If we have not found
* any available space add the remaining number of entries to any that
* we may have already found that are just before this entry. If more
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
2018498: 80 88 a0 ff btst 0xff, %g2
201849c: 12 80 00 dc bne 201880c <msdos_find_name_in_fat_file+0x4ec>
20184a0: 80 a7 60 02 cmp %i5, 2
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
20184a4: 85 34 60 05 srl %l1, 5, %g2
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
{
empty_space_count +=
entries_per_block - (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
20184a8: b5 36 a0 05 srl %i2, 5, %i2
20184ac: b0 06 00 02 add %i0, %g2, %i0
* we may have already found that are just before this entry. If more
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
{
empty_space_count +=
20184b0: 10 80 00 d7 b 201880c <msdos_find_name_in_fat_file+0x4ec>
20184b4: b0 26 00 1a sub %i0, %i2, %i0
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
20184b8: 12 80 00 0c bne 20184e8 <msdos_find_name_in_fat_file+0x1c8>
20184bc: c2 0f bf e7 ldub [ %fp + -25 ], %g1
{
if (create_node)
20184c0: 80 a0 a0 00 cmp %g2, 0
20184c4: 22 80 00 bb be,a 20187b0 <msdos_find_name_in_fat_file+0x490>
20184c8: b4 06 a0 20 add %i2, 0x20, %i2
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
20184cc: c2 07 bf d8 ld [ %fp + -40 ], %g1
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
20184d0: b0 06 20 01 inc %i0
if (empty_space_count == (lfn_entries + 1))
20184d4: 80 a6 00 01 cmp %i0, %g1
20184d8: 32 80 00 b6 bne,a 20187b0 <msdos_find_name_in_fat_file+0x490>
20184dc: b4 06 a0 20 add %i2, 0x20, %i2
empty_space_found = true;
20184e0: 10 80 00 b2 b 20187a8 <msdos_find_name_in_fat_file+0x488>
20184e4: 82 10 20 01 mov 1, %g1
* A valid entry so handle it.
*
* If empty space has not been found we need to start the
* count again.
*/
if (create_node && !empty_space_found)
20184e8: 98 18 60 01 xor %g1, 1, %o4
20184ec: 80 8b 20 ff btst 0xff, %o4
20184f0: 02 80 00 07 be 201850c <msdos_find_name_in_fat_file+0x1ec><== NEVER TAKEN
20184f4: d8 0d 60 0b ldub [ %l5 + 0xb ], %o4
20184f8: 80 a0 a0 00 cmp %g2, 0
20184fc: 02 80 00 04 be 201850c <msdos_find_name_in_fat_file+0x1ec>
2018500: 01 00 00 00 nop
{
empty_space_entry = 0;
empty_space_count = 0;
2018504: b0 10 20 00 clr %i0 ! 0 <PROM_START>
* If empty space has not been found we need to start the
* count again.
*/
if (create_node && !empty_space_found)
{
empty_space_entry = 0;
2018508: ae 10 20 00 clr %l7
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
201850c: 98 0b 20 3f and %o4, 0x3f, %o4
2018510: 80 a3 20 0f cmp %o4, 0xf
2018514: 12 80 00 54 bne 2018664 <msdos_find_name_in_fat_file+0x344>
2018518: 80 8b 60 ff btst 0xff, %o5
#endif
/*
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
201851c: d8 07 bf f8 ld [ %fp + -8 ], %o4
2018520: 80 a3 3f ff cmp %o4, -1
2018524: 32 80 00 10 bne,a 2018564 <msdos_find_name_in_fat_file+0x244>
2018528: de 0d 40 00 ldub [ %l5 ], %o7
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
201852c: 98 0b e0 40 and %o7, 0x40, %o4
2018530: 80 8b 20 ff btst 0xff, %o4
2018534: 02 80 00 9e be 20187ac <msdos_find_name_in_fat_file+0x48c>
2018538: 9a 10 20 00 clr %o5
* entry match the number we expect for this
* file name. Note we do not know the number of
* characters in the entry so this is check further
* on when the characters are checked.
*/
if (lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
201853c: 9e 0b e0 3f and %o7, 0x3f, %o7
2018540: 80 a4 c0 0f cmp %l3, %o7
2018544: 32 80 00 9b bne,a 20187b0 <msdos_find_name_in_fat_file+0x490>
2018548: b4 06 a0 20 add %i2, 0x20, %i2
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
201854c: f6 27 bf f8 st %i3, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
2018550: f4 27 bf fc st %i2, [ %fp + -4 ]
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
2018554: c6 0d 60 0d ldub [ %l5 + 0xd ], %g3
2018558: c6 2f bf ef stb %g3, [ %fp + -17 ]
201855c: 86 10 00 13 mov %l3, %g3
* If the entry number or the check sum do not match
* forget this series of long directory entries. These
* could be orphaned entries depending on the history
* of the disk.
*/
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
2018560: de 0d 40 00 ldub [ %l5 ], %o7
2018564: 9e 0b e0 3f and %o7, 0x3f, %o7
2018568: 80 a0 c0 0f cmp %g3, %o7
201856c: 12 80 00 07 bne 2018588 <msdos_find_name_in_fat_file+0x268><== NEVER TAKEN
2018570: 82 10 3f ff mov -1, %g1
MSDOS_LAST_LONG_ENTRY_MASK)) ||
2018574: d8 0f bf ef ldub [ %fp + -17 ], %o4
2018578: de 0d 60 0d ldub [ %l5 + 0xd ], %o7
201857c: 80 a3 00 0f cmp %o4, %o7
2018580: 02 80 00 04 be 2018590 <msdos_find_name_in_fat_file+0x270><== ALWAYS TAKEN
2018584: 98 00 ff ff add %g3, -1, %o4
{
#if MSDOS_FIND_PRINT
printf ("MSFS:[4.4] no match\n");
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
2018588: 10 80 00 89 b 20187ac <msdos_find_name_in_fat_file+0x48c> <== NOT EXECUTED
201858c: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
2018590: 9f 2b 20 02 sll %o4, 2, %o7
2018594: 97 2b 20 04 sll %o4, 4, %o3
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
2018598: 9a 05 60 01 add %l5, 1, %o5
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
201859c: 96 22 c0 0f sub %o3, %o7, %o3
p = entry + 1;
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
20185a0: 9e 10 20 00 clr %o7
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
20185a4: 96 02 c0 0c add %o3, %o4, %o3
{
#if MSDOS_FIND_PRINT > 1
printf ("MSFS:[6] o:%i i:%i *p:%c(%02x) name[o + i]:%c(%02x)\n",
o, i, *p, *p, name[o + i], name[o + i]);
#endif
if (*p == '\0')
20185a8: d4 4b 40 00 ldsb [ %o5 ], %o2
20185ac: 80 a2 a0 00 cmp %o2, 0
20185b0: 12 80 00 0b bne 20185dc <msdos_find_name_in_fat_file+0x2bc>
20185b4: 92 03 c0 0b add %o7, %o3, %o1
/*
* If this is the first entry, ie the last part of the
* long file name and the length does not match then
* the file names do not match.
*/
if (((lfn_entry + 1) == lfn_entries) &&
20185b8: 80 a0 c0 13 cmp %g3, %l3
20185bc: 12 80 00 22 bne 2018644 <msdos_find_name_in_fat_file+0x324><== NEVER TAKEN
20185c0: 80 a3 20 00 cmp %o4, 0
((o + i) != name_len))
20185c4: 9e 02 c0 0f add %o3, %o7, %o7
/*
* If this is the first entry, ie the last part of the
* long file name and the length does not match then
* the file names do not match.
*/
if (((lfn_entry + 1) == lfn_entries) &&
20185c8: 80 a3 c0 1c cmp %o7, %i4
20185cc: 02 80 00 1e be 2018644 <msdos_find_name_in_fat_file+0x324><== ALWAYS TAKEN
20185d0: 80 a3 20 00 cmp %o4, 0
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
20185d4: 10 80 00 0b b 2018600 <msdos_find_name_in_fat_file+0x2e0> <== NOT EXECUTED
20185d8: 86 10 3f ff mov -1, %g3 <== NOT EXECUTED
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
20185dc: 80 a2 40 1c cmp %o1, %i4
20185e0: 16 80 00 07 bge 20185fc <msdos_find_name_in_fat_file+0x2dc>
20185e4: c2 07 a0 50 ld [ %fp + 0x50 ], %g1
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
20185e8: 92 00 40 0b add %g1, %o3, %o1
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
20185ec: d2 4a 40 0f ldsb [ %o1 + %o7 ], %o1
20185f0: 80 a2 80 09 cmp %o2, %o1
20185f4: 02 80 00 05 be 2018608 <msdos_find_name_in_fat_file+0x2e8>
20185f8: 80 a3 e0 04 cmp %o7, 4
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
20185fc: 86 10 3f ff mov -1, %g3
break;
2018600: 10 80 00 10 b 2018640 <msdos_find_name_in_fat_file+0x320>
2018604: c6 27 bf f8 st %g3, [ %fp + -8 ]
}
switch (i)
2018608: 02 80 00 06 be 2018620 <msdos_find_name_in_fat_file+0x300>
201860c: 80 a3 e0 0a cmp %o7, 0xa
2018610: 32 80 00 08 bne,a 2018630 <msdos_find_name_in_fat_file+0x310>
2018614: 9a 03 60 02 add %o5, 2, %o5
{
case 4:
p += 5;
break;
case 10:
p += 4;
2018618: 10 80 00 04 b 2018628 <msdos_find_name_in_fat_file+0x308>
201861c: 9a 03 60 04 add %o5, 4, %o5
switch (i)
{
case 4:
p += 5;
break;
2018620: 10 80 00 04 b 2018630 <msdos_find_name_in_fat_file+0x310>
2018624: 9a 03 60 05 add %o5, 5, %o5
case 10:
p += 4;
break;
2018628: 10 80 00 03 b 2018634 <msdos_find_name_in_fat_file+0x314>
201862c: 9e 03 e0 01 inc %o7
p = entry + 1;
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
2018630: 9e 03 e0 01 inc %o7
2018634: 80 a3 e0 0d cmp %o7, 0xd
2018638: 32 bf ff dd bne,a 20185ac <msdos_find_name_in_fat_file+0x28c>
201863c: d4 4b 40 00 ldsb [ %o5 ], %o2
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
2018640: 80 a3 20 00 cmp %o4, 0
2018644: 12 80 00 06 bne 201865c <msdos_find_name_in_fat_file+0x33c>
2018648: 9a 10 20 00 clr %o5
201864c: c6 07 bf f8 ld [ %fp + -8 ], %g3
2018650: 86 38 00 03 xnor %g0, %g3, %g3
2018654: 80 a0 00 03 cmp %g0, %g3
2018658: 9a 40 20 00 addx %g0, 0, %o5
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
201865c: 10 80 00 54 b 20187ac <msdos_find_name_in_fat_file+0x48c>
2018660: 86 10 00 0c mov %o4, %g3
* If a LFN has been found and it matched check the
* entries have all been found and the checksum is
* correct. If this is the case return the short file
* name entry.
*/
if (lfn_matched)
2018664: 02 80 01 85 be 2018c78 <msdos_find_name_in_fat_file+0x958>
2018668: c2 07 bf dc ld [ %fp + -36 ], %g1
201866c: 9a 10 20 00 clr %o5
2018670: 9e 10 20 00 clr %o7
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
2018674: d6 0d 40 0d ldub [ %l5 + %o5 ], %o3
2018678: 98 0b e0 01 and %o7, 1, %o4
201867c: 80 a0 00 0c cmp %g0, %o4
2018680: 9e 0b e0 ff and %o7, 0xff, %o7
2018684: 98 40 3f ff addx %g0, -1, %o4
2018688: 9f 33 e0 01 srl %o7, 1, %o7
201868c: 98 0b 20 80 and %o4, 0x80, %o4
2018690: 9e 02 c0 0f add %o3, %o7, %o7
2018694: 98 03 3f 80 add %o4, -128, %o4
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
2018698: 9a 03 60 01 inc %o5
201869c: 80 a3 60 0b cmp %o5, 0xb
20186a0: 12 bf ff f5 bne 2018674 <msdos_find_name_in_fat_file+0x354>
20186a4: 9e 03 c0 0c add %o7, %o4, %o7
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
20186a8: c2 0f bf ef ldub [ %fp + -17 ], %g1
20186ac: 9e 1b c0 01 xor %o7, %g1, %o7
20186b0: 80 8b e0 ff btst 0xff, %o7
20186b4: 12 80 01 71 bne 2018c78 <msdos_find_name_in_fat_file+0x958><== NEVER TAKEN
20186b8: c2 07 bf dc ld [ %fp + -36 ], %g1
20186bc: 80 a0 e0 00 cmp %g3, 0
20186c0: 12 80 01 6f bne 2018c7c <msdos_find_name_in_fat_file+0x95c><== NEVER TAKEN
20186c4: 80 a0 60 00 cmp %g1, 0
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
20186c8: 90 10 00 10 mov %l0, %o0
20186cc: 92 10 00 19 mov %i1, %o1
20186d0: 94 10 20 01 mov 1, %o2
20186d4: 96 10 00 04 mov %g4, %o3
20186d8: 7f ff e7 ef call 2012694 <fat_file_ioctl>
20186dc: 98 10 00 12 mov %l2, %o4
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
20186e0: b0 92 20 00 orcc %o0, 0, %i0
20186e4: 02 80 00 13 be 2018730 <msdos_find_name_in_fat_file+0x410><== ALWAYS TAKEN
20186e8: d2 07 bf f8 ld [ %fp + -8 ], %o1
20186ec: 81 c7 e0 08 ret <== NOT EXECUTED
20186f0: 81 e8 00 00 restore <== NOT EXECUTED
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
((name_type == MSDOS_NAME_SHORT) &&
20186f4: 80 a3 ff ff cmp %o7, -1
20186f8: 12 80 00 29 bne 201879c <msdos_find_name_in_fat_file+0x47c><== NEVER TAKEN
20186fc: 82 10 3f ff mov -1, %g1
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
2018700: c4 3f bf d0 std %g2, [ %fp + -48 ]
2018704: c8 27 bf cc st %g4, [ %fp + -52 ]
2018708: 90 10 00 15 mov %l5, %o0
201870c: 92 10 00 14 mov %l4, %o1
2018710: 40 00 0e 3c call 201c000 <memcmp>
2018714: 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) &&
2018718: c4 1f bf d0 ldd [ %fp + -48 ], %g2
201871c: 80 a2 20 00 cmp %o0, 0
2018720: 12 80 00 1e bne 2018798 <msdos_find_name_in_fat_file+0x478>
2018724: c8 07 bf cc ld [ %fp + -52 ], %g4
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
2018728: 10 bf ff e9 b 20186cc <msdos_find_name_in_fat_file+0x3ac>
201872c: 90 10 00 10 mov %l0, %o0
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
2018730: 80 a2 7f ff cmp %o1, -1
2018734: 12 80 00 0c bne 2018764 <msdos_find_name_in_fat_file+0x444>
2018738: f4 24 a0 04 st %i2, [ %l2 + 4 ]
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
201873c: c2 07 bf f8 ld [ %fp + -8 ], %g1
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
2018740: 90 10 00 14 mov %l4, %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
2018744: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
2018748: c2 07 bf fc ld [ %fp + -4 ], %g1
memcpy(name_dir_entry, entry,
201874c: 92 10 00 15 mov %l5, %o1
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
2018750: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
memcpy(name_dir_entry, entry,
2018754: 40 00 0e 55 call 201c0a8 <memcpy>
2018758: 94 10 20 20 mov 0x20, %o2
201875c: 81 c7 e0 08 ret
2018760: 81 e8 00 00 restore
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
2018764: 7f ff a7 bb call 2002650 <.umul>
2018768: 90 10 00 11 mov %l1, %o0
201876c: 92 10 00 19 mov %i1, %o1
2018770: 96 10 00 08 mov %o0, %o3
2018774: 94 10 20 01 mov 1, %o2
2018778: 90 10 00 10 mov %l0, %o0
201877c: 7f ff e7 c6 call 2012694 <fat_file_ioctl>
2018780: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
2018784: 80 a2 20 00 cmp %o0, 0
2018788: 12 80 01 37 bne 2018c64 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
201878c: c2 07 bf f8 ld [ %fp + -8 ], %g1
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
2018790: 10 bf ff ed b 2018744 <msdos_find_name_in_fat_file+0x424>
2018794: 90 10 00 14 mov %l4, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
2018798: 82 10 3f ff mov -1, %g1
lfn_matched = false;
201879c: 9a 10 20 00 clr %o5
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
20187a0: 10 80 00 03 b 20187ac <msdos_find_name_in_fat_file+0x48c>
20187a4: c2 27 bf f8 st %g1, [ %fp + -8 ]
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
empty_space_found = true;
20187a8: c2 2f bf e7 stb %g1, [ %fp + -25 ]
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
20187ac: b4 06 a0 20 add %i2, 0x20, %i2
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
20187b0: 80 a6 80 11 cmp %i2, %l1
20187b4: 0a bf ff 2a bcs 201845c <msdos_find_name_in_fat_file+0x13c>
20187b8: aa 05 60 20 add %l5, 0x20, %l5
}
if (remainder_empty)
break;
dir_offset++;
20187bc: b6 06 e0 01 inc %i3
20187c0: 88 01 00 11 add %g4, %l1, %g4
/*
* 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),
20187c4: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
20187c8: 94 10 00 04 mov %g4, %o2
20187cc: c4 3f bf d0 std %g2, [ %fp + -48 ]
20187d0: c8 27 bf cc st %g4, [ %fp + -52 ]
20187d4: da 27 bf c4 st %o5, [ %fp + -60 ]
20187d8: 90 10 00 10 mov %l0, %o0
20187dc: 92 10 00 19 mov %i1, %o1
20187e0: 7f ff e6 cd call 2012314 <fat_file_read>
20187e4: 96 10 00 11 mov %l1, %o3
20187e8: c4 1f bf d0 ldd [ %fp + -48 ], %g2
20187ec: 80 a2 20 00 cmp %o0, 0
20187f0: c8 07 bf cc ld [ %fp + -52 ], %g4
20187f4: 12 bf ff 0b bne 2018420 <msdos_find_name_in_fat_file+0x100>
20187f8: da 07 bf c4 ld [ %fp + -60 ], %o5
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
20187fc: 80 a0 a0 00 cmp %g2, 0
2018800: 22 bf ff 23 be,a 201848c <msdos_find_name_in_fat_file+0x16c>
2018804: 31 00 00 1f sethi %hi(0x7c00), %i0
* 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)
2018808: 80 a7 60 02 cmp %i5, 2
201880c: 12 80 00 2e bne 20188c4 <msdos_find_name_in_fat_file+0x5a4>
2018810: 80 a4 e0 00 cmp %l3, 0
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
2018814: 90 10 00 16 mov %l6, %o0
2018818: 7f ff a7 8e call 2002650 <.umul>
201881c: 92 10 00 11 mov %l1, %o1
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
2018820: c4 4d 00 00 ldsb [ %l4 ], %g2
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
2018824: ba 04 e0 01 add %l3, 1, %i5
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
2018828: 90 02 00 17 add %o0, %l7, %o0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
201882c: 80 a0 a0 2e cmp %g2, 0x2e
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
2018830: 91 32 20 05 srl %o0, 5, %o0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
2018834: 02 80 00 05 be 2018848 <msdos_find_name_in_fat_file+0x528><== NEVER TAKEN
2018838: ba 07 40 08 add %i5, %o0, %i5
201883c: 80 a0 a0 20 cmp %g2, 0x20
2018840: 32 80 00 05 bne,a 2018854 <msdos_find_name_in_fat_file+0x534>
2018844: c4 4d 20 01 ldsb [ %l4 + 1 ], %g2
*c = '_';
2018848: 84 10 20 5f mov 0x5f, %g2
201884c: c4 2d 00 00 stb %g2, [ %l4 ]
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
2018850: c4 4d 20 01 ldsb [ %l4 + 1 ], %g2
2018854: 80 a0 a0 2e cmp %g2, 0x2e
2018858: 22 80 00 06 be,a 2018870 <msdos_find_name_in_fat_file+0x550><== NEVER TAKEN
201885c: 84 10 20 5f mov 0x5f, %g2 <== NOT EXECUTED
2018860: 80 a0 a0 20 cmp %g2, 0x20
2018864: 12 80 00 05 bne 2018878 <msdos_find_name_in_fat_file+0x558>
2018868: 86 05 20 02 add %l4, 2, %g3
*c = '_';
201886c: 84 10 20 5f mov 0x5f, %g2
2018870: c4 2d 20 01 stb %g2, [ %l4 + 1 ]
msdos_short_name_hex(char* sfn, int num)
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
2018874: 86 05 20 02 add %l4, 2, %g3
2018878: 84 10 20 00 clr %g2
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
201887c: 35 00 80 ac sethi %hi(0x202b000), %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(
2018880: 88 20 00 02 neg %g2, %g4
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
2018884: b8 16 a3 b0 or %i2, 0x3b0, %i4
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
2018888: 89 29 20 02 sll %g4, 2, %g4
201888c: 88 01 20 0c add %g4, 0xc, %g4
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
2018890: 89 3f 40 04 sra %i5, %g4, %g4
2018894: 88 09 20 0f and %g4, 0xf, %g4
2018898: c8 0f 00 04 ldub [ %i4 + %g4 ], %g4
201889c: c8 28 c0 02 stb %g4, [ %g3 + %g2 ]
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
20188a0: 84 00 a0 01 inc %g2
20188a4: 80 a0 a0 04 cmp %g2, 4
20188a8: 12 bf ff f8 bne 2018888 <msdos_find_name_in_fat_file+0x568>
20188ac: 88 20 00 02 neg %g2, %g4
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
20188b0: 84 10 20 7e mov 0x7e, %g2
20188b4: c4 2d 20 06 stb %g2, [ %l4 + 6 ]
*c++ = '1';
20188b8: 84 10 20 31 mov 0x31, %g2
20188bc: c4 2d 20 07 stb %g2, [ %l4 + 7 ]
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
msdos_short_name_hex(MSDOS_DIR_NAME(name_dir_entry), slot);
}
if (lfn_entries)
20188c0: 80 a4 e0 00 cmp %l3, 0
20188c4: 02 80 00 10 be 2018904 <msdos_find_name_in_fat_file+0x5e4>
20188c8: b8 10 20 00 clr %i4
20188cc: 84 10 20 00 clr %g2
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
20188d0: c8 0d 00 02 ldub [ %l4 + %g2 ], %g4
20188d4: 86 0f 20 01 and %i4, 1, %g3
20188d8: 80 a0 00 03 cmp %g0, %g3
20188dc: b8 0f 20 ff and %i4, 0xff, %i4
20188e0: 86 40 3f ff addx %g0, -1, %g3
20188e4: b9 37 20 01 srl %i4, 1, %i4
20188e8: 86 08 e0 80 and %g3, 0x80, %g3
20188ec: b8 01 00 1c add %g4, %i4, %i4
20188f0: 86 00 ff 80 add %g3, -128, %g3
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
20188f4: 84 00 a0 01 inc %g2
20188f8: 80 a0 a0 0b cmp %g2, 0xb
20188fc: 12 bf ff f5 bne 20188d0 <msdos_find_name_in_fat_file+0x5b0>
2018900: b8 07 00 03 add %i4, %g3, %i4
* empty_space_count is a count of empty entries in the currently
* read cluster so if 0 there is no space. Note, dir_offset will
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
2018904: 80 a6 20 00 cmp %i0, 0
2018908: 22 80 00 06 be,a 2018920 <msdos_find_name_in_fat_file+0x600>
201890c: ac 10 00 1b mov %i3, %l6
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;
2018910: 82 1e c0 16 xor %i3, %l6, %g1
2018914: 80 a0 00 01 cmp %g0, %g1
2018918: 10 80 00 04 b 2018928 <msdos_find_name_in_fat_file+0x608>
201891c: b4 40 20 00 addx %g0, 0, %i2
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
{
read_cluster = true;
2018920: b4 10 20 01 mov 1, %i2
empty_space_offset = dir_offset;
empty_space_entry = 0;
2018924: ae 10 20 00 clr %l7
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
2018928: 84 10 3f ff mov -1, %g2
201892c: 90 10 00 16 mov %l6, %o0
2018930: c4 27 bf fc st %g2, [ %fp + -4 ]
2018934: c4 27 bf f8 st %g2, [ %fp + -8 ]
2018938: 7f ff a7 46 call 2002650 <.umul>
201893c: 92 10 00 11 mov %l1, %o1
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
2018940: c6 07 a0 50 ld [ %fp + 0x50 ], %g3
2018944: 83 2c e0 02 sll %l3, 2, %g1
2018948: 85 2c e0 04 sll %l3, 4, %g2
201894c: 82 20 80 01 sub %g2, %g1, %g1
2018950: 82 00 40 13 add %g1, %l3, %g1
2018954: 82 00 c0 01 add %g3, %g1, %g1
2018958: ba 10 00 08 mov %o0, %i5
201895c: c2 27 bf e4 st %g1, [ %fp + -28 ]
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
lfn_entry = 0;
2018960: b0 10 20 00 clr %i0
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
2018964: 82 04 e0 01 add %l3, 1, %g1
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
2018968: 10 80 00 ba b 2018c50 <msdos_find_name_in_fat_file+0x930>
201896c: c2 27 bf ec st %g1, [ %fp + -20 ]
{
int length = 0;
if (read_cluster)
2018970: 02 80 00 2f be 2018a2c <msdos_find_name_in_fat_file+0x70c>
2018974: c6 07 bf e4 ld [ %fp + -28 ], %g3
{
uint32_t new_length;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
#endif
ret = fat_file_read(&fs_info->fat, fat_fd,
2018978: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
201897c: 90 10 00 10 mov %l0, %o0
2018980: 92 10 00 19 mov %i1, %o1
2018984: 94 10 00 1d mov %i5, %o2
2018988: 7f ff e6 63 call 2012314 <fat_file_read>
201898c: 96 10 00 11 mov %l1, %o3
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
2018990: 80 a2 00 11 cmp %o0, %l1
2018994: 02 80 00 25 be 2018a28 <msdos_find_name_in_fat_file+0x708><== NEVER TAKEN
2018998: 80 a2 20 00 cmp %o0, 0
{
if (ret != FAT_EOF)
201899c: 22 80 00 03 be,a 20189a8 <msdos_find_name_in_fat_file+0x688><== ALWAYS TAKEN
20189a0: 90 10 00 10 mov %l0, %o0
20189a4: 30 80 00 1b b,a 2018a10 <msdos_find_name_in_fat_file+0x6f0><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.2] extending file:%li\n", empty_space_offset);
#endif
ret = fat_file_extend (&fs_info->fat, fat_fd, false,
20189a8: 92 10 00 19 mov %i1, %o1
20189ac: 94 10 20 00 clr %o2
20189b0: 96 10 00 1d mov %i5, %o3
20189b4: 7f ff e7 6c call 2012764 <fat_file_extend>
20189b8: 98 07 bf f4 add %fp, -12, %o4
empty_space_offset * bts2rd, &new_length);
if (ret != RC_OK)
20189bc: 80 a2 20 00 cmp %o0, 0
20189c0: 12 80 00 a9 bne 2018c64 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
20189c4: c2 07 bf f4 ld [ %fp + -12 ], %g1
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))
20189c8: 80 a0 40 1d cmp %g1, %i5
20189cc: 22 80 00 03 be,a 20189d8 <msdos_find_name_in_fat_file+0x6b8><== ALWAYS TAKEN
20189d0: d0 04 20 a0 ld [ %l0 + 0xa0 ], %o0
20189d4: 30 80 00 0f b,a 2018a10 <msdos_find_name_in_fat_file+0x6f0><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
20189d8: 92 10 20 00 clr %o1
20189dc: 40 00 0d f0 call 201c19c <memset>
20189e0: 94 10 00 11 mov %l1, %o2
ret = fat_file_write(&fs_info->fat, fat_fd,
20189e4: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
20189e8: 90 10 00 10 mov %l0, %o0
20189ec: 92 10 00 19 mov %i1, %o1
20189f0: 94 10 00 1d mov %i5, %o2
20189f4: 7f ff e7 f2 call 20129bc <fat_file_write>
20189f8: 96 10 00 11 mov %l1, %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)
20189fc: 80 a2 3f ff cmp %o0, -1
2018a00: 02 80 00 99 be 2018c64 <msdos_find_name_in_fat_file+0x944><== ALWAYS TAKEN
2018a04: 80 a2 00 11 cmp %o0, %l1
return ret;
else if (ret != bts2rd)
2018a08: 02 80 00 09 be 2018a2c <msdos_find_name_in_fat_file+0x70c><== NOT EXECUTED
2018a0c: c6 07 bf e4 ld [ %fp + -28 ], %g3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
2018a10: 40 00 0a e7 call 201b5ac <__errno> <== NOT EXECUTED
2018a14: 01 00 00 00 nop <== NOT EXECUTED
2018a18: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2018a1c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2018a20: 10 80 00 91 b 2018c64 <msdos_find_name_in_fat_file+0x944> <== NOT EXECUTED
2018a24: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
2018a28: c6 07 bf e4 ld [ %fp + -28 ], %g3 <== NOT EXECUTED
2018a2c: 83 2e 20 02 sll %i0, 2, %g1
2018a30: 97 2e 20 04 sll %i0, 4, %o3
2018a34: 84 06 20 01 add %i0, 1, %g2
2018a38: 96 22 c0 01 sub %o3, %g1, %o3
2018a3c: 9a 10 20 00 clr %o5
2018a40: 96 02 c0 18 add %o3, %i0, %o3
2018a44: b4 10 20 00 clr %i2
2018a48: 96 20 c0 0b sub %g3, %o3, %o3
2018a4c: 10 80 00 68 b 2018bec <msdos_find_name_in_fat_file+0x8cc>
2018a50: 96 02 ff f3 add %o3, -13, %o3
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
2018a54: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
2018a58: c2 07 bf ec ld [ %fp + -20 ], %g1
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
2018a5c: aa 03 00 1b add %o4, %i3, %l5
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
2018a60: b4 06 a0 20 add %i2, 0x20, %i2
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
2018a64: 80 a0 80 01 cmp %g2, %g1
2018a68: 12 80 00 25 bne 2018afc <msdos_find_name_in_fat_file+0x7dc>
2018a6c: b0 10 00 02 mov %g2, %i0
{
/* get current cluster number */
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
2018a70: 90 10 00 10 mov %l0, %o0
2018a74: 92 10 00 19 mov %i1, %o1
2018a78: 94 10 20 01 mov 1, %o2
2018a7c: 96 10 00 1d mov %i5, %o3
2018a80: 7f ff e7 05 call 2012694 <fat_file_ioctl>
2018a84: 98 10 00 12 mov %l2, %o4
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
2018a88: 80 a2 20 00 cmp %o0, 0
2018a8c: 12 80 00 76 bne 2018c64 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
2018a90: d2 07 bf f8 ld [ %fp + -8 ], %o1
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
2018a94: 80 a2 7f ff cmp %o1, -1
2018a98: 12 80 00 0c bne 2018ac8 <msdos_find_name_in_fat_file+0x7a8>
2018a9c: f6 24 a0 04 st %i3, [ %l2 + 4 ]
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
2018aa0: c2 07 bf f8 ld [ %fp + -8 ], %g1
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
2018aa4: 90 10 00 15 mov %l5, %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
2018aa8: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
2018aac: c2 07 bf fc ld [ %fp + -4 ], %g1
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
2018ab0: 92 10 00 14 mov %l4, %o1
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
2018ab4: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
2018ab8: 40 00 0d 7c call 201c0a8 <memcpy>
2018abc: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
2018ac0: 10 80 00 50 b 2018c00 <msdos_find_name_in_fat_file+0x8e0>
2018ac4: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
2018ac8: 7f ff a6 e2 call 2002650 <.umul>
2018acc: 90 10 00 11 mov %l1, %o0
2018ad0: 92 10 00 19 mov %i1, %o1
2018ad4: 96 10 00 08 mov %o0, %o3
2018ad8: 94 10 20 01 mov 1, %o2
2018adc: 90 10 00 10 mov %l0, %o0
2018ae0: 7f ff e6 ed call 2012694 <fat_file_ioctl>
2018ae4: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
2018ae8: 80 a2 20 00 cmp %o0, 0
2018aec: 02 bf ff ee be 2018aa4 <msdos_find_name_in_fat_file+0x784><== ALWAYS TAKEN
2018af0: c2 07 bf f8 ld [ %fp + -8 ], %g1
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
2018af4: 81 c7 e0 08 ret <== NOT EXECUTED
2018af8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
* This is a long file name and we need to write
* a long file name entry. See if this is the
* first entry written and if so remember the
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
2018afc: c2 07 bf f8 ld [ %fp + -8 ], %g1
2018b00: 80 a0 7f ff cmp %g1, -1
2018b04: 32 80 00 05 bne,a 2018b18 <msdos_find_name_in_fat_file+0x7f8>
2018b08: d8 3f bf c0 std %o4, [ %fp + -64 ]
{
lfn_start.cln = empty_space_offset;
2018b0c: ec 27 bf f8 st %l6, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
2018b10: f6 27 bf fc st %i3, [ %fp + -4 ]
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2018b14: d8 3f bf c0 std %o4, [ %fp + -64 ]
2018b18: 94 10 20 20 mov 0x20, %o2
2018b1c: c4 27 bf d0 st %g2, [ %fp + -48 ]
2018b20: d6 27 bf c8 st %o3, [ %fp + -56 ]
2018b24: 90 10 00 15 mov %l5, %o0
2018b28: 40 00 0d 9d call 201c19c <memset>
2018b2c: 92 10 20 00 clr %o1
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
2018b30: f8 2d 60 0d stb %i4, [ %l5 + 0xd ]
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
2018b34: d6 07 bf c8 ld [ %fp + -56 ], %o3
2018b38: da 07 bf c4 ld [ %fp + -60 ], %o5
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
2018b3c: d8 07 bf c0 ld [ %fp + -64 ], %o4
2018b40: c4 07 bf d0 ld [ %fp + -48 ], %g2
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
2018b44: 82 05 60 01 add %l5, 1, %g1
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
2018b48: 9e 02 c0 0d add %o3, %o5, %o7
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
2018b4c: 94 10 20 00 clr %o2
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
2018b50: b0 10 20 00 clr %i0
{
if (*n != 0)
2018b54: d0 4b c0 00 ldsb [ %o7 ], %o0
2018b58: 80 a2 20 00 cmp %o0, 0
2018b5c: 02 80 00 05 be 2018b70 <msdos_find_name_in_fat_file+0x850>
2018b60: d2 0b c0 00 ldub [ %o7 ], %o1
{
*p = *n;
2018b64: d2 28 40 00 stb %o1, [ %g1 ]
n++;
2018b68: 10 80 00 05 b 2018b7c <msdos_find_name_in_fat_file+0x85c>
2018b6c: 9e 03 e0 01 inc %o7
}
else
{
p [0] = fill;
2018b70: d4 28 40 00 stb %o2, [ %g1 ]
p [1] = fill;
2018b74: d4 28 60 01 stb %o2, [ %g1 + 1 ]
fill = 0xff;
2018b78: 94 10 3f ff mov -1, %o2
}
switch (i)
2018b7c: 80 a6 20 04 cmp %i0, 4
2018b80: 02 80 00 06 be 2018b98 <msdos_find_name_in_fat_file+0x878>
2018b84: 80 a6 20 0a cmp %i0, 0xa
2018b88: 32 80 00 08 bne,a 2018ba8 <msdos_find_name_in_fat_file+0x888>
2018b8c: 82 00 60 02 add %g1, 2, %g1
{
case 4:
p += 5;
break;
case 10:
p += 4;
2018b90: 10 80 00 04 b 2018ba0 <msdos_find_name_in_fat_file+0x880>
2018b94: 82 00 60 04 add %g1, 4, %g1
switch (i)
{
case 4:
p += 5;
break;
2018b98: 10 80 00 04 b 2018ba8 <msdos_find_name_in_fat_file+0x888>
2018b9c: 82 00 60 05 add %g1, 5, %g1
case 10:
p += 4;
break;
2018ba0: 10 80 00 03 b 2018bac <msdos_find_name_in_fat_file+0x88c>
2018ba4: b0 06 20 01 inc %i0
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
2018ba8: b0 06 20 01 inc %i0
2018bac: 80 a6 20 0d cmp %i0, 0xd
2018bb0: 32 bf ff ea bne,a 2018b58 <msdos_find_name_in_fat_file+0x838>
2018bb4: d0 4b c0 00 ldsb [ %o7 ], %o0
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
2018bb8: c6 07 bf ec ld [ %fp + -20 ], %g3
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
2018bbc: 80 a0 a0 01 cmp %g2, 1
2018bc0: 02 80 00 04 be 2018bd0 <msdos_find_name_in_fat_file+0x8b0>
2018bc4: 82 20 c0 02 sub %g3, %g2, %g1
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
2018bc8: 10 80 00 04 b 2018bd8 <msdos_find_name_in_fat_file+0x8b8>
2018bcc: c2 2b 00 1b stb %g1, [ %o4 + %i3 ]
2018bd0: 82 10 60 40 or %g1, 0x40, %g1
2018bd4: c2 2b 00 1b stb %g1, [ %o4 + %i3 ]
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
2018bd8: c2 0d 60 0b ldub [ %l5 + 0xb ], %g1
2018bdc: 84 00 a0 01 inc %g2
2018be0: 82 10 60 0f or %g1, 0xf, %g1
2018be4: 9a 03 7f f3 add %o5, -13, %o5
2018be8: c2 2d 60 0b stb %g1, [ %l5 + 0xb ]
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
2018bec: b6 06 80 17 add %i2, %l7, %i3
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
2018bf0: 80 a6 c0 11 cmp %i3, %l1
2018bf4: 0a bf ff 98 bcs 2018a54 <msdos_find_name_in_fat_file+0x734><== ALWAYS TAKEN
2018bf8: b0 00 bf ff add %g2, -1, %i0
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
}
ret = fat_file_write(&fs_info->fat, fat_fd,
2018bfc: d8 04 20 a0 ld [ %l0 + 0xa0 ], %o4 <== NOT EXECUTED
2018c00: 90 10 00 10 mov %l0, %o0
2018c04: 92 10 00 19 mov %i1, %o1
2018c08: 94 07 40 17 add %i5, %l7, %o2
2018c0c: 96 10 00 1a mov %i2, %o3
2018c10: 7f ff e7 6b call 20129bc <fat_file_write>
2018c14: 98 03 00 17 add %o4, %l7, %o4
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
2018c18: 80 a2 3f ff cmp %o0, -1
2018c1c: 02 80 00 14 be 2018c6c <msdos_find_name_in_fat_file+0x94c><== NEVER TAKEN
2018c20: 80 a2 00 1a cmp %o0, %i2
return ret;
else if (ret != length)
2018c24: 02 80 00 08 be 2018c44 <msdos_find_name_in_fat_file+0x924><== ALWAYS TAKEN
2018c28: ba 07 40 11 add %i5, %l1, %i5
rtems_set_errno_and_return_minus_one(EIO);
2018c2c: 40 00 0a 60 call 201b5ac <__errno> <== NOT EXECUTED
2018c30: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2018c34: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2018c38: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2018c3c: 81 c7 e0 08 ret <== NOT EXECUTED
2018c40: 81 e8 00 00 restore <== NOT EXECUTED
empty_space_offset++;
2018c44: ac 05 a0 01 inc %l6
empty_space_entry = 0;
2018c48: ae 10 20 00 clr %l7
read_cluster = true;
2018c4c: b4 10 20 01 mov 1, %i2
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
2018c50: 80 a4 c0 18 cmp %l3, %i0
2018c54: 16 bf ff 47 bge 2018970 <msdos_find_name_in_fat_file+0x650>
2018c58: 80 8e a0 ff btst 0xff, %i2
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
2018c5c: 81 c7 e0 08 ret
2018c60: 91 e8 20 00 restore %g0, 0, %o0
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
2018c64: 81 c7 e0 08 ret
2018c68: 91 e8 00 08 restore %g0, %o0, %o0
}
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)
2018c6c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2018c70: 81 c7 e0 08 ret <== NOT EXECUTED
2018c74: 81 e8 00 00 restore <== NOT EXECUTED
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
2018c78: 80 a0 60 00 cmp %g1, 0
2018c7c: 02 bf fe c8 be 201879c <msdos_find_name_in_fat_file+0x47c>
2018c80: 82 10 3f ff mov -1, %g1
((name_type == MSDOS_NAME_SHORT) &&
2018c84: 10 bf fe 9c b 20186f4 <msdos_find_name_in_fat_file+0x3d4>
2018c88: de 07 bf f8 ld [ %fp + -8 ], %o7
02018c8c <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
)
{
2018c8c: 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) &&
2018c90: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2018c94: 80 a0 60 01 cmp %g1, 1
2018c98: 12 80 00 0f bne 2018cd4 <msdos_find_node_by_cluster_num_in_fat_file+0x48><== ALWAYS TAKEN
2018c9c: fa 06 20 08 ld [ %i0 + 8 ], %i5
2018ca0: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
2018ca4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2018ca8: 32 80 00 07 bne,a 2018cc4 <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
2018cac: f0 17 60 06 lduh [ %i5 + 6 ], %i0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
2018cb0: c2 0f 60 0e ldub [ %i5 + 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) &&
2018cb4: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2018cb8: 22 80 00 03 be,a 2018cc4 <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
2018cbc: f0 17 60 06 lduh [ %i5 + 6 ], %i0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
2018cc0: f0 06 60 18 ld [ %i1 + 0x18 ], %i0 <== NOT EXECUTED
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
2018cc4: 27 00 00 3f sethi %hi(0xfc00), %l3
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
2018cc8: a2 10 20 00 clr %l1
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
2018ccc: 10 80 00 44 b 2018ddc <msdos_find_node_by_cluster_num_in_fat_file+0x150>
2018cd0: a6 14 e3 ff or %l3, 0x3ff, %l3
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
2018cd4: 10 bf ff fc b 2018cc4 <msdos_find_node_by_cluster_num_in_fat_file+0x38>
2018cd8: f0 17 60 06 lduh [ %i5 + 6 ], %i0
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
2018cdc: 14 80 00 08 bg 2018cfc <msdos_find_node_by_cluster_num_in_fat_file+0x70><== ALWAYS TAKEN
2018ce0: 80 a2 00 18 cmp %o0, %i0
rtems_set_errno_and_return_minus_one( EIO );
2018ce4: 40 00 0a 32 call 201b5ac <__errno> <== NOT EXECUTED
2018ce8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2018cec: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2018cf0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2018cf4: 81 c7 e0 08 ret <== NOT EXECUTED
2018cf8: 81 e8 00 00 restore <== NOT EXECUTED
assert(ret == bts2rd);
2018cfc: 22 80 00 0a be,a 2018d24 <msdos_find_node_by_cluster_num_in_fat_file+0x98><== ALWAYS TAKEN
2018d00: e0 07 60 a0 ld [ %i5 + 0xa0 ], %l0
2018d04: 11 00 80 af sethi %hi(0x202bc00), %o0 <== NOT EXECUTED
2018d08: 15 00 80 af sethi %hi(0x202bc00), %o2 <== NOT EXECUTED
2018d0c: 17 00 80 af sethi %hi(0x202bc00), %o3 <== NOT EXECUTED
2018d10: 90 12 20 28 or %o0, 0x28, %o0 <== NOT EXECUTED
2018d14: 92 10 26 4e mov 0x64e, %o1 <== NOT EXECUTED
2018d18: 94 12 a1 18 or %o2, 0x118, %o2 <== NOT EXECUTED
2018d1c: 7f ff ee 80 call 201471c <__assert_func> <== NOT EXECUTED
2018d20: 96 12 e0 c8 or %o3, 0xc8, %o3 <== NOT EXECUTED
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
2018d24: a4 10 20 00 clr %l2
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
2018d28: c2 0c 00 00 ldub [ %l0 ], %g1
2018d2c: 80 a0 60 00 cmp %g1, 0
2018d30: 02 80 00 34 be 2018e00 <msdos_find_node_by_cluster_num_in_fat_file+0x174><== NEVER TAKEN
2018d34: 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)) ==
2018d38: 22 80 00 25 be,a 2018dcc <msdos_find_node_by_cluster_num_in_fat_file+0x140><== NEVER TAKEN
2018d3c: a4 04 a0 20 add %l2, 0x20, %l2 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
2018d40: c4 14 20 14 lduh [ %l0 + 0x14 ], %g2
2018d44: c2 14 20 1a lduh [ %l0 + 0x1a ], %g1
2018d48: 85 28 a0 10 sll %g2, 0x10, %g2
2018d4c: 87 30 a0 18 srl %g2, 0x18, %g3
2018d50: 83 28 60 10 sll %g1, 0x10, %g1
2018d54: 85 30 a0 08 srl %g2, 8, %g2
2018d58: 84 08 80 13 and %g2, %l3, %g2
2018d5c: 84 10 c0 02 or %g3, %g2, %g2
2018d60: 87 30 60 18 srl %g1, 0x18, %g3
2018d64: 85 28 a0 10 sll %g2, 0x10, %g2
2018d68: 83 30 60 08 srl %g1, 8, %g1
2018d6c: 82 08 40 13 and %g1, %l3, %g1
2018d70: 82 10 c0 01 or %g3, %g1, %g1
2018d74: 82 10 80 01 or %g2, %g1, %g1
2018d78: 80 a0 40 1a cmp %g1, %i2
2018d7c: 32 80 00 14 bne,a 2018dcc <msdos_find_node_by_cluster_num_in_fat_file+0x140>
2018d80: a4 04 a0 20 add %l2, 0x20, %l2
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
2018d84: 90 10 00 1d mov %i5, %o0
2018d88: 92 10 00 19 mov %i1, %o1
2018d8c: 94 10 20 01 mov 1, %o2
2018d90: 96 10 00 11 mov %l1, %o3
2018d94: 7f ff e6 40 call 2012694 <fat_file_ioctl>
2018d98: 98 10 00 1b mov %i3, %o4
&dir_pos->sname.cln);
if (rc != RC_OK)
2018d9c: b0 92 20 00 orcc %o0, 0, %i0
2018da0: 12 bf ff d5 bne 2018cf4 <msdos_find_node_by_cluster_num_in_fat_file+0x68><== NEVER TAKEN
2018da4: 82 10 3f ff mov -1, %g1
return rc;
dir_pos->sname.ofs = i;
2018da8: e4 26 e0 04 st %l2, [ %i3 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2018dac: c2 26 e0 08 st %g1, [ %i3 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2018db0: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
memcpy(dir_entry, entry,
2018db4: 90 10 00 1c mov %i4, %o0
2018db8: 92 10 00 10 mov %l0, %o1
2018dbc: 40 00 0c bb call 201c0a8 <memcpy>
2018dc0: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
2018dc4: 81 c7 e0 08 ret
2018dc8: 81 e8 00 00 restore
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2018dcc: 80 a4 80 18 cmp %l2, %i0
2018dd0: 0a bf ff d6 bcs 2018d28 <msdos_find_node_by_cluster_num_in_fat_file+0x9c><== ALWAYS TAKEN
2018dd4: a0 04 20 20 add %l0, 0x20, %l0
2018dd8: a2 04 40 18 add %l1, %i0, %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
2018ddc: d8 07 60 a0 ld [ %i5 + 0xa0 ], %o4
2018de0: 90 10 00 1d mov %i5, %o0
2018de4: 92 10 00 19 mov %i1, %o1
2018de8: 94 10 00 11 mov %l1, %o2
2018dec: 7f ff e5 4a call 2012314 <fat_file_read>
2018df0: 96 10 00 18 mov %i0, %o3
2018df4: 80 a2 20 00 cmp %o0, 0
2018df8: 12 bf ff b9 bne 2018cdc <msdos_find_node_by_cluster_num_in_fat_file+0x50><== ALWAYS TAKEN
2018dfc: 80 a2 20 1f cmp %o0, 0x1f
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
2018e00: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
2018e04: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
2018e08: 81 c7 e0 08 ret <== NOT EXECUTED
2018e0c: 81 e8 00 00 restore <== NOT EXECUTED
0200d864 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
200d864: 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");
200d868: 92 10 20 02 mov 2, %o1
200d86c: 90 10 00 19 mov %i1, %o0
200d870: 15 00 80 ad sethi %hi(0x202b400), %o2
200d874: 7f ff ff 60 call 200d5f4 <msdos_format_printf>
200d878: 94 12 a1 b0 or %o2, 0x1b0, %o2 ! 202b5b0 <_CPU_Trap_slot_template+0x68>
fd = open(devname, O_RDWR);
200d87c: 92 10 20 02 mov 2, %o1
200d880: 7f ff e2 2a call 2006128 <open>
200d884: 90 10 00 18 mov %i0, %o0
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
struct stat stat_buf;
int ret_val = 0;
200d888: 82 38 00 08 xnor %g0, %o0, %g1
200d88c: 80 a0 00 01 cmp %g0, %g1
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
fd = open(devname, O_RDWR);
200d890: b8 10 00 08 mov %o0, %i4
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
struct stat stat_buf;
int ret_val = 0;
200d894: b6 40 3f ff addx %g0, -1, %i3
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200d898: 90 10 00 19 mov %i1, %o0
200d89c: 92 10 20 02 mov 2, %o1
200d8a0: 15 00 80 ad sethi %hi(0x202b400), %o2
200d8a4: 96 10 00 18 mov %i0, %o3
200d8a8: 7f ff ff 53 call 200d5f4 <msdos_format_printf>
200d8ac: 94 12 a1 c0 or %o2, 0x1c0, %o2
"stat check: %s\n", devname);
if (ret_val == 0) {
200d8b0: 80 a6 e0 00 cmp %i3, 0
200d8b4: 12 80 00 06 bne 200d8cc <msdos_format+0x68> <== NEVER TAKEN
200d8b8: ba 10 3f ff mov -1, %i5
ret_val = fstat(fd, &stat_buf);
200d8bc: 90 10 00 1c mov %i4, %o0
200d8c0: 7f ff de cf call 20053fc <fstat>
200d8c4: 92 07 bd 60 add %fp, -672, %o1
200d8c8: ba 10 00 08 mov %o0, %i5
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
200d8cc: 90 10 00 19 mov %i1, %o0
200d8d0: 92 10 20 01 mov 1, %o1
200d8d4: 15 00 80 ad sethi %hi(0x202b400), %o2
200d8d8: 96 10 00 18 mov %i0, %o3
200d8dc: 7f ff ff 46 call 200d5f4 <msdos_format_printf>
200d8e0: 94 12 a1 d0 or %o2, 0x1d0, %o2
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
200d8e4: 80 a7 60 00 cmp %i5, 0
200d8e8: 12 80 02 0d bne 200e11c <msdos_format+0x8b8> <== NEVER TAKEN
200d8ec: 80 a0 00 19 cmp %g0, %i1
200d8f0: c4 07 bd 6c ld [ %fp + -660 ], %g2
200d8f4: 03 00 00 3c sethi %hi(0xf000), %g1
200d8f8: 84 08 80 01 and %g2, %g1, %g2
200d8fc: 03 00 00 18 sethi %hi(0x6000), %g1
200d900: 80 a0 80 01 cmp %g2, %g1
200d904: 02 80 03 7d be 200e6f8 <msdos_format+0xe94> <== ALWAYS TAKEN
200d908: 92 10 20 00 clr %o1
errno = ENOTTY;
200d90c: 40 00 37 28 call 201b5ac <__errno> <== NOT EXECUTED
200d910: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
200d914: 82 10 20 19 mov 0x19, %g1 <== NOT EXECUTED
200d918: 10 80 02 00 b 200e118 <msdos_format+0x8b4> <== NOT EXECUTED
200d91c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
static inline int rtems_disk_fd_get_block_count(
int fd,
rtems_blkdev_bnum *block_count
)
{
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
200d920: 92 16 e2 05 or %i3, 0x205, %o1
200d924: 40 00 1c 3d call 2014a18 <ioctl>
200d928: 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) {
200d92c: ba 92 20 00 orcc %o0, 0, %i5
200d930: 12 80 01 67 bne 200decc <msdos_format+0x668> <== NEVER TAKEN
200d934: f0 07 bd ac ld [ %fp + -596 ], %i0
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
200d938: fa 07 bd b0 ld [ %fp + -592 ], %i5
200d93c: 92 10 00 18 mov %i0, %o1
200d940: 7f ff d3 44 call 2002650 <.umul>
200d944: 90 10 00 1d mov %i5, %o0
200d948: b4 10 20 00 clr %i2
200d94c: b6 10 00 08 mov %o0, %i3
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200d950: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
200d954: f4 3f bd 58 std %i2, [ %fp + -680 ]
200d958: 9a 10 20 00 clr %o5
200d95c: 90 10 00 19 mov %i1, %o0
200d960: 92 10 20 02 mov 2, %o1
200d964: 15 00 80 ad sethi %hi(0x202b400), %o2
200d968: 96 10 00 18 mov %i0, %o3
200d96c: 94 12 a1 e0 or %o2, 0x1e0, %o2
200d970: 7f ff ff 21 call 200d5f4 <msdos_format_printf>
200d974: 98 10 00 1d mov %i5, %o4
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
200d978: 80 a6 60 00 cmp %i1, 0
200d97c: 02 80 00 0a be 200d9a4 <msdos_format+0x140>
200d980: 82 10 20 02 mov 2, %g1
(rqdata->fat_num == 0)) {
200d984: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
200d988: 80 a0 60 00 cmp %g1, 0
200d98c: 12 80 00 04 bne 200d99c <msdos_format+0x138>
200d990: 80 a0 60 06 cmp %g1, 6
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
200d994: 10 80 00 04 b 200d9a4 <msdos_format+0x140>
200d998: 82 10 20 02 mov 2, %g1
}
else if (rqdata->fat_num <= 6) {
200d99c: 18 80 00 04 bgu 200d9ac <msdos_format+0x148>
200d9a0: 01 00 00 00 nop
fmt_params->fat_num = rqdata->fat_num;
200d9a4: 10 80 03 62 b 200e72c <msdos_format+0xec8>
200d9a8: c2 2f bd dc stb %g1, [ %fp + -548 ]
}
else {
errno = EINVAL;
200d9ac: 40 00 37 00 call 201b5ac <__errno>
200d9b0: ba 10 3f ff mov -1, %i5
200d9b4: 82 10 20 16 mov 0x16, %g1
200d9b8: 10 80 01 45 b 200decc <msdos_format+0x668>
200d9bc: c2 22 00 00 st %g1, [ %o0 ]
* 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) {
200d9c0: 84 90 60 00 orcc %g1, 0, %g2
200d9c4: 12 80 00 05 bne 200d9d8 <msdos_format+0x174>
200d9c8: c6 07 bd b0 ld [ %fp + -592 ], %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;
200d9cc: 84 10 20 20 mov 0x20, %g2
/*
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
200d9d0: 82 10 20 08 mov 8, %g1
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
fat12_sect_per_clust = rqdata->sectors_per_cluster;
fat16_sect_per_clust = rqdata->sectors_per_cluster;
}
if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
200d9d4: c6 07 bd b0 ld [ %fp + -592 ], %g3
200d9d8: 89 28 60 02 sll %g1, 2, %g4
200d9dc: bb 28 60 0a sll %g1, 0xa, %i5
200d9e0: 88 27 40 04 sub %i5, %g4, %g4
200d9e4: 88 01 00 01 add %g4, %g1, %g4
200d9e8: 89 29 20 02 sll %g4, 2, %g4
200d9ec: 82 01 00 01 add %g4, %g1, %g1
200d9f0: 80 a0 c0 01 cmp %g3, %g1
200d9f4: 3a 80 00 04 bcc,a 200da04 <msdos_format+0x1a0>
200d9f8: 83 28 a0 02 sll %g2, 2, %g1
fmt_params->fattype = FAT_FAT12;
200d9fc: 10 80 00 0b b 200da28 <msdos_format+0x1c4>
200da00: 82 10 20 01 mov 1, %g1
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
200da04: 89 28 a0 0e sll %g2, 0xe, %g4
200da08: 82 21 00 01 sub %g4, %g1, %g1
200da0c: 82 00 40 02 add %g1, %g2, %g1
200da10: 83 28 60 02 sll %g1, 2, %g1
200da14: 84 00 40 02 add %g1, %g2, %g2
200da18: 80 a0 c0 02 cmp %g3, %g2
200da1c: 1a 80 00 06 bcc 200da34 <msdos_format+0x1d0>
200da20: 1b 10 00 00 sethi %hi(0x40000000), %o5
fmt_params->fattype = FAT_FAT16;
200da24: 82 10 20 02 mov 2, %g1
200da28: c2 2f bd de stb %g1, [ %fp + -546 ]
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
200da2c: 10 80 00 15 b 200da80 <msdos_format+0x21c>
200da30: 82 10 20 02 mov 2, %g1
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
200da34: 86 86 c0 0d addcc %i3, %o5, %g3
200da38: 83 30 e0 1e srl %g3, 0x1e, %g1
200da3c: 98 10 20 00 clr %o4
200da40: 84 46 80 0c addx %i2, %o4, %g2
200da44: 85 28 a0 02 sll %g2, 2, %g2
200da48: 84 10 80 01 or %g2, %g1, %g2
int b;
fmt_params->fattype = FAT_FAT32;
200da4c: 82 10 20 04 mov 4, %g1
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
200da50: 86 10 20 01 mov 1, %g3
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
200da54: c2 2f bd de stb %g1, [ %fp + -546 ]
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
200da58: 82 10 20 1f mov 0x1f, %g1
if ((gigs & (1 << b)) != 0)
200da5c: 89 28 c0 01 sll %g3, %g1, %g4
200da60: 80 89 00 02 btst %g4, %g2
200da64: 32 80 00 06 bne,a 200da7c <msdos_format+0x218>
200da68: 84 10 20 01 mov 1, %g2
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
200da6c: 82 80 7f ff addcc %g1, -1, %g1
200da70: 12 bf ff fc bne 200da60 <msdos_format+0x1fc>
200da74: 89 28 c0 01 sll %g3, %g1, %g4
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
200da78: 84 10 20 01 mov 1, %g2
200da7c: 83 28 80 01 sll %g2, %g1, %g1
200da80: c2 27 bd b8 st %g1, [ %fp + -584 ]
}
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
200da84: 90 10 00 19 mov %i1, %o0
200da88: 7f ff ff 53 call 200d7d4 <msdos_set_sectors_per_cluster_from_request>
200da8c: 92 07 bd ac add %fp, -596, %o1
/* 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;
200da90: 98 10 20 00 clr %o4
200da94: 1b 10 00 00 sethi %hi(0x40000000), %o5
200da98: 86 86 c0 0d addcc %i3, %o5, %g3
200da9c: 84 46 80 0c addx %i2, %o4, %g2
200daa0: 83 30 e0 1e srl %g3, 0x1e, %g1
200daa4: 85 28 a0 02 sll %g2, 2, %g2
200daa8: 82 10 80 01 or %g2, %g1, %g1
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
/*
* Skip aligning structures or d align them
*/
if (ret_val == 0 && rqdata != NULL)
200daac: 80 a0 00 19 cmp %g0, %i1
/* 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;
200dab0: c2 27 bd 40 st %g1, [ %fp + -704 ]
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 );
200dab4: ba 10 00 08 mov %o0, %i5
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
/*
* Skip aligning structures or d align them
*/
if (ret_val == 0 && rqdata != NULL)
200dab8: 82 40 20 00 addx %g0, 0, %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;
200dabc: b4 10 3f ff mov -1, %i2
200dac0: a8 10 20 00 clr %l4
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
/*
* Skip aligning structures or d align them
*/
if (ret_val == 0 && rqdata != NULL)
200dac4: 10 80 00 f8 b 200dea4 <msdos_format+0x640>
200dac8: c2 27 bd 48 st %g1, [ %fp + -696 ]
200dacc: 80 a1 20 00 cmp %g4, 0
200dad0: 02 80 00 05 be 200dae4 <msdos_format+0x280>
200dad4: d6 07 bd b8 ld [ %fp + -584 ], %o3
fmt_params->skip_alignment = rqdata->skip_alignment;
200dad8: c2 0e 60 16 ldub [ %i1 + 0x16 ], %g1
200dadc: c2 2f bd fc stb %g1, [ %fp + -516 ]
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200dae0: d6 07 bd b8 ld [ %fp + -584 ], %o3
200dae4: 90 10 00 19 mov %i1, %o0
200dae8: 92 10 20 02 mov 2, %o1
200daec: 15 00 80 ad sethi %hi(0x202b400), %o2
200daf0: 7f ff fe c1 call 200d5f4 <msdos_format_printf>
200daf4: 94 12 a2 20 or %o2, 0x220, %o2 ! 202b620 <_CPU_Trap_slot_template+0xd8>
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
200daf8: f4 0f bd de ldub [ %fp + -546 ], %i2
200dafc: 82 0e a0 ff and %i2, 0xff, %g1
200db00: 80 a0 60 04 cmp %g1, 4
200db04: 12 80 00 0a bne 200db2c <msdos_format+0x2c8>
200db08: 82 10 20 01 mov 1, %g1
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
200db0c: 82 10 20 20 mov 0x20, %g1
200db10: c2 27 bd b4 st %g1, [ %fp + -588 ]
/* 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;
200db14: 82 10 20 06 mov 6, %g1
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
200db18: c0 27 bd c4 clr [ %fp + -572 ]
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
200db1c: c2 27 bd d4 st %g1, [ %fp + -556 ]
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
200db20: 82 10 20 01 mov 1, %g1
200db24: 10 80 00 1c b 200db94 <msdos_format+0x330>
200db28: c2 27 bd d8 st %g1, [ %fp + -552 ]
}
else {
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
200db2c: c2 27 bd b4 st %g1, [ %fp + -588 ]
/* 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) &&
200db30: c2 07 bd 48 ld [ %fp + -696 ], %g1
200db34: 80 a0 60 00 cmp %g1, 0
200db38: 02 80 00 08 be 200db58 <msdos_format+0x2f4>
200db3c: 82 0e a0 ff and %i2, 0xff, %g1
(rqdata->files_per_root_dir > 0)) {
200db40: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
200db44: 80 a0 60 00 cmp %g1, 0
200db48: 22 80 00 04 be,a 200db58 <msdos_format+0x2f4>
200db4c: 82 0e a0 ff and %i2, 0xff, %g1
else {
if (fmt_params->fattype == FAT_FAT16) {
fmt_params->files_per_root_dir = 512;
}
else {
fmt_params->files_per_root_dir = 64;
200db50: 10 80 00 07 b 200db6c <msdos_format+0x308>
200db54: c2 27 bd c4 st %g1, [ %fp + -572 ]
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) {
200db58: 80 a0 60 02 cmp %g1, 2
200db5c: 32 80 00 03 bne,a 200db68 <msdos_format+0x304>
200db60: 82 10 20 40 mov 0x40, %g1
200db64: 82 10 22 00 mov 0x200, %g1
fmt_params->files_per_root_dir = 512;
}
else {
fmt_params->files_per_root_dir = 64;
200db68: c2 27 bd c4 st %g1, [ %fp + -572 ]
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
200db6c: d2 07 bd ac ld [ %fp + -596 ], %o1
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
200db70: f6 07 bd c4 ld [ %fp + -572 ], %i3
(2*fmt_params->bytes_per_sector/
200db74: 93 2a 60 01 sll %o1, 1, %o1
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
200db78: b6 06 ff ff add %i3, -1, %i3
(2*fmt_params->bytes_per_sector/
200db7c: 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 +
200db80: b6 06 c0 09 add %i3, %o1, %i3
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
200db84: 40 00 6b f6 call 2028b5c <.urem>
200db88: 90 10 00 1b mov %i3, %o0
200db8c: 90 26 c0 08 sub %i3, %o0, %o0
200db90: d0 27 bd c4 st %o0, [ %fp + -572 ]
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
200db94: f6 07 bd ac ld [ %fp + -596 ], %i3
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
200db98: d0 07 bd c4 ld [ %fp + -572 ], %o0
+ fmt_params->bytes_per_sector - 1)
200db9c: 88 06 ff ff add %i3, -1, %g4
/ fmt_params->bytes_per_sector);
200dba0: 92 10 00 1b mov %i3, %o1
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
200dba4: c8 27 bd 54 st %g4, [ %fp + -684 ]
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
200dba8: 91 2a 20 05 sll %o0, 5, %o0
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
200dbac: 7f ff d2 e3 call 2002738 <.udiv>
200dbb0: 90 01 00 08 add %g4, %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,
200dbb4: c2 07 bd b0 ld [ %fp + -592 ], %g1
200dbb8: c8 07 bd b4 ld [ %fp + -588 ], %g4
}
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);
200dbbc: a4 10 00 08 mov %o0, %l2
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
200dbc0: d0 27 bd c8 st %o0, [ %fp + -568 ]
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,
200dbc4: b0 0e a0 ff and %i2, 0xff, %i0
200dbc8: c2 27 bd 44 st %g1, [ %fp + -700 ]
200dbcc: c8 27 bd 50 st %g4, [ %fp + -688 ]
200dbd0: ea 0f bd dc ldub [ %fp + -548 ], %l5
200dbd4: ec 07 bd b8 ld [ %fp + -584 ], %l6
200dbd8: e6 0f bd fc ldub [ %fp + -516 ], %l3
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) {
200dbdc: 92 10 00 1b mov %i3, %o1
200dbe0: 7f ff d2 d6 call 2002738 <.udiv>
200dbe4: 11 00 00 20 sethi %hi(0x8000), %o0
200dbe8: 10 80 00 03 b 200dbf4 <msdos_format+0x390>
200dbec: 80 a2 00 16 cmp %o0, %l6
200dbf0: 80 a2 00 16 cmp %o0, %l6 <== NOT EXECUTED
200dbf4: 2a bf ff ff bcs,a 200dbf0 <msdos_format+0x38c> <== NEVER TAKEN
200dbf8: ad 35 a0 01 srl %l6, 1, %l6 <== 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);
200dbfc: c2 07 bd 50 ld [ %fp + -688 ], %g1
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
200dc00: aa 0d 60 ff and %l5, 0xff, %l5
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
200dc04: 82 00 7f ff add %g1, -1, %g1
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200dc08: a6 0c e0 ff and %l3, 0xff, %l3
return (sectors + clustersize - 1) & ~(clustersize - 1);
200dc0c: c2 27 bd 3c st %g1, [ %fp + -708 ]
200dc10: ae 04 bf ff add %l2, -1, %l7
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
200dc14: ea 27 bd 4c st %l5, [ %fp + -692 ]
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200dc18: 80 a4 e0 00 cmp %l3, 0
200dc1c: 12 80 00 06 bne 200dc34 <msdos_format+0x3d0>
200dc20: d0 07 bd 50 ld [ %fp + -688 ], %o0
return (sectors + clustersize - 1) & ~(clustersize - 1);
200dc24: c8 07 bd 3c ld [ %fp + -708 ], %g4
200dc28: 90 20 00 16 neg %l6, %o0
200dc2c: 84 01 00 16 add %g4, %l6, %g2
200dc30: 90 0a 00 02 and %o0, %g2, %o0
* 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
200dc34: c2 07 bd 44 ld [ %fp + -700 ], %g1
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
200dc38: 80 a6 20 01 cmp %i0, 1
200dc3c: 12 80 00 10 bne 200dc7c <msdos_format+0x418>
200dc40: 90 20 40 08 sub %g1, %o0, %o0
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200dc44: 80 a4 e0 00 cmp %l3, 0
200dc48: 12 80 00 05 bne 200dc5c <msdos_format+0x3f8>
200dc4c: 84 10 00 12 mov %l2, %g2
return (sectors + clustersize - 1) & ~(clustersize - 1);
200dc50: 84 05 c0 16 add %l7, %l6, %g2
200dc54: 86 20 00 16 neg %l6, %g3
200dc58: 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;
200dc5c: 90 22 00 02 sub %o0, %g2, %o0
200dc60: 7f ff d2 b6 call 2002738 <.udiv>
200dc64: 92 10 00 16 mov %l6, %o1
200dc68: a0 10 00 08 mov %o0, %l0
fat_capacity = fatdata_cluster_cnt * 3 / 2;
200dc6c: 91 2a 20 01 sll %o0, 1, %o0
200dc70: 90 02 00 10 add %o0, %l0, %o0
200dc74: 10 80 00 14 b 200dcc4 <msdos_format+0x460>
200dc78: 91 32 20 01 srl %o0, 1, %o0
}
else if (fattype == FAT_FAT16) {
200dc7c: 80 a6 20 02 cmp %i0, 2
200dc80: 12 80 00 0d bne 200dcb4 <msdos_format+0x450>
200dc84: 80 a4 e0 00 cmp %l3, 0
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200dc88: 12 80 00 05 bne 200dc9c <msdos_format+0x438>
200dc8c: 84 10 00 12 mov %l2, %g2
return (sectors + clustersize - 1) & ~(clustersize - 1);
200dc90: 84 05 c0 16 add %l7, %l6, %g2
200dc94: 86 20 00 16 neg %l6, %g3
200dc98: 84 08 c0 02 and %g3, %g2, %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;
200dc9c: 90 22 00 02 sub %o0, %g2, %o0
200dca0: 7f ff d2 a6 call 2002738 <.udiv>
200dca4: 92 10 00 16 mov %l6, %o1
200dca8: a0 10 00 08 mov %o0, %l0
fat_capacity = fatdata_cluster_cnt * 2;
200dcac: 10 80 00 06 b 200dcc4 <msdos_format+0x460>
200dcb0: 91 2a 20 01 sll %o0, 1, %o0
}
else { /* FAT32 */
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
200dcb4: 7f ff d2 a1 call 2002738 <.udiv>
200dcb8: 92 10 00 16 mov %l6, %o1
200dcbc: a0 10 00 08 mov %o0, %l0
fat_capacity = fatdata_cluster_cnt * 4;
200dcc0: 91 2a 20 02 sll %o0, 2, %o0
}
sectors_per_fat = ((fat_capacity
200dcc4: c8 07 bd 54 ld [ %fp + -684 ], %g4
200dcc8: 92 10 00 1b mov %i3, %o1
200dccc: 7f ff d2 9b call 2002738 <.udiv>
200dcd0: 90 02 00 04 add %o0, %g4, %o0
+ (bytes_per_sector - 1))
/ bytes_per_sector);
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
200dcd4: 7f ff d2 5f call 2002650 <.umul>
200dcd8: d2 07 bd 4c ld [ %fp + -692 ], %o1
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200dcdc: 80 a4 e0 00 cmp %l3, 0
200dce0: 12 80 00 06 bne 200dcf8 <msdos_format+0x494>
200dce4: a2 10 00 08 mov %o0, %l1
return (sectors + clustersize - 1) & ~(clustersize - 1);
200dce8: 84 05 bf ff add %l6, -1, %g2
200dcec: a2 00 80 08 add %g2, %o0, %l1
200dcf0: 84 20 00 16 neg %l6, %g2
200dcf4: a2 0c 40 02 and %l1, %g2, %l1
sectors_per_cluster,
skip_alignment);
*data_cluster_cnt = (fatdata_cluster_cnt -
((fat_sectors_cnt
+ (sectors_per_cluster - 1))
200dcf8: 90 05 bf ff add %l6, -1, %o0
/ sectors_per_cluster));
200dcfc: 92 10 00 16 mov %l6, %o1
200dd00: 7f ff d2 8e call 2002738 <.udiv>
200dd04: 90 02 00 11 add %o0, %l1, %o0
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
200dd08: 80 a6 20 01 cmp %i0, 1
200dd0c: 12 80 00 07 bne 200dd28 <msdos_format+0x4c4>
200dd10: a0 24 00 08 sub %l0, %o0, %l0
200dd14: 80 a4 2f f5 cmp %l0, 0xff5
200dd18: 08 80 00 10 bleu 200dd58 <msdos_format+0x4f4>
200dd1c: aa 10 20 01 mov 1, %l5
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
200dd20: 10 80 00 0b b 200dd4c <msdos_format+0x4e8>
200dd24: ad 2d a0 01 sll %l6, 1, %l6
+ (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)) ||
200dd28: 80 a6 20 02 cmp %i0, 2
200dd2c: 12 80 00 11 bne 200dd70 <msdos_format+0x50c>
200dd30: aa 10 20 01 mov 1, %l5
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
200dd34: 03 00 00 3f sethi %hi(0xfc00), %g1
200dd38: 82 10 63 f5 or %g1, 0x3f5, %g1 ! fff5 <PROM_START+0xfff5>
200dd3c: 80 a4 00 01 cmp %l0, %g1
200dd40: 08 80 00 0d bleu 200dd74 <msdos_format+0x510>
200dd44: 90 10 00 16 mov %l6, %o0
sectors_per_cluster *= 2;
200dd48: ad 2d a0 01 sll %l6, 1, %l6
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if (fattype == FAT_FAT12) {
200dd4c: 80 a6 20 01 cmp %i0, 1
200dd50: 12 80 00 08 bne 200dd70 <msdos_format+0x50c>
200dd54: aa 10 20 00 clr %l5
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
200dd58: 90 10 00 16 mov %l6, %o0
200dd5c: 7f ff d2 3d call 2002650 <.umul>
200dd60: 92 10 00 1b mov %i3, %o1
200dd64: 09 00 00 04 sethi %hi(0x1000), %g4
200dd68: 10 80 00 07 b 200dd84 <msdos_format+0x520>
200dd6c: 80 a2 00 04 cmp %o0, %g4
finished = true;
}
} else if ((sectors_per_cluster * bytes_per_sector)
200dd70: 90 10 00 16 mov %l6, %o0
200dd74: 7f ff d2 37 call 2002650 <.umul>
200dd78: 92 10 00 1b mov %i3, %o1
200dd7c: 03 00 00 20 sethi %hi(0x8000), %g1
200dd80: 80 a2 00 01 cmp %o0, %g1
200dd84: 38 80 00 06 bgu,a 200dd9c <msdos_format+0x538>
200dd88: d2 07 bd 4c ld [ %fp + -692 ], %o1
> MS_BYTES_PER_CLUSTER_LIMIT) {
finished = true;
}
} while (!finished);
200dd8c: 80 8d 60 ff btst 0xff, %l5
200dd90: 02 bf ff a3 be 200dc1c <msdos_format+0x3b8>
200dd94: 80 a4 e0 00 cmp %l3, 0
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
200dd98: d2 07 bd 4c ld [ %fp + -692 ], %o1
200dd9c: 7f ff d2 67 call 2002738 <.udiv>
200dda0: 90 10 00 11 mov %l1, %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 =
200dda4: 09 00 80 ad sethi %hi(0x202b400), %g4
finished = true;
}
} while (!finished);
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
200dda8: 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 =
200ddac: d0 01 22 e0 ld [ %g4 + 0x2e0 ], %o0
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment,
§ors_per_cluster_adj,
&fmt_params->sectors_per_fat,
&data_clusters_cnt);
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
200ddb0: ec 27 bd b8 st %l6, [ %fp + -584 ]
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 =
200ddb4: 7f ff d2 61 call 2002738 <.udiv>
200ddb8: 92 10 00 1b mov %i3, %o1
( 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
200ddbc: 80 a2 00 16 cmp %o0, %l6
200ddc0: 2a 80 00 06 bcs,a 200ddd8 <msdos_format+0x574>
200ddc4: 11 00 00 20 sethi %hi(0x8000), %o0
200ddc8: 80 a4 2f f4 cmp %l0, 0xff4
200ddcc: 08 80 00 0f bleu 200de08 <msdos_format+0x5a4>
200ddd0: 84 10 20 01 mov 1, %g2
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 =
200ddd4: 11 00 00 20 sethi %hi(0x8000), %o0
200ddd8: 92 10 00 1b mov %i3, %o1
200dddc: 7f ff d2 57 call 2002738 <.udiv>
200dde0: 90 12 20 01 or %o0, 1, %o0
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
200dde4: 80 a2 00 16 cmp %o0, %l6
200dde8: 2a 80 00 08 bcs,a 200de08 <msdos_format+0x5a4>
200ddec: 84 10 20 04 mov 4, %g2
200ddf0: 03 00 00 3f sethi %hi(0xfc00), %g1
200ddf4: 82 10 63 f4 or %g1, 0x3f4, %g1 ! fff4 <PROM_START+0xfff4>
200ddf8: 80 a0 40 10 cmp %g1, %l0
200ddfc: 1a 80 00 03 bcc 200de08 <msdos_format+0x5a4>
200de00: 84 10 20 02 mov 2, %g2
{
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;
200de04: 84 10 20 04 mov 4, %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) {
200de08: 86 0e a0 ff and %i2, 0xff, %g3
200de0c: 82 08 a0 ff and %g2, 0xff, %g1
200de10: 80 a0 c0 01 cmp %g3, %g1
200de14: 02 80 00 19 be 200de78 <msdos_format+0x614>
200de18: 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 ) {
200de1c: 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
200de20: 82 10 20 1f mov 0x1f, %g1
200de24: 84 08 a0 ff and %g2, 0xff, %g2
200de28: 80 a0 a0 01 cmp %g2, 1
200de2c: 18 80 00 04 bgu 200de3c <msdos_format+0x5d8>
200de30: 86 10 20 01 mov 1, %g3
|| fmt_params->fattype == FAT_FAT16 ) {
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
200de34: 10 80 00 0c b 200de64 <msdos_format+0x600>
200de38: 82 10 20 02 mov 2, %g1
#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-- ) {
if ( (gigs & ( 1 << b) ) != 0 )
200de3c: c8 07 bd 40 ld [ %fp + -704 ], %g4
200de40: 85 28 c0 01 sll %g3, %g1, %g2
200de44: 80 88 80 04 btst %g2, %g4
200de48: 12 80 00 06 bne 200de60 <msdos_format+0x5fc>
200de4c: 84 10 20 01 mov 1, %g2
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-- ) {
200de50: 82 80 7f ff addcc %g1, -1, %g1
200de54: 12 bf ff fc bne 200de44 <msdos_format+0x5e0> <== ALWAYS TAKEN
200de58: 85 28 c0 01 sll %g3, %g1, %g2
if ( (gigs & ( 1 << b) ) != 0 )
break;
}
fmt_params->sectors_per_cluster = 1 << b;
200de5c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
200de60: 83 28 80 01 sll %g2, %g1, %g1
200de64: c2 27 bd b8 st %g1, [ %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,
200de68: 90 10 00 19 mov %i1, %o0
200de6c: 7f ff fe 5a call 200d7d4 <msdos_set_sectors_per_cluster_from_request>
200de70: 92 07 bd ac add %fp, -596, %o1
200de74: ba 10 00 08 mov %o0, %i5
fmt_params );
}
}
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
200de78: c2 0f bd de ldub [ %fp + -546 ], %g1
200de7c: 84 0e a0 ff and %i2, 0xff, %g2
200de80: 80 a0 80 01 cmp %g2, %g1
200de84: 02 80 00 07 be 200dea0 <msdos_format+0x63c>
200de88: 82 0d 20 ff and %l4, 0xff, %g1
200de8c: 80 a0 60 01 cmp %g1, 1
200de90: 08 80 00 04 bleu 200dea0 <msdos_format+0x63c>
200de94: c2 07 bd b0 ld [ %fp + -592 ], %g1
--fmt_params->totl_sector_cnt;
200de98: 82 00 7f ff add %g1, -1, %g1
200de9c: c2 27 bd b0 st %g1, [ %fp + -592 ]
}
}
++iteration_cnt;
200dea0: a8 05 20 01 inc %l4
if (ret_val == 0) {
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
200dea4: 80 a7 60 00 cmp %i5, 0
200dea8: 12 80 00 09 bne 200decc <msdos_format+0x668> <== NEVER TAKEN
200deac: c2 0f bd de ldub [ %fp + -546 ], %g1
&& fmt_params->fattype != fat_type
200deb0: b4 0e a0 ff and %i2, 0xff, %i2
200deb4: 80 a0 40 1a cmp %g1, %i2
200deb8: 02 80 00 05 be 200decc <msdos_format+0x668>
200debc: c2 07 bd b0 ld [ %fp + -592 ], %g1
&& fmt_params->totl_sector_cnt > 0 ) {
200dec0: 80 a0 60 00 cmp %g1, 0
200dec4: 12 bf ff 02 bne 200dacc <msdos_format+0x268> <== ALWAYS TAKEN
200dec8: c8 07 bd 48 ld [ %fp + -696 ], %g4
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
200decc: c2 07 bd b0 ld [ %fp + -592 ], %g1
200ded0: 80 a0 60 00 cmp %g1, 0
200ded4: 02 80 00 2f be 200df90 <msdos_format+0x72c> <== NEVER TAKEN
200ded8: 80 a7 60 00 cmp %i5, 0
{
errno = EINVAL;
ret_val = -1;
}
if (0 == ret_val)
200dedc: 12 80 00 34 bne 200dfac <msdos_format+0x748>
200dee0: c2 0f bd de ldub [ %fp + -546 ], %g1
{
if (FAT_FAT32 != fmt_params->fattype)
200dee4: 80 a0 60 04 cmp %g1, 4
200dee8: 02 80 00 0e be 200df20 <msdos_format+0x6bc>
200deec: 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)
200def0: c4 0f bd fc ldub [ %fp + -516 ], %g2
200def4: 80 a0 a0 00 cmp %g2, 0
200def8: 12 80 00 06 bne 200df10 <msdos_format+0x6ac>
200defc: c2 07 bd b8 ld [ %fp + -584 ], %g1
return (sectors + clustersize - 1) & ~(clustersize - 1);
200df00: 90 02 00 01 add %o0, %g1, %o0
200df04: 82 20 00 01 neg %g1
200df08: 90 02 3f ff add %o0, -1, %o0
200df0c: 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);
200df10: d2 07 bd ac ld [ %fp + -596 ], %o1
200df14: 7f ff d1 cf call 2002650 <.umul>
200df18: 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,
200df1c: 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)
200df20: c6 0f bd fc ldub [ %fp + -516 ], %g3
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment)
* (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
}
fmt_params->rsvd_sector_cnt = loc_align_object (fmt_params->rsvd_sector_cnt,
200df24: c2 07 bd b4 ld [ %fp + -588 ], %g1
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200df28: 80 a0 e0 00 cmp %g3, 0
200df2c: 12 80 00 06 bne 200df44 <msdos_format+0x6e0>
200df30: c4 07 bd b8 ld [ %fp + -584 ], %g2
return (sectors + clustersize - 1) & ~(clustersize - 1);
200df34: 82 00 40 02 add %g1, %g2, %g1
200df38: 84 20 00 02 neg %g2
200df3c: 82 00 7f ff add %g1, -1, %g1
200df40: 82 08 40 02 and %g1, %g2, %g1
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
200df44: 80 a6 60 00 cmp %i1, 0
200df48: 02 80 00 17 be 200dfa4 <msdos_format+0x740>
200df4c: c2 27 bd b4 st %g1, [ %fp + -588 ]
(rqdata->media != 0)) {
200df50: f6 0e 60 14 ldub [ %i1 + 0x14 ], %i3
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
200df54: b4 8e e0 ff andcc %i3, 0xff, %i2
200df58: 02 80 00 14 be 200dfa8 <msdos_format+0x744>
200df5c: 82 10 3f f8 mov -8, %g1
(rqdata->media != 0)) {
const char valid_media_codes[] =
200df60: 94 10 20 09 mov 9, %o2
200df64: 90 07 be 00 add %fp, -512, %o0
200df68: 13 00 80 ad sethi %hi(0x202b400), %o1
200df6c: 40 00 38 4f call 201c0a8 <memcpy>
200df70: 92 12 62 d0 or %o1, 0x2d0, %o1 ! 202b6d0 <_CPU_Trap_slot_template+0x188>
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
200df74: 90 07 be 00 add %fp, -512, %o0
200df78: 92 10 00 1a mov %i2, %o1
200df7c: 40 00 37 dd call 201bef0 <memchr>
200df80: 94 10 20 09 mov 9, %o2
200df84: 80 a2 20 00 cmp %o0, 0
200df88: 32 80 00 09 bne,a 200dfac <msdos_format+0x748> <== NEVER TAKEN
200df8c: f6 2f bd dd stb %i3, [ %fp + -547 ] <== NOT EXECUTED
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
200df90: 40 00 35 87 call 201b5ac <__errno>
200df94: ba 10 3f ff mov -1, %i5
200df98: 82 10 20 16 mov 0x16, %g1
200df9c: 10 80 00 04 b 200dfac <msdos_format+0x748>
200dfa0: c2 22 00 00 st %g1, [ %o0 ]
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
200dfa4: 82 10 3f f8 mov -8, %g1
200dfa8: c2 2f bd dd stb %g1, [ %fp + -547 ]
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
200dfac: f4 07 bd c8 ld [ %fp + -568 ], %i2
200dfb0: d0 0f bd dc ldub [ %fp + -548 ], %o0
200dfb4: 80 a6 a0 00 cmp %i2, 0
200dfb8: f6 07 bd b4 ld [ %fp + -588 ], %i3
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
200dfbc: 90 0a 20 ff and %o0, 0xff, %o0
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
200dfc0: 02 80 00 08 be 200dfe0 <msdos_format+0x77c>
200dfc4: 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);
200dfc8: 7f ff d1 a2 call 2002650 <.umul>
200dfcc: 01 00 00 00 nop
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
200dfd0: 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);
200dfd4: 90 02 00 1b add %o0, %i3, %o0
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
200dfd8: 10 80 00 08 b 200dff8 <msdos_format+0x794>
200dfdc: d0 27 bd cc st %o0, [ %fp + -564 ]
/*
* 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);
200dfe0: 7f ff d1 9c call 2002650 <.umul>
200dfe4: 01 00 00 00 nop
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
200dfe8: 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);
200dfec: 90 02 00 1b add %o0, %i3, %o0
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
200dff0: c2 27 bd d0 st %g1, [ %fp + -560 ]
}
else {
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
200dff4: 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) {
200dff8: 80 a7 60 00 cmp %i5, 0
200dffc: 12 80 00 48 bne 200e11c <msdos_format+0x8b8>
200e000: 80 a0 00 19 cmp %g0, %i1
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
200e004: 80 a6 60 00 cmp %i1, 0
200e008: 02 80 00 07 be 200e024 <msdos_format+0x7c0>
200e00c: 03 00 80 ad sethi %hi(0x202b400), %g1
(rqdata->OEMName != NULL)) {
200e010: c2 06 40 00 ld [ %i1 ], %g1
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
200e014: 80 a0 60 00 cmp %g1, 0
200e018: 32 80 00 05 bne,a 200e02c <msdos_format+0x7c8>
200e01c: 05 00 80 b4 sethi %hi(0x202d000), %g2
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
200e020: 03 00 80 ad sethi %hi(0x202b400), %g1
200e024: 82 10 61 88 or %g1, 0x188, %g1 ! 202b588 <_CPU_Trap_slot_template+0x40>
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
200e028: 05 00 80 b4 sethi %hi(0x202d000), %g2
200e02c: 86 10 20 09 mov 9, %g3
200e030: f4 00 a0 08 ld [ %g2 + 8 ], %i2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
200e034: b0 10 20 20 mov 0x20, %i0
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
200e038: 10 80 00 0f b 200e074 <msdos_format+0x810>
200e03c: 84 07 bd df add %fp, -545, %g2
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
200e040: 88 0e e0 ff and %i3, 0xff, %g4
200e044: 88 06 80 04 add %i2, %g4, %g4
200e048: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
200e04c: 80 89 20 97 btst 0x97, %g4
200e050: 02 80 00 06 be 200e068 <msdos_format+0x804>
200e054: 88 00 a0 01 add %g2, 1, %g4
*to++ = *from++;
200e058: f6 28 80 00 stb %i3, [ %g2 ]
200e05c: 82 00 60 01 inc %g1
200e060: 10 80 00 04 b 200e070 <msdos_format+0x80c>
200e064: 84 10 00 04 mov %g4, %g2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
200e068: f0 28 80 00 stb %i0, [ %g2 ]
200e06c: 84 10 00 04 mov %g4, %g2
}
*to = '\0';
200e070: c0 29 00 00 clrb [ %g4 ]
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
200e074: 86 80 ff ff addcc %g3, -1, %g3
200e078: 32 bf ff f2 bne,a 200e040 <msdos_format+0x7dc>
200e07c: f6 08 40 00 ldub [ %g1 ], %i3
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
200e080: 10 80 01 b6 b 200e758 <msdos_format+0xef4>
200e084: 80 a6 60 00 cmp %i1, 0
200e088: 80 a0 60 00 cmp %g1, 0
200e08c: 22 80 00 05 be,a 200e0a0 <msdos_format+0x83c>
200e090: 03 00 80 aa sethi %hi(0x202a800), %g1
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
200e094: 84 10 20 01 mov 1, %g2
200e098: 10 80 00 03 b 200e0a4 <msdos_format+0x840>
200e09c: c4 2f bd f4 stb %g2, [ %fp + -524 ]
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
200e0a0: 82 10 63 f8 or %g1, 0x3f8, %g1
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
200e0a4: 05 00 80 b4 sethi %hi(0x202d000), %g2
200e0a8: 86 10 20 0c mov 0xc, %g3
200e0ac: f4 00 a0 08 ld [ %g2 + 8 ], %i2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
200e0b0: b0 10 20 20 mov 0x20, %i0
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
200e0b4: 10 80 00 0f b 200e0f0 <msdos_format+0x88c>
200e0b8: 84 07 bd e8 add %fp, -536, %g2
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
200e0bc: 88 0e e0 ff and %i3, 0xff, %g4
200e0c0: 88 06 80 04 add %i2, %g4, %g4
200e0c4: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
200e0c8: 80 89 20 97 btst 0x97, %g4
200e0cc: 02 80 00 06 be 200e0e4 <msdos_format+0x880>
200e0d0: 88 00 a0 01 add %g2, 1, %g4
*to++ = *from++;
200e0d4: f6 28 80 00 stb %i3, [ %g2 ]
200e0d8: 82 00 60 01 inc %g1
200e0dc: 10 80 00 04 b 200e0ec <msdos_format+0x888>
200e0e0: 84 10 00 04 mov %g4, %g2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
200e0e4: f0 28 80 00 stb %i0, [ %g2 ]
200e0e8: 84 10 00 04 mov %g4, %g2
}
*to = '\0';
200e0ec: c0 29 00 00 clrb [ %g4 ]
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
200e0f0: 86 80 ff ff addcc %g3, -1, %g3
200e0f4: 32 bf ff f2 bne,a 200e0bc <msdos_format+0x858>
200e0f8: f6 08 40 00 ldub [ %g1 ], %i3
200e0fc: 30 80 01 9b b,a 200e768 <msdos_format+0xf04>
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
if (rc == RTEMS_SUCCESSFUL) {
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
200e100: 83 28 60 01 sll %g1, 1, %g1 <== NOT EXECUTED
200e104: 10 80 00 05 b 200e118 <msdos_format+0x8b4> <== NOT EXECUTED
200e108: c2 27 bd f8 st %g1, [ %fp + -520 ] <== NOT EXECUTED
}
else {
*volid_ptr = rand();
200e10c: 40 00 3a af call 201cbc8 <rand>
200e110: 01 00 00 00 nop
200e114: d0 27 bd f8 st %o0, [ %fp + -520 ]
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
200e118: 80 a0 00 19 cmp %g0, %i1
200e11c: b4 40 20 00 addx %g0, 0, %i2
ret_val = msdos_format_determine_fmt_params(fd,rqdata,&fmt_params);
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
200e120: 80 a7 60 00 cmp %i5, 0
200e124: 12 80 01 5f bne 200e6a0 <msdos_format+0xe3c>
200e128: b0 10 00 1d mov %i5, %i0
200e12c: 80 8e a0 ff btst 0xff, %i2
200e130: 02 80 00 1d be 200e1a4 <msdos_format+0x940>
200e134: 80 a7 60 00 cmp %i5, 0
(rqdata != NULL) &&
200e138: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
200e13c: 80 a0 60 00 cmp %g1, 0
200e140: 02 80 00 11 be 200e184 <msdos_format+0x920>
200e144: 90 10 00 19 mov %i1, %o0
*/
if (ret_val == 0) {
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e148: 92 10 20 02 mov 2, %o1
200e14c: 15 00 80 ad sethi %hi(0x202b400), %o2
200e150: 7f ff fd 29 call 200d5f4 <msdos_format_printf>
200e154: 94 12 a2 40 or %o2, 0x240, %o2 ! 202b640 <_CPU_Trap_slot_template+0xf8>
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
200e158: 90 10 00 1c mov %i4, %o0
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"read MRB sector\n");
ret_val = msdos_format_read_sec(fd,
200e15c: 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)) {
200e160: 92 10 20 00 clr %o1
200e164: 94 10 20 00 clr %o2
200e168: 40 00 1a 4d call 2014a9c <lseek>
200e16c: 96 10 20 00 clr %o3
200e170: 80 a2 20 00 cmp %o0, 0
200e174: 16 80 01 83 bge 200e780 <msdos_format+0xf1c> <== ALWAYS TAKEN
200e178: 90 10 00 1c mov %i4, %o0
}
}
if ( fmt_params->totl_sector_cnt == 0 )
{
errno = EINVAL;
ret_val = -1;
200e17c: 10 80 01 89 b 200e7a0 <msdos_format+0xf3c> <== NOT EXECUTED
200e180: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
200e184: d6 07 bd b0 ld [ %fp + -592 ], %o3
200e188: d8 07 bd ac ld [ %fp + -596 ], %o4
200e18c: 92 10 00 1c mov %i4, %o1
200e190: 94 10 20 00 clr %o2
200e194: 7f ff fd 45 call 200d6a8 <msdos_format_fill_sectors>
200e198: 9a 10 3f e5 mov -27, %o5
200e19c: ba 10 00 08 mov %o0, %i5
}
/*
* create master boot record
*/
if (ret_val == 0) {
200e1a0: 80 a7 60 00 cmp %i5, 0
200e1a4: 12 80 01 3f bne 200e6a0 <msdos_format+0xe3c> <== NEVER TAKEN
200e1a8: b0 10 00 1d mov %i5, %i0
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e1ac: 10 bf ff e7 b 200e148 <msdos_format+0x8e4>
200e1b0: 90 10 00 19 mov %i1, %o0
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
200e1b4: ba 10 20 00 clr %i5
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
200e1b8: 92 10 20 00 clr %o1
200e1bc: 94 10 21 be mov 0x1be, %o2
200e1c0: 40 00 37 f7 call 201c19c <memset>
200e1c4: 90 07 be 00 add %fp, -512, %o0
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
200e1c8: 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,
200e1cc: c0 37 bf fe clrh [ %fp + -2 ]
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
200e1d0: 92 07 bd df add %fp, -545, %o1
200e1d4: 40 00 37 b5 call 201c0a8 <memcpy>
200e1d8: 94 10 20 08 mov 8, %o2
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
200e1dc: c2 07 bd ac ld [ %fp + -596 ], %g1
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
200e1e0: 05 00 00 3f sethi %hi(0xfc00), %g2
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
200e1e4: c2 2f be 0b stb %g1, [ %fp + -501 ]
200e1e8: 83 30 60 08 srl %g1, 8, %g1
200e1ec: c2 2f be 0c stb %g1, [ %fp + -500 ]
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
200e1f0: c2 07 bd b8 ld [ %fp + -584 ], %g1
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
200e1f4: 84 10 a3 ff or %g2, 0x3ff, %g2
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
200e1f8: c2 2f be 0d stb %g1, [ %fp + -499 ]
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
200e1fc: c2 07 bd b4 ld [ %fp + -588 ], %g1
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
200e200: fa 2f be 20 stb %i5, [ %fp + -480 ]
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
200e204: c2 2f be 0e stb %g1, [ %fp + -498 ]
200e208: 83 30 60 08 srl %g1, 8, %g1
200e20c: c2 2f be 0f stb %g1, [ %fp + -497 ]
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
200e210: c2 07 bd c4 ld [ %fp + -572 ], %g1
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
200e214: 88 10 20 02 mov 2, %g4
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
200e218: c2 2f be 11 stb %g1, [ %fp + -495 ]
200e21c: 83 30 60 08 srl %g1, 8, %g1
200e220: 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);
200e224: c2 0f bd dd ldub [ %fp + -547 ], %g1
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
200e228: f6 2f be 13 stb %i3, [ %fp + -493 ]
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
200e22c: c2 2f be 15 stb %g1, [ %fp + -491 ]
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
200e230: 82 10 3f ff mov -1, %g1
200e234: c2 2f be 18 stb %g1, [ %fp + -488 ]
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
200e238: 82 10 20 06 mov 6, %g1
200e23c: c2 2f be 1a stb %g1, [ %fp + -486 ]
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
200e240: 82 0f 40 02 and %i5, %g2, %g1
200e244: 83 30 60 08 srl %g1, 8, %g1
200e248: c2 2f be 21 stb %g1, [ %fp + -479 ]
200e24c: 83 37 60 10 srl %i5, 0x10, %g1
200e250: bb 37 60 18 srl %i5, 0x18, %i5
200e254: fa 2f be 23 stb %i5, [ %fp + -477 ]
if (fmt_params->fattype != FAT_FAT32) {
200e258: fa 0f bd de ldub [ %fp + -546 ], %i5
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
200e25c: b7 36 e0 08 srl %i3, 8, %i3
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... */
200e260: 86 10 20 01 mov 1, %g3
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
200e264: c2 2f be 22 stb %g1, [ %fp + -478 ]
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
200e268: c8 2f be 10 stb %g4, [ %fp + -496 ]
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
200e26c: f6 2f be 14 stb %i3, [ %fp + -492 ]
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
200e270: c6 2f be 1c stb %g3, [ %fp + -484 ]
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
200e274: 80 a7 60 04 cmp %i5, 4
200e278: 02 80 00 1c be 200e2e8 <msdos_format+0xa84>
200e27c: c2 07 bd bc ld [ %fp + -580 ], %g1
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
200e280: c2 2f be 16 stb %g1, [ %fp + -490 ]
200e284: 83 30 60 08 srl %g1, 8, %g1
200e288: c2 2f be 17 stb %g1, [ %fp + -489 ]
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
200e28c: 82 10 20 29 mov 0x29, %g1
200e290: c2 2f be 26 stb %g1, [ %fp + -474 ]
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
200e294: c2 07 bd f8 ld [ %fp + -520 ], %g1
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
200e298: 92 07 bd e8 add %fp, -536, %o1
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
200e29c: 84 08 40 02 and %g1, %g2, %g2
200e2a0: 85 30 a0 08 srl %g2, 8, %g2
200e2a4: c2 2f be 27 stb %g1, [ %fp + -473 ]
200e2a8: c4 2f be 28 stb %g2, [ %fp + -472 ]
200e2ac: 85 30 60 10 srl %g1, 0x10, %g2
200e2b0: 83 30 60 18 srl %g1, 0x18, %g1
200e2b4: c4 2f be 29 stb %g2, [ %fp + -471 ]
200e2b8: c2 2f be 2a stb %g1, [ %fp + -470 ]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
200e2bc: 90 07 be 2b add %fp, -469, %o0
200e2c0: 40 00 37 7a call 201c0a8 <memcpy>
200e2c4: 94 10 20 0b mov 0xb, %o2
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
200e2c8: 13 00 80 ad sethi %hi(0x202b400), %o1
200e2cc: 80 a7 60 01 cmp %i5, 1
200e2d0: 12 80 00 04 bne 200e2e0 <msdos_format+0xa7c>
200e2d4: 92 12 61 a0 or %o1, 0x1a0, %o1
200e2d8: 13 00 80 ad sethi %hi(0x202b400), %o1
200e2dc: 92 12 61 90 or %o1, 0x190, %o1 ! 202b590 <_CPU_Trap_slot_template+0x48>
200e2e0: 10 80 00 1d b 200e354 <msdos_format+0xaf0>
200e2e4: 90 07 be 36 add %fp, -458, %o0
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
200e2e8: 84 08 40 02 and %g1, %g2, %g2
200e2ec: 85 30 a0 08 srl %g2, 8, %g2
200e2f0: c2 2f be 24 stb %g1, [ %fp + -476 ]
200e2f4: c4 2f be 25 stb %g2, [ %fp + -475 ]
200e2f8: 85 30 60 10 srl %g1, 0x10, %g2
200e2fc: 83 30 60 18 srl %g1, 0x18, %g1
200e300: c2 2f be 27 stb %g1, [ %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 */
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 */
200e304: c2 07 bd d4 ld [ %fp + -556 ], %g1
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
200e308: c4 2f be 26 stb %g2, [ %fp + -474 ]
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 */
200e30c: c2 2f be 32 stb %g1, [ %fp + -462 ]
200e310: 83 30 60 08 srl %g1, 8, %g1
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
200e314: c8 2f be 2c stb %g4, [ %fp + -468 ]
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
200e318: c6 2f be 30 stb %g3, [ %fp + -464 ]
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
200e31c: c2 2f be 33 stb %g1, [ %fp + -461 ]
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
200e320: 92 10 20 00 clr %o1
200e324: 94 10 20 0c mov 0xc, %o2
200e328: 40 00 37 9d call 201c19c <memset>
200e32c: 90 07 be 34 add %fp, -460, %o0
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);
200e330: 82 10 20 29 mov 0x29, %g1
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
200e334: 92 10 20 00 clr %o1
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);
200e338: 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);
200e33c: 90 07 be 47 add %fp, -441, %o0
200e340: 40 00 37 97 call 201c19c <memset>
200e344: 94 10 20 0b mov 0xb, %o2
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
200e348: 13 00 80 ad sethi %hi(0x202b400), %o1
200e34c: 90 07 be 52 add %fp, -430, %o0
200e350: 92 12 62 58 or %o1, 0x258, %o1
200e354: 40 00 37 55 call 201c0a8 <memcpy>
200e358: 94 10 20 08 mov 8, %o2
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
200e35c: 82 10 20 55 mov 0x55, %g1
200e360: c2 2f bf fe stb %g1, [ %fp + -2 ]
200e364: 82 10 3f aa mov -86, %g1
200e368: c2 2f bf ff stb %g1, [ %fp + -1 ]
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
200e36c: 82 10 3f eb mov -21, %g1
200e370: c2 2f be 00 stb %g1, [ %fp + -512 ]
FAT_SET_VAL8(mbr,1,0x3c);
200e374: 82 10 20 3c mov 0x3c, %g1
200e378: c2 2f be 01 stb %g1, [ %fp + -511 ]
FAT_SET_VAL8(mbr,2,0x90);
200e37c: 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,
200e380: 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);
200e384: 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,
200e388: 92 10 20 02 mov 2, %o1
200e38c: 15 00 80 ad sethi %hi(0x202b400), %o2
200e390: 7f ff fc 99 call 200d5f4 <msdos_format_printf>
200e394: 94 12 a2 68 or %o2, 0x268, %o2 ! 202b668 <_CPU_Trap_slot_template+0x120>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
200e398: d4 07 bd ac ld [ %fp + -596 ], %o2
200e39c: 90 10 00 1c mov %i4, %o0
200e3a0: 92 10 20 00 clr %o1
200e3a4: 7f ff fc a9 call 200d648 <msdos_format_write_sec>
200e3a8: 96 07 be 00 add %fp, -512, %o3
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
200e3ac: ba 92 20 00 orcc %o0, 0, %i5
200e3b0: 12 80 00 fc bne 200e7a0 <msdos_format+0xf3c> <== NEVER TAKEN
200e3b4: c2 07 bd d4 ld [ %fp + -556 ], %g1
200e3b8: 80 a0 60 00 cmp %g1, 0
200e3bc: 12 80 00 08 bne 200e3dc <msdos_format+0xb78>
200e3c0: 90 10 00 19 mov %i1, %o0
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
200e3c4: fa 07 bd d8 ld [ %fp + -552 ], %i5
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
200e3c8: 80 a7 60 00 cmp %i5, 0
200e3cc: 22 80 00 37 be,a 200e4a8 <msdos_format+0xc44>
200e3d0: d2 07 bd bc ld [ %fp + -580 ], %o1
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
200e3d4: 10 80 00 10 b 200e414 <msdos_format+0xbb0>
200e3d8: 92 10 20 00 clr %o1
if ((ret_val == 0) &&
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e3dc: 92 10 20 02 mov 2, %o1
200e3e0: 15 00 80 ad sethi %hi(0x202b400), %o2
200e3e4: 7f ff fc 84 call 200d5f4 <msdos_format_printf>
200e3e8: 94 12 a2 80 or %o2, 0x280, %o2 ! 202b680 <_CPU_Trap_slot_template+0x138>
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
200e3ec: d2 07 bd d4 ld [ %fp + -556 ], %o1
200e3f0: d4 07 bd ac ld [ %fp + -596 ], %o2
200e3f4: 90 10 00 1c mov %i4, %o0
200e3f8: 7f ff fc 94 call 200d648 <msdos_format_write_sec>
200e3fc: 96 07 be 00 add %fp, -512, %o3
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
200e400: ba 92 20 00 orcc %o0, 0, %i5
200e404: 22 bf ff f1 be,a 200e3c8 <msdos_format+0xb64> <== ALWAYS TAKEN
200e408: fa 07 bd d8 ld [ %fp + -552 ], %i5
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
200e40c: 10 80 00 a5 b 200e6a0 <msdos_format+0xe3c> <== NOT EXECUTED
200e410: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
200e414: 94 10 22 00 mov 0x200, %o2
200e418: 40 00 37 61 call 201c19c <memset>
200e41c: 90 07 be 00 add %fp, -512, %o0
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
200e420: 82 10 20 52 mov 0x52, %g1
200e424: c2 2f be 00 stb %g1, [ %fp + -512 ]
200e428: c2 2f be 01 stb %g1, [ %fp + -511 ]
200e42c: 82 10 20 61 mov 0x61, %g1
200e430: c2 2f be 02 stb %g1, [ %fp + -510 ]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
200e434: c2 2f bf e7 stb %g1, [ %fp + -25 ]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
200e438: 82 10 20 55 mov 0x55, %g1
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
200e43c: d4 07 bd ac ld [ %fp + -596 ], %o2
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
200e440: c2 2f bf fe stb %g1, [ %fp + -2 ]
200e444: 82 10 3f aa mov -86, %g1
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
200e448: 84 10 20 41 mov 0x41, %g2
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
200e44c: 86 10 20 72 mov 0x72, %g3
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
200e450: c2 2f bf ff stb %g1, [ %fp + -1 ]
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
200e454: 82 10 3f ff mov -1, %g1
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
200e458: 92 10 00 1d mov %i5, %o1
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
200e45c: c4 2f be 03 stb %g2, [ %fp + -509 ]
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
200e460: c6 2f bf e4 stb %g3, [ %fp + -28 ]
200e464: c6 2f bf e5 stb %g3, [ %fp + -27 ]
200e468: c4 2f bf e6 stb %g2, [ %fp + -26 ]
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
200e46c: c2 2f bf e8 stb %g1, [ %fp + -24 ]
200e470: c2 2f bf e9 stb %g1, [ %fp + -23 ]
200e474: c2 2f bf ea stb %g1, [ %fp + -22 ]
200e478: c2 2f bf eb stb %g1, [ %fp + -21 ]
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
200e47c: c2 2f bf ec stb %g1, [ %fp + -20 ]
200e480: c2 2f bf ed stb %g1, [ %fp + -19 ]
200e484: c2 2f bf ee stb %g1, [ %fp + -18 ]
200e488: 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,
200e48c: 90 10 00 1c mov %i4, %o0
200e490: 7f ff fc 6e call 200d648 <msdos_format_write_sec>
200e494: 96 07 be 00 add %fp, -512, %o3
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
200e498: ba 92 20 00 orcc %o0, 0, %i5
200e49c: 12 80 00 81 bne 200e6a0 <msdos_format+0xe3c> <== NEVER TAKEN
200e4a0: b0 10 00 1d mov %i5, %i0
ret_val = msdos_format_fill_sectors
(rqdata,
200e4a4: d2 07 bd bc ld [ %fp + -580 ], %o1
200e4a8: d0 0f bd dc ldub [ %fp + -548 ], %o0
200e4ac: 7f ff d0 69 call 2002650 <.umul>
200e4b0: 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
200e4b4: d8 07 bd ac ld [ %fp + -596 ], %o4
(rqdata,
200e4b8: 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
200e4bc: 94 10 00 1d mov %i5, %o2
200e4c0: 90 10 00 19 mov %i1, %o0
200e4c4: 92 10 00 1c mov %i4, %o1
200e4c8: 7f ff fc 78 call 200d6a8 <msdos_format_fill_sectors>
200e4cc: 9a 10 20 00 clr %o5
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
200e4d0: ba 92 20 00 orcc %o0, 0, %i5
200e4d4: 12 80 00 b3 bne 200e7a0 <msdos_format+0xf3c> <== NEVER TAKEN
200e4d8: d4 07 bd cc ld [ %fp + -564 ], %o2
ret_val = msdos_format_fill_sectors
200e4dc: d6 07 bd d0 ld [ %fp + -560 ], %o3
200e4e0: d8 07 bd ac ld [ %fp + -596 ], %o4
200e4e4: 90 10 00 19 mov %i1, %o0
200e4e8: 92 10 00 1c mov %i4, %o1
200e4ec: 7f ff fc 6f call 200d6a8 <msdos_format_fill_sectors>
200e4f0: 9a 10 20 00 clr %o5
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
200e4f4: ba 92 20 00 orcc %o0, 0, %i5
200e4f8: 12 80 00 aa bne 200e7a0 <msdos_format+0xf3c> <== NEVER TAKEN
200e4fc: c2 0f bd f4 ldub [ %fp + -524 ], %g1
200e500: 80 a0 60 00 cmp %g1, 0
200e504: 12 80 00 0f bne 200e540 <msdos_format+0xcdc>
200e508: 90 07 be 00 add %fp, -512, %o0
uint32_t start_sector;
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
200e50c: 92 10 20 00 clr %o1
200e510: 40 00 37 23 call 201c19c <memset>
200e514: 94 10 22 00 mov 0x200, %o2
switch(fmt_params.fattype) {
200e518: c2 0f bd de ldub [ %fp + -546 ], %g1
200e51c: 80 a0 60 02 cmp %g1, 2
200e520: 02 80 00 21 be 200e5a4 <msdos_format+0xd40>
200e524: 80 a0 60 04 cmp %g1, 4
200e528: 02 80 00 27 be 200e5c4 <msdos_format+0xd60>
200e52c: 80 a0 60 01 cmp %g1, 1
200e530: 12 80 00 32 bne 200e5f8 <msdos_format+0xd94> <== NEVER TAKEN
200e534: c2 0f bd dd ldub [ %fp + -547 ], %g1
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
200e538: 10 80 00 16 b 200e590 <msdos_format+0xd2c>
200e53c: c2 2f be 00 stb %g1, [ %fp + -512 ]
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
200e540: 92 10 20 00 clr %o1
200e544: 94 10 22 00 mov 0x200, %o2
200e548: 40 00 37 15 call 201c19c <memset>
200e54c: 90 07 be 00 add %fp, -512, %o0
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
200e550: 92 07 bd e8 add %fp, -536, %o1
200e554: 94 10 20 0b mov 0xb, %o2
200e558: 40 00 36 d4 call 201c0a8 <memcpy>
200e55c: 90 07 be 00 add %fp, -512, %o0
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
200e560: d2 07 bd cc ld [ %fp + -564 ], %o1
200e564: 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);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
200e568: 82 10 20 08 mov 8, %g1
ret_val = msdos_format_write_sec
200e56c: 90 10 00 1c mov %i4, %o0
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
200e570: c2 2f be 0b stb %g1, [ %fp + -501 ]
ret_val = msdos_format_write_sec
200e574: 7f ff fc 35 call 200d648 <msdos_format_write_sec>
200e578: 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) {
200e57c: b0 92 20 00 orcc %o0, 0, %i0
200e580: 12 80 00 49 bne 200e6a4 <msdos_format+0xe40> <== NEVER TAKEN
200e584: 80 a6 20 00 cmp %i0, 0
uint32_t start_sector;
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
200e588: 10 bf ff e1 b 200e50c <msdos_format+0xca8>
200e58c: 90 07 be 00 add %fp, -512, %o0
switch(fmt_params.fattype) {
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
/* 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)));
200e590: 82 10 3f 8f mov -113, %g1
200e594: 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));
200e598: 82 10 3f ff mov -1, %g1
break;
200e59c: 10 80 00 1b b 200e608 <msdos_format+0xda4>
200e5a0: c2 2f be 02 stb %g1, [ %fp + -510 ]
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
200e5a4: c2 0f bd dd ldub [ %fp + -547 ], %g1
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
200e5a8: 84 10 3f f8 mov -8, %g2
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);
200e5ac: c2 2f be 00 stb %g1, [ %fp + -512 ]
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
200e5b0: c4 2f be 02 stb %g2, [ %fp + -510 ]
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
FAT_SET_VAL8(tmp_sec,1,0xff);
200e5b4: 82 10 3f ff mov -1, %g1
200e5b8: c2 2f be 01 stb %g1, [ %fp + -511 ]
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
200e5bc: 10 80 00 13 b 200e608 <msdos_format+0xda4>
200e5c0: c2 2f be 03 stb %g1, [ %fp + -509 ]
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
200e5c4: c2 0f bd dd ldub [ %fp + -547 ], %g1
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
200e5c8: 84 10 3f f8 mov -8, %g2
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);
200e5cc: c2 2f be 00 stb %g1, [ %fp + -512 ]
200e5d0: 82 10 3f ff mov -1, %g1
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
200e5d4: c4 2f be 04 stb %g2, [ %fp + -508 ]
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);
200e5d8: c2 2f be 01 stb %g1, [ %fp + -511 ]
200e5dc: c2 2f be 02 stb %g1, [ %fp + -510 ]
200e5e0: c2 2f be 03 stb %g1, [ %fp + -509 ]
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
200e5e4: c2 2f be 05 stb %g1, [ %fp + -507 ]
200e5e8: c2 2f be 06 stb %g1, [ %fp + -506 ]
200e5ec: 82 10 20 0f mov 0xf, %g1
break;
200e5f0: 10 80 00 06 b 200e608 <msdos_format+0xda4>
200e5f4: c2 2f be 07 stb %g1, [ %fp + -505 ]
default:
ret_val = -1;
errno = EINVAL;
200e5f8: 40 00 33 ed call 201b5ac <__errno> <== NOT EXECUTED
200e5fc: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
200e600: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200e604: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
200e608: c2 0f bd de ldub [ %fp + -546 ], %g1
200e60c: 80 a0 60 04 cmp %g1, 4
200e610: 12 80 00 0a bne 200e638 <msdos_format+0xdd4>
200e614: c4 0f bd fc ldub [ %fp + -516 ], %g2
/*
* 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);
200e618: 82 10 3f f8 mov -8, %g1
200e61c: c2 2f be 08 stb %g1, [ %fp + -504 ]
200e620: 82 10 3f ff mov -1, %g1
200e624: c2 2f be 09 stb %g1, [ %fp + -503 ]
200e628: c2 2f be 0a stb %g1, [ %fp + -502 ]
200e62c: 82 10 20 0f mov 0xf, %g1
200e630: c2 2f be 0b stb %g1, [ %fp + -501 ]
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200e634: c4 0f bd fc ldub [ %fp + -516 ], %g2
* 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,
200e638: f6 07 bd b4 ld [ %fp + -588 ], %i3
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
200e63c: 80 a0 a0 00 cmp %g2, 0
200e640: 12 80 00 06 bne 200e658 <msdos_format+0xdf4>
200e644: c2 07 bd b8 ld [ %fp + -584 ], %g1
return (sectors + clustersize - 1) & ~(clustersize - 1);
200e648: b6 06 c0 01 add %i3, %g1, %i3
200e64c: 82 20 00 01 neg %g1
200e650: b6 06 ff ff add %i3, -1, %i3
200e654: b6 0e c0 01 and %i3, %g1, %i3
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
200e658: b0 10 00 1d mov %i5, %i0
200e65c: 10 80 00 0b b 200e688 <msdos_format+0xe24>
200e660: ba 10 20 00 clr %i5
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
(fd,
start_sector
+ (i * fmt_params.sectors_per_fat),
200e664: 7f ff cf fb call 2002650 <.umul>
200e668: 90 10 00 1d mov %i5, %o0
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
200e66c: d4 07 bd ac ld [ %fp + -596 ], %o2
(fd,
200e670: 92 02 00 1b add %o0, %i3, %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
200e674: 96 07 be 00 add %fp, -512, %o3
200e678: 90 10 00 1c mov %i4, %o0
200e67c: 7f ff fb f3 call 200d648 <msdos_format_write_sec>
200e680: ba 07 60 01 inc %i5
200e684: b0 10 00 08 mov %o0, %i0
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);
200e688: c2 0f bd dc ldub [ %fp + -548 ], %g1
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
200e68c: 80 a7 40 01 cmp %i5, %g1
200e690: 16 80 00 04 bge 200e6a0 <msdos_format+0xe3c>
200e694: 80 a6 20 00 cmp %i0, 0
(i < fmt_params.fat_num) && (ret_val == 0);
200e698: 02 bf ff f3 be 200e664 <msdos_format+0xe00> <== ALWAYS TAKEN
200e69c: d2 07 bd bc ld [ %fp + -580 ], %o1
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
200e6a0: 80 a6 20 00 cmp %i0, 0
200e6a4: 12 80 00 0f bne 200e6e0 <msdos_format+0xe7c>
200e6a8: 80 a7 3f ff cmp %i4, -1
200e6ac: 80 8e a0 ff btst 0xff, %i2
200e6b0: 02 80 00 0c be 200e6e0 <msdos_format+0xe7c>
200e6b4: 80 a7 3f ff cmp %i4, -1
200e6b8: c2 0e 60 17 ldub [ %i1 + 0x17 ], %g1
200e6bc: 80 a0 60 00 cmp %g1, 0
200e6c0: 02 80 00 08 be 200e6e0 <msdos_format+0xe7c>
200e6c4: 80 a7 3f ff cmp %i4, -1
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
}
static inline int rtems_disk_fd_sync(int fd)
{
return ioctl(fd, RTEMS_BLKIO_SYNCDEV);
200e6c8: 90 10 00 1c mov %i4, %o0
200e6cc: 13 08 00 10 sethi %hi(0x20004000), %o1
200e6d0: 40 00 18 d2 call 2014a18 <ioctl>
200e6d4: 92 12 62 06 or %o1, 0x206, %o1 ! 20004206 <RAM_END+0x1dc04206>
200e6d8: b0 10 00 08 mov %o0, %i0
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
200e6dc: 80 a7 3f ff cmp %i4, -1
200e6e0: 02 80 00 40 be 200e7e0 <msdos_format+0xf7c> <== NEVER TAKEN
200e6e4: 01 00 00 00 nop
close(fd);
200e6e8: 7f ff da 5e call 2005060 <close>
200e6ec: 90 10 00 1c mov %i4, %o0
200e6f0: 81 c7 e0 08 ret
200e6f4: 81 e8 00 00 restore
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));
200e6f8: 94 10 20 54 mov 0x54, %o2
200e6fc: 40 00 36 a8 call 201c19c <memset>
200e700: 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);
200e704: 90 10 00 1c mov %i4, %o0
200e708: 37 10 01 10 sethi %hi(0x40044000), %i3
200e70c: 94 07 bd ac add %fp, -596, %o2
200e710: 40 00 18 c2 call 2014a18 <ioctl>
200e714: 92 16 e2 02 or %i3, 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) {
200e718: ba 92 20 00 orcc %o0, 0, %i5
200e71c: 12 bf fd ed bne 200ded0 <msdos_format+0x66c> <== NEVER TAKEN
200e720: c2 07 bd b0 ld [ %fp + -592 ], %g1
static inline int rtems_disk_fd_get_block_count(
int fd,
rtems_blkdev_bnum *block_count
)
{
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
200e724: 10 bf fc 7f b 200d920 <msdos_format+0xbc>
200e728: 90 10 00 1c mov %i4, %o0
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e72c: d6 0f bd dc ldub [ %fp + -548 ], %o3
200e730: 90 10 00 19 mov %i1, %o0
200e734: 92 10 20 02 mov 2, %o1
200e738: 15 00 80 ad sethi %hi(0x202b400), %o2
200e73c: 7f ff fb ae call 200d5f4 <msdos_format_printf>
200e740: 94 12 a2 a0 or %o2, 0x2a0, %o2 ! 202b6a0 <_CPU_Trap_slot_template+0x158>
* 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) {
200e744: 80 a6 60 00 cmp %i1, 0
200e748: 32 bf fc 9e bne,a 200d9c0 <msdos_format+0x15c>
200e74c: c2 06 60 08 ld [ %i1 + 8 ], %g1
* 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;
200e750: 10 bf fc a0 b 200d9d0 <msdos_format+0x16c>
200e754: 84 10 20 20 mov 0x20, %g2
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
200e758: 32 bf fe 4c bne,a 200e088 <msdos_format+0x824>
200e75c: c2 06 60 04 ld [ %i1 + 4 ], %g1
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
200e760: 10 bf fe 50 b 200e0a0 <msdos_format+0x83c>
200e764: 03 00 80 aa sethi %hi(0x202a800), %g1
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
200e768: 40 00 1c b0 call 2015a28 <rtems_clock_get_tod_timeval>
200e76c: 90 07 be 00 add %fp, -512, %o0
if (rc == RTEMS_SUCCESSFUL) {
200e770: 80 a2 20 00 cmp %o0, 0
200e774: 02 bf fe 63 be 200e100 <msdos_format+0x89c> <== NEVER TAKEN
200e778: c2 07 be 00 ld [ %fp + -512 ], %g1
200e77c: 30 bf fe 64 b,a 200e10c <msdos_format+0x8a8>
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
200e780: 92 07 be 00 add %fp, -512, %o1
200e784: 40 00 19 8f call 2014dc0 <read>
200e788: 94 10 00 1d mov %i5, %o2
200e78c: 80 a2 20 00 cmp %o0, 0
200e790: 16 80 00 08 bge 200e7b0 <msdos_format+0xf4c> <== ALWAYS TAKEN
200e794: 90 10 00 19 mov %i1, %o0
}
}
if ( fmt_params->totl_sector_cnt == 0 )
{
errno = EINVAL;
ret_val = -1;
200e798: 10 80 00 04 b 200e7a8 <msdos_format+0xf44> <== NOT EXECUTED
200e79c: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
200e7a0: 10 bf ff c0 b 200e6a0 <msdos_format+0xe3c> <== NOT EXECUTED
200e7a4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
200e7a8: 10 bf ff be b 200e6a0 <msdos_format+0xe3c> <== NOT EXECUTED
200e7ac: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
ret_val = msdos_format_read_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200e7b0: 92 10 20 02 mov 2, %o1
200e7b4: 15 00 80 ad sethi %hi(0x202b400), %o2
200e7b8: 7f ff fb 8f call 200d5f4 <msdos_format_printf>
200e7bc: 94 12 a2 b8 or %o2, 0x2b8, %o2 ! 202b6b8 <_CPU_Trap_slot_template+0x170>
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
200e7c0: fa 07 bd b0 ld [ %fp + -592 ], %i5
200e7c4: 03 00 00 3f sethi %hi(0xfc00), %g1
200e7c8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
200e7cc: 80 a7 40 01 cmp %i5, %g1
200e7d0: 18 bf fe 7a bgu 200e1b8 <msdos_format+0x954>
200e7d4: b6 10 20 00 clr %i3
200e7d8: 10 bf fe 77 b 200e1b4 <msdos_format+0x950>
200e7dc: b6 10 00 1d mov %i5, %i3
if (fd != -1) {
close(fd);
}
return ret_val;
}
200e7e0: 81 c7 e0 08 ret <== NOT EXECUTED
200e7e4: 81 e8 00 00 restore <== NOT EXECUTED
0200d6a8 <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
200d6a8: 9d e3 bf a0 save %sp, -96, %sp
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
200d6ac: 7f ff e0 74 call 200587c <malloc>
200d6b0: 90 10 00 1c mov %i4, %o0
if (fill_buffer == NULL) {
200d6b4: a0 92 20 00 orcc %o0, 0, %l0
200d6b8: 12 80 00 07 bne 200d6d4 <msdos_format_fill_sectors+0x2c> <== ALWAYS TAKEN
200d6bc: 92 10 00 1d mov %i5, %o1
errno = ENOMEM;
200d6c0: 40 00 37 bb call 201b5ac <__errno> <== NOT EXECUTED
200d6c4: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
200d6c8: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
200d6cc: 10 80 00 05 b 200d6e0 <msdos_format_fill_sectors+0x38> <== NOT EXECUTED
200d6d0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
200d6d4: 94 10 00 1c mov %i4, %o2
200d6d8: 40 00 3a b1 call 201c19c <memset>
200d6dc: ba 10 20 00 clr %i5
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200d6e0: 90 10 00 18 mov %i0, %o0
200d6e4: 92 10 20 02 mov 2, %o1
200d6e8: 15 00 80 ad sethi %hi(0x202b400), %o2
200d6ec: 7f ff ff c2 call 200d5f4 <msdos_format_printf>
200d6f0: 94 12 a1 58 or %o2, 0x158, %o2 ! 202b558 <_CPU_Trap_slot_template+0x10>
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
200d6f4: 85 2e e0 02 sll %i3, 2, %g2
200d6f8: 83 2e e0 04 sll %i3, 4, %g1
while ((ret_val == 0) &&
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
200d6fc: 2b 00 80 ac sethi %hi(0x202b000), %l5
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
200d700: 82 00 80 01 add %g2, %g1, %g1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
200d704: a4 10 20 00 clr %l2
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
200d708: a7 28 60 02 sll %g1, 2, %l3
\*=========================================================================*/
{
int ret_val = 0;
char *fill_buffer = NULL;
uint32_t total_sectors = sector_cnt;
int last_percent = -1;
200d70c: a2 10 3f ff mov -1, %l1
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
200d710: a6 00 40 13 add %g1, %l3, %l3
200d714: a8 06 c0 1a add %i3, %i2, %l4
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
200d718: 10 80 00 15 b 200d76c <msdos_format_fill_sectors+0xc4>
200d71c: aa 15 63 00 or %l5, 0x300, %l5
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
200d720: 7f ff d4 06 call 2002738 <.udiv>
200d724: 92 10 00 1b mov %i3, %o1
if (percent != last_percent) {
200d728: 80 a2 00 11 cmp %o0, %l1
200d72c: 02 80 00 08 be 200d74c <msdos_format_fill_sectors+0xa4>
200d730: 80 8a 20 01 btst 1, %o0
if ((percent & 1) == 0)
200d734: 12 80 00 06 bne 200d74c <msdos_format_fill_sectors+0xa4>
200d738: a2 10 00 08 mov %o0, %l1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
200d73c: 90 10 00 18 mov %i0, %o0
200d740: 92 10 20 02 mov 2, %o1
200d744: 7f ff ff ac call 200d5f4 <msdos_format_printf>
200d748: 94 10 00 15 mov %l5, %o2
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
200d74c: 92 10 00 1a mov %i2, %o1
200d750: 90 10 00 19 mov %i1, %o0
200d754: 94 10 00 1c mov %i4, %o2
200d758: 96 10 00 10 mov %l0, %o3
200d75c: 7f ff ff bb call 200d648 <msdos_format_write_sec>
200d760: b4 06 a0 01 inc %i2
200d764: a4 04 bf 9c add %l2, -100, %l2
200d768: ba 10 00 08 mov %o0, %i5
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
200d76c: 80 a5 00 1a cmp %l4, %i2
200d770: 02 80 00 04 be 200d780 <msdos_format_fill_sectors+0xd8>
200d774: 80 a7 60 00 cmp %i5, 0
200d778: 02 bf ff ea be 200d720 <msdos_format_fill_sectors+0x78> <== ALWAYS TAKEN
200d77c: 90 04 80 13 add %l2, %l3, %o0
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
200d780: 90 10 00 18 mov %i0, %o0
200d784: 92 10 20 02 mov 2, %o1
200d788: 15 00 80 aa sethi %hi(0x202a800), %o2
200d78c: 7f ff ff 9a call 200d5f4 <msdos_format_printf>
200d790: 94 12 a3 48 or %o2, 0x348, %o2 ! 202ab48 <__clz_tab+0x478>
if (ret_val)
200d794: 80 a7 60 00 cmp %i5, 0
200d798: 02 80 00 09 be 200d7bc <msdos_format_fill_sectors+0x114> <== ALWAYS TAKEN
200d79c: 80 a4 20 00 cmp %l0, 0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
200d7a0: 15 00 80 ad sethi %hi(0x202b400), %o2 <== NOT EXECUTED
200d7a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200d7a8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
200d7ac: 94 12 a1 68 or %o2, 0x168, %o2 <== NOT EXECUTED
200d7b0: 7f ff ff 91 call 200d5f4 <msdos_format_printf> <== NOT EXECUTED
200d7b4: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
200d7b8: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
200d7bc: 02 80 00 04 be 200d7cc <msdos_format_fill_sectors+0x124> <== NEVER TAKEN
200d7c0: 01 00 00 00 nop
free(fill_buffer);
200d7c4: 7f ff de e4 call 2005354 <free>
200d7c8: 90 10 00 10 mov %l0, %o0
fill_buffer = NULL;
}
return ret_val;
}
200d7cc: 81 c7 e0 08 ret
200d7d0: 91 e8 00 1d restore %g0, %i5, %o0
0200d5f4 <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
200d5f4: 9d e3 bf 98 save %sp, -104, %sp
va_list args;
va_start (args, format);
200d5f8: 94 07 a0 50 add %fp, 0x50, %o2
200d5fc: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
200d600: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
200d604: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
if (rqdata != NULL && rqdata->info_level >= info_level)
200d608: 80 a6 20 00 cmp %i0, 0
200d60c: 02 80 00 0d be 200d640 <msdos_format_printf+0x4c>
200d610: d4 27 bf fc st %o2, [ %fp + -4 ]
200d614: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200d618: 80 a0 40 19 cmp %g1, %i1
200d61c: 06 80 00 09 bl 200d640 <msdos_format_printf+0x4c> <== ALWAYS TAKEN
200d620: 3b 00 80 b4 sethi %hi(0x202d000), %i5
{
vfprintf (stdout, format, args);
200d624: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 ! 202d010 <_impure_ptr><== NOT EXECUTED
200d628: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
200d62c: 40 00 5a 88 call 202404c <vfprintf> <== NOT EXECUTED
200d630: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
fflush (stdout);
200d634: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
200d638: 40 00 38 e0 call 201b9b8 <fflush> <== NOT EXECUTED
200d63c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
200d640: 81 c7 e0 08 ret
200d644: 81 e8 00 00 restore
0200d648 <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
200d648: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
200d64c: 94 10 20 00 clr %o2
200d650: 96 10 00 1a mov %i2, %o3
200d654: 90 10 20 00 clr %o0
200d658: 7f ff d2 e1 call 20021dc <__muldi3>
200d65c: 92 10 00 19 mov %i1, %o1
200d660: 84 10 00 08 mov %o0, %g2
200d664: 86 10 00 09 mov %o1, %g3
200d668: 90 10 00 18 mov %i0, %o0
200d66c: 92 10 00 02 mov %g2, %o1
200d670: 94 10 00 03 mov %g3, %o2
200d674: 40 00 1d 0a call 2014a9c <lseek>
200d678: 96 10 20 00 clr %o3
200d67c: 80 a2 20 00 cmp %o0, 0
200d680: 16 80 00 04 bge 200d690 <msdos_format_write_sec+0x48> <== ALWAYS TAKEN
200d684: 90 10 00 18 mov %i0, %o0
200d688: 81 c7 e0 08 ret <== NOT EXECUTED
200d68c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
200d690: 92 10 00 1b mov %i3, %o1
200d694: 7f ff ee 9b call 2009100 <write>
200d698: 94 10 00 1a mov %i2, %o2
200d69c: b1 3a 20 1f sra %o0, 0x1f, %i0
ret_val = -1;
}
}
return ret_val;
}
200d6a0: 81 c7 e0 08 ret
200d6a4: 81 e8 00 00 restore
02018e10 <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
)
{
2018e10: 9d e3 bf 50 save %sp, -176, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
2018e14: f8 06 20 08 ld [ %i0 + 8 ], %i4
fat_file_fd_t *fat_fd = NULL;
2018e18: 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);
2018e1c: 90 10 00 1c mov %i4, %o0
2018e20: 92 10 00 1a mov %i2, %o1
2018e24: 7f ff e4 d9 call 2012188 <fat_file_open>
2018e28: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
2018e2c: ba 92 20 00 orcc %o0, 0, %i5
2018e30: 32 80 00 a5 bne,a 20190c4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b4><== NEVER TAKEN
2018e34: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
fat_fd->cln = cln;
2018e38: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2018e3c: 03 00 08 00 sethi %hi(0x200000), %g1
*/
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
2018e40: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
2018e44: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2018e48: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
2018e4c: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
2018e50: f2 22 60 38 st %i1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
2018e54: 7f ff e7 7a call 2012c3c <fat_file_size>
2018e58: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
2018e5c: ba 92 20 00 orcc %o0, 0, %i5
2018e60: 22 80 00 04 be,a 2018e70 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x60><== ALWAYS TAKEN
2018e64: ba 07 bf c0 add %fp, -64, %i5
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
2018e68: 10 80 00 19 b 2018ecc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xbc><== NOT EXECUTED
2018e6c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2018e70: 92 10 20 00 clr %o1
2018e74: 90 10 00 1d mov %i5, %o0
2018e78: 40 00 0c c9 call 201c19c <memset>
2018e7c: 94 10 20 20 mov 0x20, %o2
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
2018e80: 94 10 00 1d mov %i5, %o2
2018e84: 33 00 80 ac sethi %hi(0x202b000), %i1
2018e88: 92 10 20 01 mov 1, %o1
2018e8c: 96 10 20 0b mov 0xb, %o3
2018e90: 7f ff fb 7a call 2017c78 <msdos_long_to_short>
2018e94: 90 16 63 00 or %i1, 0x300, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
2018e98: d2 07 bf bc ld [ %fp + -68 ], %o1
2018e9c: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
2018ea0: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
2018ea4: 90 10 00 18 mov %i0, %o0
2018ea8: 94 10 20 00 clr %o2
2018eac: 96 16 63 00 or %i1, 0x300, %o3
2018eb0: 98 10 20 01 mov 1, %o4
2018eb4: 7f ff fd 1b call 2018320 <msdos_find_name_in_fat_file>
2018eb8: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
2018ebc: ba 92 20 00 orcc %o0, 0, %i5
2018ec0: 22 80 00 05 be,a 2018ed4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xc4><== ALWAYS TAKEN
2018ec4: ba 07 bf e0 add %fp, -32, %i5
{
fat_file_close(&fs_info->fat, fat_fd);
2018ec8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2018ecc: 10 80 00 77 b 20190a8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
2018ed0: d2 07 bf bc ld [ %fp + -68 ], %o1 <== NOT EXECUTED
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2018ed4: 92 10 20 00 clr %o1
2018ed8: 90 10 00 1d mov %i5, %o0
2018edc: 40 00 0c b0 call 201c19c <memset>
2018ee0: 94 10 20 20 mov 0x20, %o2
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
2018ee4: 94 10 00 1d mov %i5, %o2
2018ee8: 33 00 80 ae sethi %hi(0x202b800), %i1
2018eec: 92 10 20 02 mov 2, %o1
2018ef0: 96 10 20 0b mov 0xb, %o3
2018ef4: 7f ff fb 61 call 2017c78 <msdos_long_to_short>
2018ef8: 90 16 61 d8 or %i1, 0x1d8, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
2018efc: d2 07 bf bc ld [ %fp + -68 ], %o1
2018f00: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
2018f04: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
2018f08: 90 10 00 18 mov %i0, %o0
2018f0c: 94 10 20 00 clr %o2
2018f10: 96 16 61 d8 or %i1, 0x1d8, %o3
2018f14: 98 10 20 02 mov 2, %o4
2018f18: 7f ff fd 02 call 2018320 <msdos_find_name_in_fat_file>
2018f1c: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
2018f20: ba 92 20 00 orcc %o0, 0, %i5
2018f24: 02 80 00 04 be 2018f34 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x124><== ALWAYS TAKEN
2018f28: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(&fs_info->fat, fat_fd);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
2018f2c: 10 80 00 5f b 20190a8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
2018f30: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
2018f34: e0 17 bf da lduh [ %fp + -38 ], %l0
2018f38: e2 17 bf d4 lduh [ %fp + -44 ], %l1
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(&fs_info->fat, fat_fd);
2018f3c: 7f ff e5 a9 call 20125e0 <fat_file_close>
2018f40: 90 10 00 1c mov %i4, %o0
if ( rc != RC_OK )
2018f44: ba 92 20 00 orcc %o0, 0, %i5
2018f48: 12 80 00 5e bne 20190c0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0><== NEVER TAKEN
2018f4c: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
2018f50: 83 28 60 10 sll %g1, 0x10, %g1
2018f54: 85 30 60 18 srl %g1, 0x18, %g2
2018f58: 87 30 60 08 srl %g1, 8, %g3
2018f5c: 03 00 00 3f sethi %hi(0xfc00), %g1
2018f60: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2018f64: 86 08 c0 01 and %g3, %g1, %g3
2018f68: 86 10 80 03 or %g2, %g3, %g3
2018f6c: c4 17 bf fa lduh [ %fp + -6 ], %g2
2018f70: 87 28 e0 10 sll %g3, 0x10, %g3
2018f74: 85 28 a0 10 sll %g2, 0x10, %g2
2018f78: 89 30 a0 18 srl %g2, 0x18, %g4
2018f7c: 85 30 a0 08 srl %g2, 8, %g2
2018f80: 82 08 80 01 and %g2, %g1, %g1
2018f84: 82 11 00 01 or %g4, %g1, %g1
2018f88: 80 90 c0 01 orcc %g3, %g1, %g0
2018f8c: 12 80 00 08 bne 2018fac <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x19c><== ALWAYS TAKEN
2018f90: 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;
2018f94: 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;
2018f98: c0 26 a0 04 clr [ %i2 + 4 ] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2018f9c: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2018fa0: 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;
2018fa4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2018fa8: 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);
2018fac: 92 10 00 1a mov %i2, %o1
2018fb0: 7f ff e4 76 call 2012188 <fat_file_open>
2018fb4: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
2018fb8: ba 92 20 00 orcc %o0, 0, %i5
2018fbc: 12 80 00 41 bne 20190c0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0><== NEVER TAKEN
2018fc0: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
2018fc4: 33 00 00 3f sethi %hi(0xfc00), %i1
2018fc8: 83 28 60 10 sll %g1, 0x10, %g1
2018fcc: b2 16 63 ff or %i1, 0x3ff, %i1
2018fd0: bb 30 60 18 srl %g1, 0x18, %i5
2018fd4: 83 30 60 08 srl %g1, 8, %g1
2018fd8: 82 08 40 19 and %g1, %i1, %g1
2018fdc: ba 17 40 01 or %i5, %g1, %i5
2018fe0: c2 17 bf fa lduh [ %fp + -6 ], %g1
2018fe4: bb 2f 60 10 sll %i5, 0x10, %i5
2018fe8: 83 28 60 10 sll %g1, 0x10, %g1
2018fec: 89 30 60 18 srl %g1, 0x18, %g4
2018ff0: 83 30 60 08 srl %g1, 8, %g1
2018ff4: b2 08 40 19 and %g1, %i1, %i1
2018ff8: 88 11 00 19 or %g4, %i1, %g4
2018ffc: 88 97 40 04 orcc %i5, %g4, %g4
2019000: 12 80 00 05 bne 2019014 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x204><== ALWAYS TAKEN
2019004: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->cln = fs_info->fat.vol.rdir_cl;
2019008: c2 07 20 3c ld [ %i4 + 0x3c ], %g1 <== NOT EXECUTED
201900c: 10 80 00 03 b 2019018 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x208><== NOT EXECUTED
2019010: c2 22 60 1c st %g1, [ %o1 + 0x1c ] <== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
2019014: c8 22 60 1c st %g4, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2019018: 03 00 08 00 sethi %hi(0x200000), %g1
201901c: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
2019020: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
2019024: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
2019028: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
201902c: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
2019030: 7f ff e7 03 call 2012c3c <fat_file_size>
2019034: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
2019038: ba 92 20 00 orcc %o0, 0, %i5
201903c: 02 80 00 04 be 201904c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x23c><== ALWAYS TAKEN
2019040: d2 07 bf bc ld [ %fp + -68 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
2019044: 10 80 00 19 b 20190a8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
2019048: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
201904c: 87 2c 60 10 sll %l1, 0x10, %g3
2019050: 03 00 00 3f sethi %hi(0xfc00), %g1
2019054: 95 30 e0 18 srl %g3, 0x18, %o2
2019058: 82 10 63 ff or %g1, 0x3ff, %g1
201905c: 87 30 e0 08 srl %g3, 8, %g3
2019060: 86 08 c0 01 and %g3, %g1, %g3
2019064: 85 2c 20 10 sll %l0, 0x10, %g2
2019068: 94 12 80 03 or %o2, %g3, %o2
201906c: 87 30 a0 18 srl %g2, 0x18, %g3
2019070: 85 30 a0 08 srl %g2, 8, %g2
2019074: 82 08 80 01 and %g2, %g1, %g1
2019078: 82 10 c0 01 or %g3, %g1, %g1
201907c: 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,
2019080: 90 10 00 18 mov %i0, %o0
2019084: 94 12 80 01 or %o2, %g1, %o2
2019088: 96 10 00 1a mov %i2, %o3
201908c: 7f ff ff 00 call 2018c8c <msdos_find_node_by_cluster_num_in_fat_file>
2019090: 98 10 00 1b mov %i3, %o4
2019094: d2 07 bf bc ld [ %fp + -68 ], %o1
2019098: ba 10 00 08 mov %o0, %i5
dir_pos, dir_entry);
if (rc != RC_OK)
201909c: 80 a7 60 00 cmp %i5, 0
20190a0: 02 80 00 05 be 20190b4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a4><== ALWAYS TAKEN
20190a4: 90 10 00 1c mov %i4, %o0
{
fat_file_close(&fs_info->fat, fat_fd);
20190a8: 7f ff e5 4e call 20125e0 <fat_file_close> <== NOT EXECUTED
20190ac: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
20190b0: 30 80 00 05 b,a 20190c4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b4><== NOT EXECUTED
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
20190b4: 7f ff e5 4b call 20125e0 <fat_file_close>
20190b8: 01 00 00 00 nop
20190bc: ba 10 00 08 mov %o0, %i5
return rc;
}
20190c0: b0 10 00 1d mov %i5, %i0
20190c4: 81 c7 e0 08 ret
20190c8: 81 e8 00 00 restore
020190cc <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
20190cc: 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,
20190d0: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
20190d4: 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
)
{
20190d8: 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,
20190dc: 9a 10 00 1c mov %i4, %o5
20190e0: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
20190e4: e0 23 a0 60 st %l0, [ %sp + 0x60 ]
20190e8: 94 10 00 19 mov %i1, %o2
20190ec: 96 10 00 1a mov %i2, %o3
20190f0: 7f ff fc 8c call 2018320 <msdos_find_name_in_fat_file>
20190f4: 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))
20190f8: 03 00 00 1f sethi %hi(0x7c00), %g1
20190fc: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
2019100: 80 a2 00 01 cmp %o0, %g1
2019104: 02 80 00 05 be 2019118 <msdos_get_name_node+0x4c>
2019108: b8 10 00 08 mov %o0, %i4
201910c: 80 a2 20 00 cmp %o0, 0
2019110: 12 80 00 2d bne 20191c4 <msdos_get_name_node+0xf8>
2019114: 01 00 00 00 nop
return rc;
if (!create_node)
2019118: 80 a6 60 00 cmp %i1, 0
201911c: 12 80 00 2a bne 20191c4 <msdos_get_name_node+0xf8>
2019120: 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)
2019124: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
2019128: 80 a7 00 01 cmp %i4, %g1
201912c: 02 80 00 26 be 20191c4 <msdos_get_name_node+0xf8>
2019130: 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)
2019134: 12 80 00 24 bne 20191c4 <msdos_get_name_node+0xf8> <== NEVER TAKEN
2019138: 90 10 00 1a mov %i2, %o0
{
if (strncmp(name, "..", 2) == 0)
201913c: 13 00 80 ae sethi %hi(0x202b800), %o1
2019140: 94 10 20 02 mov 2, %o2
2019144: 40 00 12 56 call 201da9c <strncmp>
2019148: 92 12 61 d8 or %o1, 0x1d8, %o1
201914c: 80 a2 20 00 cmp %o0, 0
2019150: 12 80 00 1d bne 20191c4 <msdos_get_name_node+0xf8>
2019154: 05 00 00 3f sethi %hi(0xfc00), %g2
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
2019158: c6 14 20 1a lduh [ %l0 + 0x1a ], %g3
201915c: c8 14 20 14 lduh [ %l0 + 0x14 ], %g4
2019160: 87 28 e0 10 sll %g3, 0x10, %g3
2019164: 89 29 20 10 sll %g4, 0x10, %g4
2019168: 83 30 e0 18 srl %g3, 0x18, %g1
201916c: b3 31 20 18 srl %g4, 0x18, %i1
2019170: 89 31 20 08 srl %g4, 8, %g4
2019174: 84 10 a3 ff or %g2, 0x3ff, %g2
2019178: 87 30 e0 08 srl %g3, 8, %g3
201917c: 88 09 00 02 and %g4, %g2, %g4
2019180: 84 08 c0 02 and %g3, %g2, %g2
2019184: b2 16 40 04 or %i1, %g4, %i1
2019188: 82 10 40 02 or %g1, %g2, %g1
201918c: b3 2e 60 10 sll %i1, 0x10, %i1
/* are we right under root dir ? */
if (dotdot_cln == 0)
2019190: b2 96 40 01 orcc %i1, %g1, %i1
2019194: 12 80 00 08 bne 20191b4 <msdos_get_name_node+0xe8>
2019198: 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;
201919c: c0 27 60 04 clr [ %i5 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
20191a0: c2 27 60 08 st %g1, [ %i5 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
20191a4: 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;
20191a8: 82 10 20 01 mov 1, %g1
20191ac: 10 80 00 06 b 20191c4 <msdos_get_name_node+0xf8>
20191b0: c2 27 40 00 st %g1, [ %i5 ]
}
else
{
rc =
20191b4: f0 06 20 14 ld [ %i0 + 0x14 ], %i0
20191b8: b4 10 00 1d mov %i5, %i2
20191bc: 7f ff ff 15 call 2018e10 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
20191c0: 97 e8 00 10 restore %g0, %l0, %o3
}
}
}
}
return rc;
}
20191c4: 81 c7 e0 08 ret
20191c8: 91 e8 00 1c restore %g0, %i4, %o0
0200e87c <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
)
{
200e87c: 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));
200e880: 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;
200e884: 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));
200e888: 7f ff d9 df call 2005004 <calloc>
200e88c: 92 10 20 a4 mov 0xa4, %o1
if (!fs_info)
200e890: ba 92 20 00 orcc %o0, 0, %i5
200e894: 32 80 00 03 bne,a 200e8a0 <msdos_initialize_support+0x24><== ALWAYS TAKEN
200e898: d2 06 20 38 ld [ %i0 + 0x38 ], %o1
200e89c: 30 80 00 45 b,a 200e9b0 <msdos_initialize_support+0x134> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
200e8a0: 40 00 12 b1 call 2013364 <fat_init_volume_info>
200e8a4: fa 26 20 08 st %i5, [ %i0 + 8 ]
if (rc != RC_OK)
200e8a8: b8 92 20 00 orcc %o0, 0, %i4
200e8ac: 12 80 00 12 bne 200e8f4 <msdos_initialize_support+0x78> <== NEVER TAKEN
200e8b0: 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;
200e8b4: c2 27 bf f8 st %g1, [ %fp + -8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
200e8b8: 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;
200e8bc: 82 10 20 01 mov 1, %g1
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
200e8c0: f4 27 60 98 st %i2, [ %i5 + 0x98 ]
fs_info->directory_handlers = directory_handlers;
200e8c4: 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;
200e8c8: 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;
200e8cc: c2 27 bf f0 st %g1, [ %fp + -16 ]
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
200e8d0: 90 10 00 1d mov %i5, %o0
200e8d4: 92 07 bf f0 add %fp, -16, %o1
200e8d8: 40 00 0e 2c call 2012188 <fat_file_open>
200e8dc: 94 07 bf ec add %fp, -20, %o2
if (rc != RC_OK)
200e8e0: b8 92 20 00 orcc %o0, 0, %i4
200e8e4: 02 80 00 08 be 200e904 <msdos_initialize_support+0x88> <== ALWAYS TAKEN
200e8e8: d2 07 bf ec ld [ %fp + -20 ], %o1
{
fat_shutdown_drive(&fs_info->fat);
200e8ec: 40 00 14 c2 call 2013bf4 <fat_shutdown_drive> <== NOT EXECUTED
200e8f0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
200e8f4: 7f ff da 98 call 2005354 <free> <== NOT EXECUTED
200e8f8: 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;
}
200e8fc: 81 c7 e0 08 ret <== NOT EXECUTED
200e900: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
200e904: 03 00 08 00 sethi %hi(0x200000), %g1
200e908: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
200e90c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
200e910: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
200e914: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
fat_fd->map.file_cln = 0;
200e918: 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 )
200e91c: 80 a0 60 00 cmp %g1, 0
200e920: 12 80 00 09 bne 200e944 <msdos_initialize_support+0xc8>
200e924: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
200e928: 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 :
200e92c: 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) ?
200e930: 80 a2 00 01 cmp %o0, %g1
200e934: 1a 80 00 13 bcc 200e980 <msdos_initialize_support+0x104>
200e938: c2 22 60 18 st %g1, [ %o1 + 0x18 ]
200e93c: 10 80 00 11 b 200e980 <msdos_initialize_support+0x104>
200e940: 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);
200e944: 40 00 10 be call 2012c3c <fat_file_size>
200e948: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
200e94c: b4 92 20 00 orcc %o0, 0, %i2
200e950: 22 80 00 0c be,a 200e980 <msdos_initialize_support+0x104><== ALWAYS TAKEN
200e954: d0 17 60 06 lduh [ %i5 + 6 ], %o0
{
fat_file_close(&fs_info->fat, fat_fd);
200e958: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
200e95c: 40 00 0f 21 call 20125e0 <fat_file_close> <== NOT EXECUTED
200e960: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
200e964: 40 00 14 a4 call 2013bf4 <fat_shutdown_drive> <== NOT EXECUTED
200e968: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
200e96c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200e970: 7f ff da 79 call 2005354 <free> <== NOT EXECUTED
200e974: b8 10 00 1a mov %i2, %i4 <== NOT EXECUTED
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
return rc;
}
200e978: 81 c7 e0 08 ret <== NOT EXECUTED
200e97c: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
200e980: 7f ff d9 a1 call 2005004 <calloc>
200e984: 92 10 20 01 mov 1, %o1
if (fs_info->cl_buf == NULL)
200e988: 80 a2 20 00 cmp %o0, 0
200e98c: 12 80 00 0f bne 200e9c8 <msdos_initialize_support+0x14c> <== ALWAYS TAKEN
200e990: d0 27 60 a0 st %o0, [ %i5 + 0xa0 ]
{
fat_file_close(&fs_info->fat, fat_fd);
200e994: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
200e998: 40 00 0f 12 call 20125e0 <fat_file_close> <== NOT EXECUTED
200e99c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
200e9a0: 40 00 14 95 call 2013bf4 <fat_shutdown_drive> <== NOT EXECUTED
200e9a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
200e9a8: 7f ff da 6b call 2005354 <free> <== NOT EXECUTED
200e9ac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
200e9b0: 40 00 32 ff call 201b5ac <__errno> <== NOT EXECUTED
200e9b4: 01 00 00 00 nop <== NOT EXECUTED
200e9b8: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
200e9bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200e9c0: 10 80 00 1b b 200ea2c <msdos_initialize_support+0x1b0> <== NOT EXECUTED
200e9c4: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
}
sc = rtems_semaphore_create(3,
200e9c8: 92 10 20 01 mov 1, %o1
200e9cc: 90 10 20 03 mov 3, %o0
200e9d0: 94 10 20 10 mov 0x10, %o2
200e9d4: 96 10 20 00 clr %o3
200e9d8: 7f ff eb 0e call 2009610 <rtems_semaphore_create>
200e9dc: 98 07 60 9c add %i5, 0x9c, %o4
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
200e9e0: 80 a2 20 00 cmp %o0, 0
200e9e4: 02 80 00 0e be 200ea1c <msdos_initialize_support+0x1a0> <== ALWAYS TAKEN
200e9e8: d2 07 bf ec ld [ %fp + -20 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
200e9ec: 40 00 0e fd call 20125e0 <fat_file_close> <== NOT EXECUTED
200e9f0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
200e9f4: 40 00 14 80 call 2013bf4 <fat_shutdown_drive> <== NOT EXECUTED
200e9f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info->cl_buf);
200e9fc: 7f ff da 56 call 2005354 <free> <== NOT EXECUTED
200ea00: d0 07 60 a0 ld [ %i5 + 0xa0 ], %o0 <== NOT EXECUTED
free(fs_info);
200ea04: 7f ff da 54 call 2005354 <free> <== NOT EXECUTED
200ea08: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
200ea0c: 40 00 32 e8 call 201b5ac <__errno> <== NOT EXECUTED
200ea10: 01 00 00 00 nop <== NOT EXECUTED
200ea14: 10 bf ff ea b 200e9bc <msdos_initialize_support+0x140> <== NOT EXECUTED
200ea18: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
200ea1c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200ea20: d2 20 60 08 st %o1, [ %g1 + 8 ]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
200ea24: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
temp_mt_entry->ops = op_table;
200ea28: f2 26 20 0c st %i1, [ %i0 + 0xc ]
return rc;
}
200ea2c: b0 10 00 1c mov %i4, %i0
200ea30: 81 c7 e0 08 ret
200ea34: 81 e8 00 00 restore
0200e848 <msdos_lock>:
.rename_h = msdos_rename,
.statvfs_h = rtems_filesystem_default_statvfs
};
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
200e848: 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,
200e84c: 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(
200e850: 92 10 20 00 clr %o1
200e854: d0 00 60 9c ld [ %g1 + 0x9c ], %o0
200e858: 7f ff ec 0b call 2009884 <rtems_semaphore_obtain>
200e85c: 94 10 20 00 clr %o2
fs_info->vol_sema,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if (sc != RTEMS_SUCCESSFUL) {
200e860: 80 a2 20 00 cmp %o0, 0
200e864: 02 80 00 04 be 200e874 <msdos_lock+0x2c> <== ALWAYS TAKEN
200e868: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
200e86c: 7f ff ed f1 call 200a030 <rtems_fatal_error_occurred> <== NOT EXECUTED
200e870: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
200e874: 81 c7 e0 08 ret
200e878: 81 e8 00 00 restore
02017c78 <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)
{
2017c78: 9d e3 bf 98 save %sp, -104, %sp
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
2017c7c: 92 10 20 20 mov 0x20, %o1
2017c80: 90 10 00 1a mov %i2, %o0
2017c84: 40 00 11 46 call 201c19c <memset>
2017c88: 94 10 00 1b mov %i3, %o2
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
2017c8c: c2 4e 00 00 ldsb [ %i0 ], %g1
2017c90: 80 a0 60 2e cmp %g1, 0x2e
2017c94: 12 80 00 23 bne 2017d20 <msdos_long_to_short+0xa8>
2017c98: 84 10 20 00 clr %g2
2017c9c: 80 a6 60 01 cmp %i1, 1
2017ca0: 32 80 00 04 bne,a 2017cb0 <msdos_long_to_short+0x38>
2017ca4: c2 4e 20 01 ldsb [ %i0 + 1 ], %g1
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
{
sfn[0] = sfn[1] = '.';
2017ca8: 10 80 00 0a b 2017cd0 <msdos_long_to_short+0x58>
2017cac: 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))
2017cb0: 80 a0 60 2e cmp %g1, 0x2e
2017cb4: 12 80 00 1c bne 2017d24 <msdos_long_to_short+0xac> <== NEVER TAKEN
2017cb8: 80 a0 80 19 cmp %g2, %i1
2017cbc: 80 a6 60 02 cmp %i1, 2
2017cc0: 12 80 00 19 bne 2017d24 <msdos_long_to_short+0xac> <== NEVER TAKEN
2017cc4: 80 a0 80 19 cmp %g2, %i1
{
sfn[0] = sfn[1] = '.';
2017cc8: c2 2e a0 01 stb %g1, [ %i2 + 1 ]
2017ccc: 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;
2017cd0: 10 80 00 72 b 2017e98 <msdos_long_to_short+0x220>
2017cd4: 82 10 20 01 mov 1, %g1
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
2017cd8: 80 a0 60 2e cmp %g1, 0x2e
2017cdc: 22 80 00 11 be,a 2017d20 <msdos_long_to_short+0xa8> <== NEVER TAKEN
2017ce0: 84 00 a0 01 inc %g2 <== NOT EXECUTED
2017ce4: 80 a0 60 20 cmp %g1, 0x20
2017ce8: 22 80 00 0e be,a 2017d20 <msdos_long_to_short+0xa8>
2017cec: 84 00 a0 01 inc %g2
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
2017cf0: 03 00 80 b4 sethi %hi(0x202d000), %g1
2017cf4: c2 00 60 08 ld [ %g1 + 8 ], %g1 ! 202d008 <__ctype_ptr__>
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2017cf8: 2d 00 80 af sethi %hi(0x202bc00), %l6
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
2017cfc: 2f 00 80 af sethi %hi(0x202bc00), %l7
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
2017d00: c2 27 bf fc st %g1, [ %fp + -4 ]
2017d04: b8 10 20 00 clr %i4
2017d08: a2 10 3f ff mov -1, %l1
2017d0c: a4 10 20 00 clr %l2
2017d10: a6 10 20 00 clr %l3
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2017d14: ac 15 a0 08 or %l6, 8, %l6
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
2017d18: 10 80 00 45 b 2017e2c <msdos_long_to_short+0x1b4>
2017d1c: ae 15 e0 10 or %l7, 0x10, %l7
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
2017d20: 80 a0 80 19 cmp %g2, %i1
2017d24: 26 bf ff ed bl,a 2017cd8 <msdos_long_to_short+0x60> <== ALWAYS TAKEN
2017d28: c2 4e 00 02 ldsb [ %i0 + %g2 ], %g1
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
2017d2c: 80 a0 80 19 cmp %g2, %i1 <== NOT EXECUTED
2017d30: 12 bf ff f0 bne 2017cf0 <msdos_long_to_short+0x78> <== NOT EXECUTED
2017d34: 82 10 20 00 clr %g1 <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
2017d38: 81 c7 e0 08 ret <== NOT EXECUTED
2017d3c: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
2017d40: 80 a0 00 01 cmp %g0, %g1
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2017d44: 90 10 00 16 mov %l6, %o0
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
2017d48: a8 60 3f ff subx %g0, -1, %l4
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2017d4c: 92 10 00 1b mov %i3, %o1
2017d50: 40 00 14 d6 call 201d0a8 <strchr>
2017d54: aa 10 00 14 mov %l4, %l5
2017d58: 80 a2 20 00 cmp %o0, 0
2017d5c: 12 80 00 12 bne 2017da4 <msdos_long_to_short+0x12c>
2017d60: ba 10 20 02 mov 2, %i5
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
2017d64: 80 8d 20 ff btst 0xff, %l4
2017d68: 12 80 00 0e bne 2017da0 <msdos_long_to_short+0x128>
2017d6c: c2 07 bf fc ld [ %fp + -4 ], %g1
2017d70: 84 0c 20 ff and %l0, 0xff, %g2
2017d74: 84 00 40 02 add %g1, %g2, %g2
2017d78: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
2017d7c: 80 88 a0 07 btst 7, %g2
2017d80: 12 80 00 09 bne 2017da4 <msdos_long_to_short+0x12c>
2017d84: ba 10 20 01 mov 1, %i5
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
2017d88: 90 10 00 17 mov %l7, %o0
2017d8c: 40 00 14 c7 call 201d0a8 <strchr>
2017d90: 92 10 00 1b mov %i3, %o1
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
2017d94: 80 a0 00 08 cmp %g0, %o0
2017d98: 10 80 00 03 b 2017da4 <msdos_long_to_short+0x12c>
2017d9c: ba 40 20 00 addx %g0, 0, %i5
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
return MSDOS_NAME_SHORT;
2017da0: ba 10 20 01 mov 1, %i5
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
2017da4: 80 8f 60 01 btst 1, %i5
2017da8: 02 80 00 2f be 2017e64 <msdos_long_to_short+0x1ec>
2017dac: 80 a4 7f ff cmp %l1, -1
return type;
if (dot_at >= 0)
2017db0: 02 80 00 0a be 2017dd8 <msdos_long_to_short+0x160>
2017db4: 80 8d 60 ff btst 0xff, %l5
{
if (is_dot || ((count - dot_at) > 3))
2017db8: 32 80 00 2e bne,a 2017e70 <msdos_long_to_short+0x1f8>
2017dbc: ba 10 20 02 mov 2, %i5
2017dc0: 82 27 00 11 sub %i4, %l1, %g1
2017dc4: 80 a0 60 03 cmp %g1, 3
2017dc8: 24 80 00 0d ble,a 2017dfc <msdos_long_to_short+0x184> <== ALWAYS TAKEN
2017dcc: 82 04 3f bf add %l0, -65, %g1
{
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
is_dot, dot_at, count);
#endif
return MSDOS_NAME_LONG;
2017dd0: 10 80 00 28 b 2017e70 <msdos_long_to_short+0x1f8> <== NOT EXECUTED
2017dd4: ba 10 20 02 mov 2, %i5 <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
2017dd8: 80 a5 20 00 cmp %l4, 0
2017ddc: 12 80 00 05 bne 2017df0 <msdos_long_to_short+0x178>
2017de0: 80 8d 60 ff btst 0xff, %l5
2017de4: 80 a7 20 08 cmp %i4, 8
2017de8: 02 80 00 28 be 2017e88 <msdos_long_to_short+0x210>
2017dec: 80 8d 60 ff btst 0xff, %l5
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
2017df0: 32 80 00 0e bne,a 2017e28 <msdos_long_to_short+0x1b0>
2017df4: a2 10 00 1c mov %i4, %l1
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
2017df8: 82 04 3f bf add %l0, -65, %g1
2017dfc: 82 08 60 ff and %g1, 0xff, %g1
2017e00: 80 a0 60 19 cmp %g1, 0x19
2017e04: 28 80 00 09 bleu,a 2017e28 <msdos_long_to_short+0x1b0>
2017e08: a4 10 20 01 mov 1, %l2
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
2017e0c: a0 04 3f 9f add %l0, -97, %l0
2017e10: a0 0c 20 ff and %l0, 0xff, %l0
2017e14: 80 a4 20 19 cmp %l0, 0x19
2017e18: 28 80 00 04 bleu,a 2017e28 <msdos_long_to_short+0x1b0>
2017e1c: a6 10 20 01 mov 1, %l3
lowercase = true;
count++;
2017e20: 10 80 00 03 b 2017e2c <msdos_long_to_short+0x1b4>
2017e24: b8 07 20 01 inc %i4
2017e28: b8 07 20 01 inc %i4
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
2017e2c: f6 4e 00 1c ldsb [ %i0 + %i4 ], %i3
2017e30: 80 a6 e0 00 cmp %i3, 0
2017e34: 02 80 00 05 be 2017e48 <msdos_long_to_short+0x1d0>
2017e38: e0 0e 00 1c ldub [ %i0 + %i4 ], %l0
2017e3c: 80 a7 00 19 cmp %i4, %i1
2017e40: 06 bf ff c0 bl 2017d40 <msdos_long_to_short+0xc8>
2017e44: 82 1e e0 2e xor %i3, 0x2e, %g1
count++;
name++;
}
if (lowercase && uppercase)
2017e48: 80 8c e0 ff btst 0xff, %l3
2017e4c: 02 80 00 11 be 2017e90 <msdos_long_to_short+0x218>
2017e50: 80 8c a0 ff btst 0xff, %l2
2017e54: 22 80 00 07 be,a 2017e70 <msdos_long_to_short+0x1f8> <== ALWAYS TAKEN
2017e58: ba 10 20 01 mov 1, %i5
{
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
is_dot, dot_at, count);
#endif
return MSDOS_NAME_LONG;
2017e5c: 10 80 00 05 b 2017e70 <msdos_long_to_short+0x1f8> <== NOT EXECUTED
2017e60: ba 10 20 02 mov 2, %i5 <== NOT EXECUTED
* Is this a short name ?
*/
type = msdos_name_type (lfn, lfn_len);
if (type == MSDOS_NAME_INVALID)
2017e64: 82 97 60 00 orcc %i5, 0, %g1
2017e68: 22 80 00 0d be,a 2017e9c <msdos_long_to_short+0x224> <== NEVER TAKEN
2017e6c: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
2017e70: 90 10 00 18 mov %i0, %o0
2017e74: 92 10 00 19 mov %i1, %o1
2017e78: 40 00 0a a5 call 201a90c <msdos_filename_unix2dos>
2017e7c: 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;
2017e80: 10 80 00 06 b 2017e98 <msdos_long_to_short+0x220>
2017e84: 82 10 00 1d mov %i5, %g1
{
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
is_dot, dot_at, count);
#endif
return MSDOS_NAME_LONG;
2017e88: 10 bf ff fa b 2017e70 <msdos_long_to_short+0x1f8>
2017e8c: ba 10 20 02 mov 2, %i5
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
2017e90: 10 bf ff f8 b 2017e70 <msdos_long_to_short+0x1f8>
2017e94: ba 10 20 01 mov 1, %i5
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
2017e98: b0 10 00 01 mov %g1, %i0
2017e9c: 81 c7 e0 08 ret
2017ea0: 81 e8 00 00 restore
0200ea38 <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
200ea38: 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))
200ea3c: 05 00 00 3c sethi %hi(0xf000), %g2
200ea40: 03 00 00 10 sethi %hi(0x4000), %g1
200ea44: 84 0e c0 02 and %i3, %g2, %g2
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
200ea48: 88 10 00 19 mov %i1, %g4
200ea4c: 86 10 00 1a mov %i2, %g3
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
200ea50: 80 a0 80 01 cmp %g2, %g1
200ea54: 02 80 00 07 be 200ea70 <msdos_mknod+0x38>
200ea58: b8 10 00 1b mov %i3, %i4
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
200ea5c: 3b 00 00 20 sethi %hi(0x8000), %i5
200ea60: 80 a0 80 1d cmp %g2, %i5
200ea64: 02 80 00 04 be 200ea74 <msdos_mknod+0x3c> <== ALWAYS TAKEN
200ea68: b2 10 20 04 mov 4, %i1
200ea6c: 30 80 00 06 b,a 200ea84 <msdos_mknod+0x4c> <== NOT EXECUTED
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
200ea70: 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);
200ea74: b4 10 00 04 mov %g4, %i2
200ea78: b6 10 00 03 mov %g3, %i3
200ea7c: 40 00 23 1d call 20176f0 <msdos_creat_node>
200ea80: 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);
200ea84: 40 00 32 ca call 201b5ac <__errno> <== NOT EXECUTED
200ea88: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200ea8c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200ea90: 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;
}
200ea94: 81 c7 e0 08 ret <== NOT EXECUTED
200ea98: 81 e8 00 00 restore <== NOT EXECUTED
0200eaa8 <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
)
{
200eaa8: 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;
200eaac: 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,
200eab0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
200eab4: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
200eab8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
200eabc: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
200eac0: 19 00 00 20 sethi %hi(0x8000), %o4 <== NOT EXECUTED
200eac4: 40 00 23 0b call 20176f0 <msdos_creat_node> <== NOT EXECUTED
200eac8: 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)
200eacc: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
200ead0: 12 80 00 05 bne 200eae4 <msdos_rename+0x3c> <== NOT EXECUTED
200ead4: b4 10 20 e5 mov 0xe5, %i2 <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
200ead8: f0 06 60 14 ld [ %i1 + 0x14 ], %i0 <== NOT EXECUTED
200eadc: 40 00 25 78 call 20180bc <msdos_set_first_char4file_name> <== NOT EXECUTED
200eae0: 93 ef 60 20 restore %i5, 0x20, %o1 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
200eae4: 81 c7 e0 08 ret <== NOT EXECUTED
200eae8: 81 e8 00 00 restore <== NOT EXECUTED
0200eaec <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
200eaec: 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;
200eaf0: 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;
200eaf4: 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)
200eaf8: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200eafc: 80 a0 a0 00 cmp %g2, 0
200eb00: 12 80 00 19 bne 200eb64 <msdos_rmnod+0x78>
200eb04: f8 02 20 08 ld [ %o0 + 8 ], %i4
{
bool is_empty = false;
200eb08: 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);
200eb0c: 92 10 00 1d mov %i5, %o1
200eb10: 40 00 25 b8 call 20181f0 <msdos_dir_is_empty>
200eb14: 94 07 bf ff add %fp, -1, %o2
if (rc != RC_OK)
200eb18: b0 92 20 00 orcc %o0, 0, %i0
200eb1c: 12 80 00 1a bne 200eb84 <msdos_rmnod+0x98> <== NEVER TAKEN
200eb20: c2 0f bf ff ldub [ %fp + -1 ], %g1
{
return rc;
}
if (!is_empty)
200eb24: 80 a0 60 00 cmp %g1, 0
200eb28: 32 80 00 06 bne,a 200eb40 <msdos_rmnod+0x54>
200eb2c: c2 07 60 08 ld [ %i5 + 8 ], %g1
{
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
200eb30: 40 00 32 9f call 201b5ac <__errno>
200eb34: 01 00 00 00 nop
200eb38: 10 80 00 08 b 200eb58 <msdos_rmnod+0x6c>
200eb3c: 82 10 20 5a mov 0x5a, %g1 ! 5a <PROM_START+0x5a>
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
200eb40: 80 a0 60 01 cmp %g1, 1
200eb44: 28 80 00 08 bleu,a 200eb64 <msdos_rmnod+0x78> <== ALWAYS TAKEN
200eb48: d0 06 60 14 ld [ %i1 + 0x14 ], %o0
{
rtems_set_errno_and_return_minus_one(EBUSY);
200eb4c: 40 00 32 98 call 201b5ac <__errno> <== NOT EXECUTED
200eb50: 01 00 00 00 nop <== NOT EXECUTED
200eb54: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
200eb58: c2 22 00 00 st %g1, [ %o0 ]
200eb5c: 81 c7 e0 08 ret
200eb60: 91 e8 3f ff restore %g0, -1, %o0
* not used - mount() not implemenetd yet.
*/
}
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
200eb64: 92 07 60 20 add %i5, 0x20, %o1
200eb68: 40 00 25 55 call 20180bc <msdos_set_first_char4file_name>
200eb6c: 94 10 20 e5 mov 0xe5, %o2
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
200eb70: b0 92 20 00 orcc %o0, 0, %i0
200eb74: 12 80 00 04 bne 200eb84 <msdos_rmnod+0x98> <== NEVER TAKEN
200eb78: 90 10 00 1c mov %i4, %o0
{
return rc;
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
200eb7c: 40 00 10 1c call 2012bec <fat_file_mark_removed>
200eb80: 92 10 00 1d mov %i5, %o1
return rc;
}
200eb84: 81 c7 e0 08 ret
200eb88: 81 e8 00 00 restore
02017ea4 <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
)
{
2017ea4: 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);
2017ea8: 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;
2017eac: 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);
2017eb0: 94 07 bf fc add %fp, -4, %o2
2017eb4: 40 00 09 fb call 201a6a0 <msdos_date_unix2dos>
2017eb8: 92 07 bf fe add %fp, -2, %o1
/*
* 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);
2017ebc: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
2017ec0: 7f ff ff 60 call 2017c40 <fat_cluster_num_to_sector_num>
2017ec4: 90 10 00 1d mov %i5, %o0
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2017ec8: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2017ecc: f8 17 40 00 lduh [ %i5 ], %i4
/*
* 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);
2017ed0: f6 0f 60 02 ldub [ %i5 + 2 ], %i3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2017ed4: b8 07 3f ff add %i4, -1, %i4
/*
* 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);
2017ed8: b7 30 40 1b srl %g1, %i3, %i3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2017edc: b8 0f 00 01 and %i4, %g1, %i4
time_val = CT_LE_W(time_val);
2017ee0: 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);
2017ee4: b6 02 00 1b add %o0, %i3, %i3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
2017ee8: 83 28 60 10 sll %g1, 0x10, %g1
2017eec: 85 30 60 08 srl %g1, 8, %g2
2017ef0: 83 30 60 18 srl %g1, 0x18, %g1
2017ef4: 82 10 80 01 or %g2, %g1, %g1
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2017ef8: 92 10 00 1b mov %i3, %o1
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
2017efc: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2017f00: 94 07 20 16 add %i4, 0x16, %o2
2017f04: 96 10 20 02 mov 2, %o3
2017f08: 98 07 bf fc add %fp, -4, %o4
2017f0c: 7f ff ec 5d call 2013080 <fat_sector_write>
2017f10: 90 10 00 1d mov %i5, %o0
2, (char *)(&time_val));
date = CT_LE_W(date);
2017f14: c2 17 bf fe lduh [ %fp + -2 ], %g1
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2017f18: 92 10 00 1b mov %i3, %o1
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
2017f1c: 83 28 60 10 sll %g1, 0x10, %g1
2017f20: 85 30 60 08 srl %g1, 8, %g2
2017f24: 83 30 60 18 srl %g1, 0x18, %g1
2017f28: 82 10 80 01 or %g2, %g1, %g1
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2017f2c: 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);
2017f30: c2 37 bf fe sth %g1, [ %fp + -2 ]
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2017f34: 96 10 20 02 mov 2, %o3
2017f38: 98 07 bf fe add %fp, -2, %o4
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2017f3c: b4 10 00 08 mov %o0, %i2
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2017f40: 7f ff ec 50 call 2013080 <fat_sector_write>
2017f44: 90 10 00 1d mov %i5, %o0
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
2017f48: 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,
2017f4c: b2 10 00 08 mov %o0, %i1
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
2017f50: 94 07 20 12 add %i4, 0x12, %o2
2017f54: 90 10 00 1d mov %i5, %o0
2017f58: 96 10 20 02 mov 2, %o3
2017f5c: 7f ff ec 49 call 2013080 <fat_sector_write>
2017f60: 98 07 bf fe add %fp, -2, %o4
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
2017f64: 80 a6 60 00 cmp %i1, 0
2017f68: 06 80 00 04 bl 2017f78 <msdos_set_dir_wrt_time_and_date+0xd4><== NEVER TAKEN
2017f6c: 80 a6 a0 00 cmp %i2, 0
2017f70: 16 80 00 04 bge 2017f80 <msdos_set_dir_wrt_time_and_date+0xdc><== ALWAYS TAKEN
2017f74: 80 a2 20 00 cmp %o0, 0
return -1;
2017f78: 81 c7 e0 08 ret <== NOT EXECUTED
2017f7c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
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) )
2017f80: 06 bf ff fe bl 2017f78 <msdos_set_dir_wrt_time_and_date+0xd4><== NEVER TAKEN
2017f84: 01 00 00 00 nop
return -1;
return RC_OK;
}
2017f88: 81 c7 e0 08 ret
2017f8c: 91 e8 20 00 restore %g0, 0, %o0
020180bc <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
)
{
20180bc: 9d e3 bf 90 save %sp, -112, %sp
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
20180c0: c2 06 60 08 ld [ %i1 + 8 ], %g1
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
20180c4: fa 06 20 08 ld [ %i0 + 8 ], %i5
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
20180c8: c2 27 bf f0 st %g1, [ %fp + -16 ]
20180cc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
fat_pos_t end = dir_pos->sname;
20180d0: 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;
20180d4: c2 27 bf f4 st %g1, [ %fp + -12 ]
fat_pos_t end = dir_pos->sname;
20180d8: c2 06 60 04 ld [ %i1 + 4 ], %g1
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
20180dc: f4 2f a0 4c stb %i2, [ %fp + 0x4c ]
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
20180e0: c2 27 bf fc st %g1, [ %fp + -4 ]
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
20180e4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
20180e8: 80 a7 00 01 cmp %i4, %g1
20180ec: 12 80 00 08 bne 201810c <msdos_set_first_char4file_name+0x50><== NEVER TAKEN
20180f0: f8 27 bf f8 st %i4, [ %fp + -8 ]
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
20180f4: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
20180f8: 80 88 60 03 btst 3, %g1
20180fc: 22 80 00 05 be,a 2018110 <msdos_set_first_char4file_name+0x54><== NEVER TAKEN
2018100: f6 17 60 06 lduh [ %i5 + 6 ], %i3 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
2018104: 10 80 00 03 b 2018110 <msdos_set_first_char4file_name+0x54>
2018108: f6 07 60 2c ld [ %i5 + 0x2c ], %i3
else
dir_block_size = fs_info->fat.vol.bpc;
201810c: f6 17 60 06 lduh [ %i5 + 6 ], %i3 <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
2018110: c2 06 60 08 ld [ %i1 + 8 ], %g1
2018114: 80 a0 7f ff cmp %g1, -1
2018118: 12 80 00 07 bne 2018134 <msdos_set_first_char4file_name+0x78>
201811c: d2 07 bf f0 ld [ %fp + -16 ], %o1
start = dir_pos->sname;
2018120: c2 06 40 00 ld [ %i1 ], %g1
2018124: c2 27 bf f0 st %g1, [ %fp + -16 ]
2018128: c2 06 60 04 ld [ %i1 + 4 ], %g1
201812c: c2 27 bf f4 st %g1, [ %fp + -12 ]
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
2018130: d2 07 bf f0 ld [ %fp + -16 ], %o1
2018134: 7f ff fe c3 call 2017c40 <fat_cluster_num_to_sector_num>
2018138: 90 10 00 1d mov %i5, %o0
(start.ofs >> fs_info->fat.vol.sec_log2));
201813c: c2 07 bf f4 ld [ %fp + -12 ], %g1
2018140: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
2018144: d4 17 40 00 lduh [ %i5 ], %o2
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
2018148: 93 30 40 09 srl %g1, %o1, %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
201814c: 94 02 bf ff add %o2, -1, %o2
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
2018150: 92 02 00 09 add %o0, %o1, %o1
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
2018154: 94 0a 80 01 and %o2, %g1, %o2
2018158: 90 10 00 1d mov %i5, %o0
201815c: 96 10 20 01 mov 1, %o3
2018160: 7f ff eb c8 call 2013080 <fat_sector_write>
2018164: 98 07 a0 4c add %fp, 0x4c, %o4
1, &fchar);
if (ret < 0)
2018168: 80 a2 20 00 cmp %o0, 0
201816c: 06 80 00 1e bl 20181e4 <msdos_set_first_char4file_name+0x128><== NEVER TAKEN
2018170: d2 07 bf f0 ld [ %fp + -16 ], %o1
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
2018174: 80 a2 40 1c cmp %o1, %i4
2018178: 12 80 00 08 bne 2018198 <msdos_set_first_char4file_name+0xdc><== NEVER TAKEN
201817c: c2 07 bf f4 ld [ %fp + -12 ], %g1
2018180: c4 07 bf fc ld [ %fp + -4 ], %g2
2018184: 80 a0 40 02 cmp %g1, %g2
2018188: 12 80 00 05 bne 201819c <msdos_set_first_char4file_name+0xe0>
201818c: 82 00 60 20 add %g1, 0x20, %g1
return rc;
start.ofs = 0;
}
}
return RC_OK;
2018190: 81 c7 e0 08 ret
2018194: 91 e8 20 00 restore %g0, 0, %o0
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
2018198: 82 00 60 20 add %g1, 0x20, %g1 <== NOT EXECUTED
if (start.ofs >= dir_block_size)
201819c: 80 a0 40 1b cmp %g1, %i3
20181a0: 0a bf ff e4 bcs 2018130 <msdos_set_first_char4file_name+0x74><== ALWAYS TAKEN
20181a4: c2 27 bf f4 st %g1, [ %fp + -12 ]
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
20181a8: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
20181ac: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
20181b0: 12 80 00 06 bne 20181c8 <msdos_set_first_char4file_name+0x10c><== NOT EXECUTED
20181b4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
20181b8: 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) &&
20181bc: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
20181c0: 12 bf ff f4 bne 2018190 <msdos_set_first_char4file_name+0xd4><== NOT EXECUTED
20181c4: 01 00 00 00 nop <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
20181c8: 40 00 04 e9 call 201956c <fat_get_fat_cluster> <== NOT EXECUTED
20181cc: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
20181d0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
20181d4: 12 80 00 05 bne 20181e8 <msdos_set_first_char4file_name+0x12c><== NOT EXECUTED
20181d8: 01 00 00 00 nop <== NOT EXECUTED
return rc;
start.ofs = 0;
20181dc: 10 bf ff d5 b 2018130 <msdos_set_first_char4file_name+0x74><== NOT EXECUTED
20181e0: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
1, &fchar);
if (ret < 0)
return -1;
20181e4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
start.ofs = 0;
}
}
return RC_OK;
}
20181e8: 81 c7 e0 08 ret <== NOT EXECUTED
20181ec: 81 e8 00 00 restore <== NOT EXECUTED
02017f90 <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
)
{
2017f90: 9d e3 bf 98 save %sp, -104, %sp
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
2017f94: fa 06 20 08 ld [ %i0 + 8 ], %i5
/*
* 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);
2017f98: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
)
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
2017f9c: c0 37 bf fc clrh [ %fp + -4 ]
uint16_t le_cl_hi = 0;
2017fa0: c0 37 bf fe clrh [ %fp + -2 ]
/*
* 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);
2017fa4: 7f ff ff 27 call 2017c40 <fat_cluster_num_to_sector_num>
2017fa8: 90 10 00 1d mov %i5, %o0
fat_file_fd_t *fat_fd
)
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
2017fac: f8 06 60 1c ld [ %i1 + 0x1c ], %i4
/*
* 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);
2017fb0: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2017fb4: 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);
2017fb8: f4 0f 60 02 ldub [ %i5 + 2 ], %i2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2017fbc: 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);
2017fc0: b5 30 40 1a srl %g1, %i2, %i2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2017fc4: b6 0e c0 01 and %i3, %g1, %i3
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
2017fc8: 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));
2017fcc: 83 2f 20 10 sll %i4, 0x10, %g1
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
2017fd0: b2 16 63 ff or %i1, 0x3ff, %i1
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
2017fd4: 83 30 60 18 srl %g1, 0x18, %g1
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
2017fd8: 84 0f 00 19 and %i4, %i1, %g2
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
2017fdc: 85 28 a0 08 sll %g2, 8, %g2
2017fe0: 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);
2017fe4: b4 02 00 1a add %o0, %i2, %i2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
2017fe8: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(&fs_info->fat, sec,
2017fec: 92 10 00 1a mov %i2, %o1
2017ff0: 94 06 e0 1a add %i3, 0x1a, %o2
2017ff4: 96 10 20 02 mov 2, %o3
2017ff8: 98 07 bf fc add %fp, -4, %o4
2017ffc: 7f ff ec 21 call 2013080 <fat_sector_write>
2018000: 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));
2018004: 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,
2018008: a0 10 00 08 mov %o0, %l0
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
201800c: 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,
2018010: 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));
2018014: b3 2e 60 08 sll %i1, 8, %i1
2018018: b9 37 20 08 srl %i4, 8, %i4
ret2 = fat_sector_write(&fs_info->fat, sec,
201801c: 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));
2018020: b8 16 40 1c or %i1, %i4, %i4
ret2 = fat_sector_write(&fs_info->fat, sec,
2018024: 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));
2018028: f8 37 bf fe sth %i4, [ %fp + -2 ]
ret2 = fat_sector_write(&fs_info->fat, sec,
201802c: 96 10 20 02 mov 2, %o3
2018030: 7f ff ec 14 call 2013080 <fat_sector_write>
2018034: 98 07 bf fe add %fp, -2, %o4
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
2018038: 80 a2 20 00 cmp %o0, 0
201803c: 06 80 00 04 bl 201804c <msdos_set_first_cluster_num+0xbc> <== NEVER TAKEN
2018040: 80 a4 20 00 cmp %l0, 0
2018044: 16 80 00 03 bge 2018050 <msdos_set_first_cluster_num+0xc0><== ALWAYS TAKEN
2018048: b0 10 20 00 clr %i0
return -1;
201804c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return RC_OK;
}
2018050: 81 c7 e0 08 ret
2018054: 81 e8 00 00 restore
0200d7d4 <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 )
{
200d7d4: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = -1;
uint32_t onebit;
if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {
200d7d8: 80 a6 20 00 cmp %i0, 0
200d7dc: 02 80 00 07 be 200d7f8 <msdos_set_sectors_per_cluster_from_request+0x24>
200d7e0: ba 10 20 80 mov 0x80, %i5
200d7e4: c2 06 20 08 ld [ %i0 + 8 ], %g1
200d7e8: 80 a0 60 00 cmp %g1, 0
200d7ec: 32 80 00 03 bne,a 200d7f8 <msdos_set_sectors_per_cluster_from_request+0x24>
200d7f0: 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 )
{
200d7f4: ba 10 20 80 mov 0x80, %i5
200d7f8: b0 10 3f ff mov -1, %i0
* 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 ) {
200d7fc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
200d800: 80 a0 40 1d cmp %g1, %i5
200d804: 2a 80 00 0c bcs,a 200d834 <msdos_set_sectors_per_cluster_from_request+0x60>
200d808: bb 37 60 01 srl %i5, 1, %i5
fmt_params->sectors_per_cluster = onebit;
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
200d80c: 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;
200d810: fa 26 60 0c st %i5, [ %i1 + 0xc ]
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
200d814: 7f ff d3 c9 call 2002738 <.udiv>
200d818: 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
200d81c: 80 a7 40 08 cmp %i5, %o0
200d820: 18 80 00 05 bgu 200d834 <msdos_set_sectors_per_cluster_from_request+0x60><== NEVER TAKEN
200d824: bb 37 60 01 srl %i5, 1, %i5
<= 32768L / fmt_params->bytes_per_sector ) {
/* value is small enough so this value is ok */
onebit = 1;
200d828: ba 10 20 01 mov 1, %i5
ret_val = 0;
200d82c: b0 10 20 00 clr %i0
* 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 ) {
200d830: bb 37 60 01 srl %i5, 1, %i5
200d834: 80 a7 60 00 cmp %i5, 0
200d838: 32 bf ff f2 bne,a 200d800 <msdos_set_sectors_per_cluster_from_request+0x2c>
200d83c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
ret_val = 0;
}
}
}
if (ret_val != 0) {
200d840: 80 a6 20 00 cmp %i0, 0
200d844: 02 80 00 06 be 200d85c <msdos_set_sectors_per_cluster_from_request+0x88><== ALWAYS TAKEN
200d848: 01 00 00 00 nop
errno = EINVAL;
200d84c: 40 00 37 58 call 201b5ac <__errno> <== NOT EXECUTED
200d850: 01 00 00 00 nop <== NOT EXECUTED
200d854: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
200d858: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return ret_val;
}
200d85c: 81 c7 e0 08 ret
200d860: 81 e8 00 00 restore
020193e0 <msdos_sync>:
return MSDOS_NAME_NOT_FOUND_ERR;
}
int
msdos_sync(rtems_libio_t *iop)
{
20193e0: 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;
20193e4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
20193e8: 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;
20193ec: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
20193f0: 94 10 20 00 clr %o2
20193f4: 7f ff c1 24 call 2009884 <rtems_semaphore_obtain>
20193f8: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
20193fc: 80 a2 20 00 cmp %o0, 0
2019400: 02 80 00 08 be 2019420 <msdos_sync+0x40> <== ALWAYS TAKEN
2019404: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
2019408: 40 00 08 69 call 201b5ac <__errno> <== NOT EXECUTED
201940c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2019410: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2019414: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2019418: 81 c7 e0 08 ret <== NOT EXECUTED
201941c: 81 e8 00 00 restore <== NOT EXECUTED
rc = fat_sync(&fs_info->fat);
2019420: 7f ff e9 c1 call 2013b24 <fat_sync>
2019424: 90 10 00 1d mov %i5, %o0
2019428: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
201942c: 7f ff c1 5f call 20099a8 <rtems_semaphore_release>
2019430: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
2019434: 81 c7 e0 08 ret
2019438: 81 e8 00 00 restore
0200e81c <msdos_unlock>:
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
200e81c: 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);
200e820: c2 06 20 08 ld [ %i0 + 8 ], %g1
200e824: 7f ff ec 61 call 20099a8 <rtems_semaphore_release>
200e828: d0 00 60 9c ld [ %g1 + 0x9c ], %o0
if (sc != RTEMS_SUCCESSFUL) {
200e82c: 80 a2 20 00 cmp %o0, 0
200e830: 02 80 00 04 be 200e840 <msdos_unlock+0x24> <== ALWAYS TAKEN
200e834: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
200e838: 7f ff ed fe call 200a030 <rtems_fatal_error_occurred> <== NOT EXECUTED
200e83c: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
200e840: 81 c7 e0 08 ret
200e844: 81 e8 00 00 restore
020040d4 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
20040d4: 9d e3 bf a0 save %sp, -96, %sp
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
20040d8: 03 00 80 73 sethi %hi(0x201cc00), %g1
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
20040dc: 80 a6 00 19 cmp %i0, %i1
20040e0: 02 80 00 03 be 20040ec <newlib_delete_hook+0x18>
20040e4: fa 00 60 60 ld [ %g1 + 0x60 ], %i5
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
20040e8: fa 06 61 54 ld [ %i1 + 0x154 ], %i5
}
if (ptr && ptr != _global_impure_ptr) {
20040ec: 80 a7 60 00 cmp %i5, 0
20040f0: 02 80 00 0b be 200411c <newlib_delete_hook+0x48> <== NEVER TAKEN
20040f4: 03 00 80 6f sethi %hi(0x201bc00), %g1
20040f8: c2 00 62 a0 ld [ %g1 + 0x2a0 ], %g1 ! 201bea0 <_global_impure_ptr>
20040fc: 80 a7 40 01 cmp %i5, %g1
2004100: 02 80 00 07 be 200411c <newlib_delete_hook+0x48>
2004104: 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);
2004108: 90 10 00 1d mov %i5, %o0
200410c: 40 00 2f 65 call 200fea0 <_fwalk>
2004110: 92 12 62 c8 or %o1, 0x2c8, %o1
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
2004114: 40 00 1b ed call 200b0c8 <_Workspace_Free>
2004118: 90 10 00 1d mov %i5, %o0
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
200411c: 80 a6 00 19 cmp %i0, %i1
2004120: 12 80 00 04 bne 2004130 <newlib_delete_hook+0x5c>
2004124: c0 26 61 54 clr [ %i1 + 0x154 ]
_REENT = 0;
2004128: 03 00 80 73 sethi %hi(0x201cc00), %g1
200412c: c0 20 60 60 clr [ %g1 + 0x60 ] ! 201cc60 <_impure_ptr>
2004130: 81 c7 e0 08 ret
2004134: 81 e8 00 00 restore
02003ec8 <newlib_free_buffers>:
* task.
*/
int newlib_free_buffers(
FILE *fp
)
{
2003ec8: 9d e3 bf a0 save %sp, -96, %sp
switch ( fileno(fp) ) {
2003ecc: 40 00 2e fa call 200fab4 <fileno>
2003ed0: 90 10 00 18 mov %i0, %o0
2003ed4: 80 a2 20 02 cmp %o0, 2
2003ed8: 18 80 00 0e bgu 2003f10 <newlib_free_buffers+0x48> <== NEVER TAKEN
2003edc: 01 00 00 00 nop
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
2003ee0: c2 16 20 0c lduh [ %i0 + 0xc ], %g1
2003ee4: 80 88 60 80 btst 0x80, %g1
2003ee8: 02 80 00 0c be 2003f18 <newlib_free_buffers+0x50> <== ALWAYS TAKEN
2003eec: 01 00 00 00 nop
free( fp->_bf._base );
2003ef0: 7f ff fd b0 call 20035b0 <free> <== NOT EXECUTED
2003ef4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
fp->_flags &= ~__SMBF;
2003ef8: c2 16 20 0c lduh [ %i0 + 0xc ], %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2003efc: 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;
2003f00: 82 08 7f 7f and %g1, -129, %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2003f04: 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;
2003f08: 10 80 00 04 b 2003f18 <newlib_free_buffers+0x50> <== NOT EXECUTED
2003f0c: c2 36 20 0c sth %g1, [ %i0 + 0xc ] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
2003f10: 40 00 2e 29 call 200f7b4 <fclose> <== NOT EXECUTED
2003f14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
return 0;
}
2003f18: 81 c7 e0 08 ret
2003f1c: 91 e8 20 00 restore %g0, 0, %o0
02001ca8 <notify>:
}
void
notify (s)
char *s;
{
2001ca8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
printf ("%s test appears to be inconsistent...\n", s);
2001cac: 11 00 80 8a sethi %hi(0x2022800), %o0 <== NOT EXECUTED
2001cb0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2001cb4: 90 12 23 18 or %o0, 0x318, %o0 <== NOT EXECUTED
2001cb8: 40 00 58 71 call 2017e7c <printf> <== NOT EXECUTED
2001cbc: 31 00 80 8a sethi %hi(0x2022800), %i0 <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
2001cc0: 40 00 58 b0 call 2017f80 <puts> <== NOT EXECUTED
2001cc4: 91 ee 23 40 restore %i0, 0x340, %o0 <== NOT EXECUTED
02006cac <null_op_fsmount_me>:
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
return -1;
}
2006cac: 81 c3 e0 08 retl <== NOT EXECUTED
2006cb0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006cbc <null_op_fsunmount_me>:
static void null_op_fsunmount_me(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
2006cbc: 81 c3 e0 08 retl <== NOT EXECUTED
02006c84 <null_op_link>:
const char *name,
size_t namelen
)
{
return -1;
}
2006c84: 81 c3 e0 08 retl <== NOT EXECUTED
2006c88: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006ca4 <null_op_mount>:
static int null_op_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
return -1;
}
2006ca4: 81 c3 e0 08 retl <== NOT EXECUTED
2006ca8: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006cd4 <null_op_readlink>:
char *buf,
size_t bufsize
)
{
return -1;
}
2006cd4: 81 c3 e0 08 retl <== NOT EXECUTED
2006cd8: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006cdc <null_op_rename>:
const char *name,
size_t namelen
)
{
return -1;
}
2006cdc: 81 c3 e0 08 retl <== NOT EXECUTED
2006ce0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006c7c <null_op_rmnod>:
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
return -1;
}
2006c7c: 81 c3 e0 08 retl <== NOT EXECUTED
2006c80: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02005d94 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
2005d94: 9d e3 bf a0 save %sp, -96, %sp
int i;
if (tty->termios.c_oflag & OPOST) {
2005d98: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
2005d9c: 80 88 60 01 btst 1, %g1
2005da0: 02 80 00 56 be 2005ef8 <oproc+0x164> <== NEVER TAKEN
2005da4: f0 2f a0 44 stb %i0, [ %fp + 0x44 ]
switch (c) {
2005da8: 84 0e 20 ff and %i0, 0xff, %g2
2005dac: 80 a0 a0 09 cmp %g2, 9
2005db0: 22 80 00 2a be,a 2005e58 <oproc+0xc4>
2005db4: c4 06 60 28 ld [ %i1 + 0x28 ], %g2
2005db8: 18 80 00 07 bgu 2005dd4 <oproc+0x40> <== ALWAYS TAKEN
2005dbc: 80 a0 a0 0a cmp %g2, 0xa
2005dc0: 80 a0 a0 08 cmp %g2, 8 <== NOT EXECUTED
2005dc4: 12 80 00 36 bne 2005e9c <oproc+0x108> <== NOT EXECUTED
2005dc8: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
2005dcc: 10 80 00 2f b 2005e88 <oproc+0xf4> <== NOT EXECUTED
2005dd0: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
2005dd4: 02 80 00 06 be 2005dec <oproc+0x58>
2005dd8: 80 a0 a0 0d cmp %g2, 0xd
2005ddc: 32 80 00 30 bne,a 2005e9c <oproc+0x108> <== ALWAYS TAKEN
2005de0: 80 88 60 02 btst 2, %g1
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
2005de4: 10 80 00 0f b 2005e20 <oproc+0x8c> <== NOT EXECUTED
2005de8: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
2005dec: 80 88 60 20 btst 0x20, %g1
2005df0: 32 80 00 02 bne,a 2005df8 <oproc+0x64> <== NEVER TAKEN
2005df4: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
tty->column = 0;
if (tty->termios.c_oflag & ONLCR) {
2005df8: 80 88 60 04 btst 4, %g1
2005dfc: 02 80 00 40 be 2005efc <oproc+0x168> <== NEVER TAKEN
2005e00: 90 07 a0 44 add %fp, 0x44, %o0
rtems_termios_puts ("\r", 1, tty);
2005e04: 11 00 80 6c sethi %hi(0x201b000), %o0
2005e08: 92 10 20 01 mov 1, %o1
2005e0c: 90 12 23 98 or %o0, 0x398, %o0
2005e10: 7f ff ff 98 call 2005c70 <rtems_termios_puts>
2005e14: 94 10 00 19 mov %i1, %o2
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
2005e18: 10 80 00 38 b 2005ef8 <oproc+0x164>
2005e1c: c0 26 60 28 clr [ %i1 + 0x28 ]
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
2005e20: 02 80 00 06 be 2005e38 <oproc+0xa4> <== NOT EXECUTED
2005e24: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
2005e28: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 <== NOT EXECUTED
2005e2c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2005e30: 02 80 00 36 be 2005f08 <oproc+0x174> <== NOT EXECUTED
2005e34: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
2005e38: 22 80 00 30 be,a 2005ef8 <oproc+0x164> <== NOT EXECUTED
2005e3c: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
c = '\n';
2005e40: 84 10 20 0a mov 0xa, %g2 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
2005e44: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
2005e48: 02 80 00 2c be 2005ef8 <oproc+0x164> <== NOT EXECUTED
2005e4c: c4 2f a0 44 stb %g2, [ %fp + 0x44 ] <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
break;
2005e50: 10 80 00 2a b 2005ef8 <oproc+0x164> <== NOT EXECUTED
2005e54: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
2005e58: 92 10 20 08 mov 8, %o1
2005e5c: 86 08 a0 07 and %g2, 7, %g3
2005e60: 92 22 40 03 sub %o1, %g3, %o1
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
2005e64: 07 00 00 06 sethi %hi(0x1800), %g3
2005e68: 82 08 40 03 and %g1, %g3, %g1
2005e6c: 80 a0 40 03 cmp %g1, %g3
2005e70: 82 00 80 09 add %g2, %o1, %g1
2005e74: 12 80 00 21 bne 2005ef8 <oproc+0x164> <== NEVER TAKEN
2005e78: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
tty->column += i;
rtems_termios_puts ( " ", i, tty);
2005e7c: 11 00 80 6c sethi %hi(0x201b000), %o0
2005e80: 10 80 00 20 b 2005f00 <oproc+0x16c>
2005e84: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 201b3a0 <rtems_filesystem_default_pathconf+0x5c>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
2005e88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005e8c: 04 80 00 1b ble 2005ef8 <oproc+0x164> <== NOT EXECUTED
2005e90: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
if (!iscntrl(c))
tty->column++;
2005e94: 10 80 00 19 b 2005ef8 <oproc+0x164> <== NOT EXECUTED
2005e98: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
2005e9c: 02 80 00 0d be 2005ed0 <oproc+0x13c> <== ALWAYS TAKEN
2005ea0: c2 0f a0 44 ldub [ %fp + 0x44 ], %g1
c = toupper(c);
2005ea4: 03 00 80 73 sethi %hi(0x201cc00), %g1 <== NOT EXECUTED
2005ea8: c2 00 60 58 ld [ %g1 + 0x58 ], %g1 ! 201cc58 <__ctype_ptr__><== NOT EXECUTED
2005eac: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED
2005eb0: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
2005eb4: c2 08 60 01 ldub [ %g1 + 1 ], %g1 <== NOT EXECUTED
2005eb8: 82 08 60 03 and %g1, 3, %g1 <== NOT EXECUTED
2005ebc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
2005ec0: 22 80 00 02 be,a 2005ec8 <oproc+0x134> <== NOT EXECUTED
2005ec4: b0 06 3f e0 add %i0, -32, %i0 <== NOT EXECUTED
2005ec8: f0 2f a0 44 stb %i0, [ %fp + 0x44 ] <== NOT EXECUTED
if (!iscntrl(c))
2005ecc: c2 0f a0 44 ldub [ %fp + 0x44 ], %g1 <== NOT EXECUTED
2005ed0: 05 00 80 73 sethi %hi(0x201cc00), %g2
2005ed4: c4 00 a0 58 ld [ %g2 + 0x58 ], %g2 ! 201cc58 <__ctype_ptr__>
2005ed8: 82 00 80 01 add %g2, %g1, %g1
2005edc: c2 08 60 01 ldub [ %g1 + 1 ], %g1
2005ee0: 80 88 60 20 btst 0x20, %g1
2005ee4: 12 80 00 06 bne 2005efc <oproc+0x168> <== NEVER TAKEN
2005ee8: 90 07 a0 44 add %fp, 0x44, %o0
tty->column++;
2005eec: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
2005ef0: 82 00 60 01 inc %g1
2005ef4: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
break;
}
}
rtems_termios_puts (&c, 1, tty);
2005ef8: 90 07 a0 44 add %fp, 0x44, %o0
2005efc: 92 10 20 01 mov 1, %o1
2005f00: 7f ff ff 5c call 2005c70 <rtems_termios_puts>
2005f04: 94 10 00 19 mov %i1, %o2
2005f08: 81 c7 e0 08 ret
2005f0c: 81 e8 00 00 restore
02004834 <partition_free>:
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
{
2004834: 9d e3 bf a0 save %sp, -96, %sp
int part_num;
if (part_desc == NULL)
2004838: 80 a6 20 00 cmp %i0, 0
200483c: 02 80 00 11 be 2004880 <partition_free+0x4c>
2004840: 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));
2004844: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
int part_num;
if (part_desc == NULL)
return;
if (is_extended(part_desc->sys_type))
2004848: 82 08 60 7f and %g1, 0x7f, %g1
200484c: 80 a0 60 05 cmp %g1, 5
2004850: 22 80 00 04 be,a 2004860 <partition_free+0x2c> <== NEVER TAKEN
2004854: ba 10 20 00 clr %i5 <== NOT EXECUTED
{
partition_free(part_desc->sub_part[part_num]);
}
}
free(part_desc);
2004858: 40 00 04 0c call 2005888 <free>
200485c: 81 e8 00 00 restore
*
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
2004860: 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]);
2004864: d0 00 60 18 ld [ %g1 + 0x18 ], %o0 <== NOT EXECUTED
2004868: 7f ff ff f3 call 2004834 <partition_free> <== NOT EXECUTED
200486c: 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;
2004870: 80 a7 60 10 cmp %i5, 0x10 <== NOT EXECUTED
2004874: 12 bf ff fc bne 2004864 <partition_free+0x30> <== NOT EXECUTED
2004878: 82 06 00 1d add %i0, %i5, %g1 <== NOT EXECUTED
200487c: 30 bf ff f7 b,a 2004858 <partition_free+0x24> <== NOT EXECUTED
2004880: 81 c7 e0 08 ret
2004884: 81 e8 00 00 restore
02004b6c <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)
{
2004b6c: 9d e3 bf 50 save %sp, -176, %sp
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
2004b70: 92 10 20 00 clr %o1
2004b74: 90 10 00 18 mov %i0, %o0
2004b78: 40 00 07 00 call 2006778 <open>
2004b7c: ba 10 20 19 mov 0x19, %i5
if (fd < 0)
2004b80: 80 a2 20 00 cmp %o0, 0
2004b84: 06 80 00 6d bl 2004d38 <partition_table_get+0x1cc> <== NEVER TAKEN
2004b88: b8 10 00 08 mov %o0, %i4
{
return RTEMS_INTERNAL_ERROR;
}
rc = fstat(fd, &dev_stat);
2004b8c: 40 00 03 69 call 2005930 <fstat>
2004b90: 92 07 bf b8 add %fp, -72, %o1
if (rc != RTEMS_SUCCESSFUL)
2004b94: 80 a2 20 00 cmp %o0, 0
2004b98: 12 80 00 66 bne 2004d30 <partition_table_get+0x1c4> <== NEVER TAKEN
2004b9c: 90 06 60 08 add %i1, 8, %o0
{
close(fd);
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
2004ba0: 92 10 00 18 mov %i0, %o1
2004ba4: 40 00 47 57 call 2016900 <strncpy>
2004ba8: 94 10 20 0f mov 0xf, %o2
disk_desc->dev = dev_stat.st_rdev;
2004bac: c4 1f bf d0 ldd [ %fp + -48 ], %g2
2004bb0: c4 3e 40 00 std %g2, [ %i1 ]
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
2004bb4: c4 07 bf f8 ld [ %fp + -8 ], %g2
2004bb8: 80 a0 a0 00 cmp %g2, 0
2004bbc: 02 80 00 03 be 2004bc8 <partition_table_get+0x5c> <== ALWAYS TAKEN
2004bc0: 82 10 22 00 mov 0x200, %g1
2004bc4: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
2004bc8: 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;
2004bcc: 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);
2004bd0: 90 10 00 1c mov %i4, %o0
2004bd4: 92 10 20 00 clr %o1
2004bd8: 94 10 20 00 clr %o2
2004bdc: 96 10 20 00 clr %o3
2004be0: 40 00 04 47 call 2005cfc <lseek>
2004be4: ba 10 20 1b mov 0x1b, %i5
if (new_off != off) {
2004be8: 80 92 00 09 orcc %o0, %o1, %g0
2004bec: 12 80 00 09 bne 2004c10 <partition_table_get+0xa4> <== NEVER TAKEN
2004bf0: d0 07 bf b0 ld [ %fp + -80 ], %o0
2004bf4: 90 10 00 1c mov %i4, %o0
2004bf8: 92 10 20 00 clr %o1
2004bfc: 7f ff ff 2e call 20048b4 <get_sector.part.0>
2004c00: 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)
2004c04: ba 92 20 00 orcc %o0, 0, %i5
2004c08: 02 80 00 06 be 2004c20 <partition_table_get+0xb4> <== ALWAYS TAKEN
2004c0c: d0 07 bf b0 ld [ %fp + -80 ], %o0
{
if (sector)
2004c10: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004c14: 02 80 00 47 be 2004d30 <partition_table_get+0x1c4> <== NOT EXECUTED
2004c18: 01 00 00 00 nop <== NOT EXECUTED
2004c1c: 30 80 00 19 b,a 2004c80 <partition_table_get+0x114> <== NOT EXECUTED
static bool
msdos_signature_check (rtems_sector_data_t *sector)
{
uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&
2004c20: c4 0a 22 02 ldub [ %o0 + 0x202 ], %g2
2004c24: 80 a0 a0 55 cmp %g2, 0x55
2004c28: 12 80 00 06 bne 2004c40 <partition_table_get+0xd4> <== NEVER TAKEN
2004c2c: 82 10 20 00 clr %g1
2004c30: c2 0a 22 03 ldub [ %o0 + 0x203 ], %g1
2004c34: 82 18 60 aa xor %g1, 0xaa, %g1
2004c38: 80 a0 00 01 cmp %g0, %g1
2004c3c: 82 60 3f ff subx %g0, -1, %g1
free(sector);
return rc;
}
/* check if the partition table structure is MS-DOS style */
if (!msdos_signature_check(sector))
2004c40: 80 a0 60 00 cmp %g1, 0
2004c44: 32 80 00 05 bne,a 2004c58 <partition_table_get+0xec> <== ALWAYS TAKEN
2004c48: b0 02 21 c2 add %o0, 0x1c2, %i0
{
free(sector);
2004c4c: 40 00 03 0f call 2005888 <free> <== NOT EXECUTED
2004c50: ba 10 20 19 mov 0x19, %i5 <== NOT EXECUTED
2004c54: 30 80 00 37 b,a 2004d30 <partition_table_get+0x1c4> <== NOT EXECUTED
2004c58: b4 10 00 19 mov %i1, %i2
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
2004c5c: b6 10 20 00 clr %i3
* RETURNS:
* RTEMS_SUCCESSFUL if success,
* RTEMS_INTERNAL_ERROR otherwise
*/
static rtems_status_code
partition_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc)
2004c60: 91 2e e0 04 sll %i3, 4, %o0
2004c64: 92 07 bf b4 add %fp, -76, %o1
2004c68: 7f ff ff 29 call 200490c <data_to_part_desc.part.1>
2004c6c: 90 06 00 08 add %i0, %o0, %o0
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
2004c70: ba 92 20 00 orcc %o0, 0, %i5
2004c74: 02 80 00 06 be 2004c8c <partition_table_get+0x120> <== ALWAYS TAKEN
2004c78: c2 07 bf b4 ld [ %fp + -76 ], %g1
{
free(sector);
2004c7c: d0 07 bf b0 ld [ %fp + -80 ], %o0 <== NOT EXECUTED
2004c80: 40 00 03 02 call 2005888 <free> <== NOT EXECUTED
2004c84: 01 00 00 00 nop <== NOT EXECUTED
2004c88: 30 80 00 2a b,a 2004d30 <partition_table_get+0x1c4> <== NOT EXECUTED
return rc;
}
if (part_desc != NULL)
2004c8c: 80 a0 60 00 cmp %g1, 0
2004c90: 02 80 00 0b be 2004cbc <partition_table_get+0x150> <== NEVER TAKEN
2004c94: 84 06 e0 01 add %i3, 1, %g2
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
part_desc->end = part_desc->start + part_desc->size - 1;
2004c98: c6 00 60 04 ld [ %g1 + 4 ], %g3
return rc;
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
2004c9c: c4 28 60 02 stb %g2, [ %g1 + 2 ]
part_desc->disk_desc = disk_desc;
part_desc->end = part_desc->start + part_desc->size - 1;
2004ca0: c4 00 60 08 ld [ %g1 + 8 ], %g2
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
2004ca4: f2 20 60 10 st %i1, [ %g1 + 0x10 ]
part_desc->end = part_desc->start + part_desc->size - 1;
2004ca8: 84 00 c0 02 add %g3, %g2, %g2
2004cac: 84 00 bf ff add %g2, -1, %g2
2004cb0: c4 20 60 0c st %g2, [ %g1 + 0xc ]
disk_desc->partitions[part_num] = part_desc;
2004cb4: 10 80 00 03 b 2004cc0 <partition_table_get+0x154>
2004cb8: c2 26 a0 28 st %g1, [ %i2 + 0x28 ]
}
else
{
disk_desc->partitions[part_num] = NULL;
2004cbc: c0 26 a0 28 clr [ %i2 + 0x28 ] <== NOT EXECUTED
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
2004cc0: b6 06 e0 01 inc %i3
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
2004cc4: 80 a6 e0 04 cmp %i3, 4
2004cc8: 12 bf ff e6 bne 2004c60 <partition_table_get+0xf4>
2004ccc: b4 06 a0 04 add %i2, 4, %i2
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
2004cd0: 40 00 02 ee call 2005888 <free>
2004cd4: d0 07 bf b0 ld [ %fp + -80 ], %o0
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
2004cd8: f6 26 60 24 st %i3, [ %i1 + 0x24 ]
2004cdc: b6 10 20 00 clr %i3
* RETURNS:
* RTEMS_SUCCESSFUL if success,
* RTEMS_INTERNAL_ERROR otherwise
*/
static rtems_status_code
partition_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc)
2004ce0: b4 06 40 1b add %i1, %i3, %i2
but we are to process each primary partition */
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
part_desc = disk_desc->partitions[part_num];
2004ce4: d4 06 a0 28 ld [ %i2 + 0x28 ], %o2
if (part_desc != NULL && is_extended(part_desc->sys_type))
2004ce8: 80 a2 a0 00 cmp %o2, 0
2004cec: 02 80 00 0d be 2004d20 <partition_table_get+0x1b4> <== NEVER TAKEN
2004cf0: 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));
2004cf4: 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))
2004cf8: 82 08 60 7f and %g1, 0x7f, %g1
2004cfc: 80 a0 60 05 cmp %g1, 5
2004d00: 32 80 00 09 bne,a 2004d24 <partition_table_get+0x1b8>
2004d04: b6 06 e0 04 add %i3, 4, %i3
{
read_extended_partition(fd, part_desc->start, part_desc);
2004d08: d2 02 a0 04 ld [ %o2 + 4 ], %o1
2004d0c: 7f ff ff 31 call 20049d0 <read_extended_partition>
2004d10: 90 10 00 1c mov %i4, %o0
free(part_desc);
2004d14: 40 00 02 dd call 2005888 <free>
2004d18: d0 07 bf b4 ld [ %fp + -76 ], %o0
disk_desc->partitions[part_num] = NULL;
2004d1c: c0 26 a0 28 clr [ %i2 + 0x28 ]
2004d20: b6 06 e0 04 add %i3, 4, %i3
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
/* There cannot be more than one extended partition,
but we are to process each primary partition */
for (part_num = 0;
2004d24: 80 a6 e0 10 cmp %i3, 0x10
2004d28: 12 bf ff ef bne 2004ce4 <partition_table_get+0x178>
2004d2c: b4 06 40 1b add %i1, %i3, %i2
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
RTEMS_IDE_SECTOR_SIZE;
rc = read_mbr(fd, disk_desc);
close(fd);
2004d30: 40 00 02 19 call 2005594 <close>
2004d34: 90 10 00 1c mov %i4, %o0
return rc;
}
2004d38: 81 c7 e0 08 ret
2004d3c: 91 e8 00 1d restore %g0, %i5, %o0
02004598 <pathconf>:
*/
long pathconf(
const char *path,
int name
)
{
2004598: 9d e3 bf a0 save %sp, -96, %sp
int status;
int fd;
fd = open( path, O_RDONLY );
200459c: 92 10 20 00 clr %o1
20045a0: 7f ff ff 6f call 200435c <open>
20045a4: 90 10 00 18 mov %i0, %o0
if ( fd == -1 )
20045a8: 80 a2 3f ff cmp %o0, -1
20045ac: 02 80 00 09 be 20045d0 <pathconf+0x38> <== ALWAYS TAKEN
20045b0: ba 10 00 08 mov %o0, %i5
return -1;
status = fpathconf( fd, name );
20045b4: 40 00 14 15 call 2009608 <fpathconf> <== NOT EXECUTED
20045b8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20045bc: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
(void) close( fd );
20045c0: 40 00 13 e5 call 2009554 <close> <== NOT EXECUTED
20045c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return status;
20045c8: 81 c7 e0 08 ret <== NOT EXECUTED
20045cc: 81 e8 00 00 restore <== NOT EXECUTED
}
20045d0: 81 c7 e0 08 ret
20045d4: 91 e8 3f ff restore %g0, -1, %o0
0200cfac <pipe_create>:
static uint16_t rtems_pipe_no = 0;
int pipe_create(
int filsdes[2]
)
{
200cfac: 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)
200cfb0: 11 00 80 81 sethi %hi(0x2020400), %o0
200cfb4: 92 10 21 ff mov 0x1ff, %o1
200cfb8: 40 00 05 4e call 200e4f0 <rtems_mkdir>
200cfbc: 90 12 23 30 or %o0, 0x330, %o0
200cfc0: 80 a2 20 00 cmp %o0, 0
200cfc4: 12 80 00 47 bne 200d0e0 <pipe_create+0x134>
200cfc8: 03 00 00 19 sethi %hi(0x6400), %g1
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
200cfcc: 82 10 62 6f or %g1, 0x26f, %g1 ! 666f <PROM_START+0x666f>
200cfd0: c2 37 bf f8 sth %g1, [ %fp + -8 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
200cfd4: 03 00 80 88 sethi %hi(0x2022000), %g1
200cfd8: d4 10 62 90 lduh [ %g1 + 0x290 ], %o2 ! 2022290 <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);
200cfdc: 05 0b dd 1b sethi %hi(0x2f746c00), %g2
200cfe0: 84 10 a1 70 or %g2, 0x170, %g2 ! 2f746d70 <RAM_END+0x2d346d70>
200cfe4: 07 0b cb 99 sethi %hi(0x2f2e6400), %g3
200cfe8: 86 10 e2 69 or %g3, 0x269, %g3 ! 2f2e6669 <RAM_END+0x2cee6669>
200cfec: c4 3f bf f0 std %g2, [ %fp + -16 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
200cff0: 84 02 a0 01 add %o2, 1, %g2
200cff4: 90 07 bf fa add %fp, -6, %o0
200cff8: c4 30 62 90 sth %g2, [ %g1 + 0x290 ]
200cffc: 95 2a a0 10 sll %o2, 0x10, %o2
200d000: 13 00 80 81 sethi %hi(0x2020400), %o1
200d004: 95 32 a0 10 srl %o2, 0x10, %o2
200d008: 40 00 13 56 call 2011d60 <sprintf>
200d00c: 92 12 63 38 or %o1, 0x338, %o1
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
200d010: 90 07 bf f0 add %fp, -16, %o0
200d014: 40 00 04 8d call 200e248 <mkfifo>
200d018: 92 10 21 80 mov 0x180, %o1
200d01c: 80 a2 20 00 cmp %o0, 0
200d020: 02 80 00 05 be 200d034 <pipe_create+0x88> <== ALWAYS TAKEN
200d024: 90 07 bf f0 add %fp, -16, %o0
if (errno != EEXIST){
200d028: 40 00 0f e3 call 2010fb4 <__errno> <== NOT EXECUTED
200d02c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200d030: 30 80 00 2d b,a 200d0e4 <pipe_create+0x138> <== NOT EXECUTED
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
200d034: 7f ff df 15 call 2004c88 <open>
200d038: 13 00 00 10 sethi %hi(0x4000), %o1
if (filsdes[0] < 0) {
200d03c: 80 a2 20 00 cmp %o0, 0
200d040: 16 80 00 06 bge 200d058 <pipe_create+0xac>
200d044: d0 26 00 00 st %o0, [ %i0 ]
err = errno;
200d048: 40 00 0f db call 2010fb4 <__errno>
200d04c: 01 00 00 00 nop
200d050: 10 80 00 1c b 200d0c0 <pipe_create+0x114>
200d054: fa 02 00 00 ld [ %o0 ], %i5
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
200d058: 03 00 80 86 sethi %hi(0x2021800), %g1
200d05c: c4 00 61 a4 ld [ %g1 + 0x1a4 ], %g2 ! 20219a4 <rtems_libio_number_iops>
200d060: 80 a2 00 02 cmp %o0, %g2
200d064: 1a 80 00 08 bcc 200d084 <pipe_create+0xd8> <== NEVER TAKEN
200d068: 82 10 20 00 clr %g1
200d06c: 83 2a 20 03 sll %o0, 3, %g1
200d070: 91 2a 20 06 sll %o0, 6, %o0
200d074: 90 22 00 01 sub %o0, %g1, %o0
200d078: 03 00 80 89 sethi %hi(0x2022400), %g1
200d07c: c2 00 60 0c ld [ %g1 + 0xc ], %g1 ! 202240c <rtems_libio_iops>
200d080: 82 00 40 08 add %g1, %o0, %g1
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
200d084: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
filsdes[1] = open(fifopath, O_WRONLY);
200d088: 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;
200d08c: 84 08 bf fe and %g2, -2, %g2
filsdes[1] = open(fifopath, O_WRONLY);
200d090: 92 10 20 01 mov 1, %o1
200d094: 7f ff de fd call 2004c88 <open>
200d098: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
200d09c: d0 26 20 04 st %o0, [ %i0 + 4 ]
if (filsdes[1] < 0) {
200d0a0: 80 a2 20 00 cmp %o0, 0
200d0a4: 16 80 00 07 bge 200d0c0 <pipe_create+0x114>
200d0a8: ba 10 20 00 clr %i5
err = errno;
200d0ac: 40 00 0f c2 call 2010fb4 <__errno>
200d0b0: 01 00 00 00 nop
200d0b4: fa 02 00 00 ld [ %o0 ], %i5
close(filsdes[0]);
200d0b8: 7f ff da e8 call 2003c58 <close>
200d0bc: d0 06 00 00 ld [ %i0 ], %o0
}
unlink(fifopath);
200d0c0: 7f ff ea a6 call 2007b58 <unlink>
200d0c4: 90 07 bf f0 add %fp, -16, %o0
}
if(err != 0)
200d0c8: 80 a7 60 00 cmp %i5, 0
200d0cc: 02 80 00 06 be 200d0e4 <pipe_create+0x138>
200d0d0: b0 10 20 00 clr %i0
rtems_set_errno_and_return_minus_one(err);
200d0d4: 40 00 0f b8 call 2010fb4 <__errno>
200d0d8: 01 00 00 00 nop
200d0dc: fa 22 00 00 st %i5, [ %o0 ]
{
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
200d0e0: b0 10 3f ff mov -1, %i0
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
200d0e4: 81 c7 e0 08 ret
200d0e8: 81 e8 00 00 restore
0200e4d4 <pipe_ioctl>:
pipe_control_t *pipe,
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
200e4d4: 9d e3 bf a0 save %sp, -96, %sp
if (cmd == FIONREAD) {
200e4d8: 03 10 01 19 sethi %hi(0x40046400), %g1
200e4dc: 82 10 62 7f or %g1, 0x27f, %g1 ! 4004667f <RAM_END+0x3dc4667f>
200e4e0: 80 a6 40 01 cmp %i1, %g1
200e4e4: 12 80 00 11 bne 200e528 <pipe_ioctl+0x54>
200e4e8: 80 a6 a0 00 cmp %i2, 0
if (buffer == NULL)
200e4ec: 02 80 00 11 be 200e530 <pipe_ioctl+0x5c>
200e4f0: 92 10 20 00 clr %o1
return -EFAULT;
if (! PIPE_LOCK(pipe))
200e4f4: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
200e4f8: 7f ff ea 97 call 2008f54 <rtems_semaphore_obtain>
200e4fc: 94 10 20 00 clr %o2
200e500: 80 a2 20 00 cmp %o0, 0
200e504: 12 80 00 0d bne 200e538 <pipe_ioctl+0x64> <== NEVER TAKEN
200e508: 01 00 00 00 nop
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
200e50c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
PIPE_UNLOCK(pipe);
200e510: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
200e514: c2 26 80 00 st %g1, [ %i2 ]
PIPE_UNLOCK(pipe);
200e518: 7f ff ea d8 call 2009078 <rtems_semaphore_release>
200e51c: b0 10 20 00 clr %i0
return 0;
200e520: 81 c7 e0 08 ret
200e524: 81 e8 00 00 restore
}
return -EINVAL;
200e528: 81 c7 e0 08 ret
200e52c: 91 e8 3f ea restore %g0, -22, %o0
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
200e530: 81 c7 e0 08 ret
200e534: 91 e8 3f f2 restore %g0, -14, %o0
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
200e538: 81 c7 e0 08 ret <== NOT EXECUTED
200e53c: 91 e8 3f fc restore %g0, -4, %o0 <== NOT EXECUTED
0200e168 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
200e168: 9d e3 bf 98 save %sp, -104, %sp
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
200e16c: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
200e170: 92 10 20 00 clr %o1
200e174: 94 10 20 00 clr %o2
200e178: 7f ff eb 77 call 2008f54 <rtems_semaphore_obtain>
200e17c: ba 10 00 18 mov %i0, %i5
200e180: 80 a2 20 00 cmp %o0, 0
200e184: 32 80 00 5d bne,a 200e2f8 <pipe_read+0x190> <== NEVER TAKEN
200e188: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
200e18c: 10 80 00 4d b 200e2c0 <pipe_read+0x158>
200e190: b0 10 20 00 clr %i0
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
200e194: 80 a0 60 00 cmp %g1, 0
200e198: 32 80 00 04 bne,a 200e1a8 <pipe_read+0x40>
200e19c: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
200e1a0: 10 80 00 4c b 200e2d0 <pipe_read+0x168>
200e1a4: b8 10 20 00 clr %i4
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
200e1a8: 80 88 60 01 btst 1, %g1
200e1ac: 32 80 00 49 bne,a 200e2d0 <pipe_read+0x168>
200e1b0: 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 ++;
200e1b4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
PIPE_UNLOCK(pipe);
200e1b8: 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 ++;
200e1bc: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
200e1c0: 7f ff eb ae call 2009078 <rtems_semaphore_release>
200e1c4: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_READWAIT(pipe))
200e1c8: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e1cc: 40 00 05 6e call 200f784 <rtems_barrier_wait>
200e1d0: 92 10 20 00 clr %o1
200e1d4: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e1d8: 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))
200e1dc: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e1e0: 92 10 20 00 clr %o1
200e1e4: 94 10 20 00 clr %o2
200e1e8: 7f ff eb 5b call 2008f54 <rtems_semaphore_obtain>
200e1ec: b8 0f 3f fc and %i4, -4, %i4
200e1f0: 80 a2 20 00 cmp %o0, 0
200e1f4: 12 80 00 3b bne 200e2e0 <pipe_read+0x178> <== NEVER TAKEN
200e1f8: 80 a7 20 00 cmp %i4, 0
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
200e1fc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200e200: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
200e204: 12 80 00 33 bne 200e2d0 <pipe_read+0x168> <== NEVER TAKEN
200e208: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
200e20c: f8 07 60 0c ld [ %i5 + 0xc ], %i4
200e210: 80 a7 20 00 cmp %i4, 0
200e214: 22 bf ff e0 be,a 200e194 <pipe_read+0x2c>
200e218: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
200e21c: 82 26 80 18 sub %i2, %i0, %g1
200e220: 80 a7 00 01 cmp %i4, %g1
200e224: 38 80 00 02 bgu,a 200e22c <pipe_read+0xc4>
200e228: b8 10 00 01 mov %g1, %i4
chunk1 = pipe->Size - pipe->Start;
200e22c: c2 07 60 08 ld [ %i5 + 8 ], %g1
200e230: e0 07 60 04 ld [ %i5 + 4 ], %l0
200e234: d2 07 40 00 ld [ %i5 ], %o1
200e238: a0 24 00 01 sub %l0, %g1, %l0
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
200e23c: 94 10 00 1c mov %i4, %o2
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
200e240: 80 a7 00 10 cmp %i4, %l0
200e244: 90 06 40 18 add %i1, %i0, %o0
200e248: 04 80 00 09 ble 200e26c <pipe_read+0x104>
200e24c: 92 02 40 01 add %o1, %g1, %o1
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
200e250: 40 00 11 1d call 20126c4 <memcpy>
200e254: 94 10 00 10 mov %l0, %o2
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
200e258: 90 06 00 10 add %i0, %l0, %o0
200e25c: d2 07 40 00 ld [ %i5 ], %o1
200e260: 90 06 40 08 add %i1, %o0, %o0
200e264: 10 80 00 02 b 200e26c <pipe_read+0x104>
200e268: 94 27 00 10 sub %i4, %l0, %o2
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
200e26c: 40 00 11 16 call 20126c4 <memcpy>
200e270: 01 00 00 00 nop
pipe->Start += chunk;
200e274: d0 07 60 08 ld [ %i5 + 8 ], %o0
pipe->Start %= pipe->Size;
200e278: d2 07 60 04 ld [ %i5 + 4 ], %o1
200e27c: 40 00 41 11 call 201e6c0 <.urem>
200e280: 90 07 00 08 add %i4, %o0, %o0
pipe->Length -= chunk;
200e284: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
200e288: d0 27 60 08 st %o0, [ %i5 + 8 ]
pipe->Length -= chunk;
200e28c: 82 20 40 1c sub %g1, %i4, %g1
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
200e290: 80 a0 60 00 cmp %g1, 0
200e294: 12 80 00 03 bne 200e2a0 <pipe_read+0x138>
200e298: c2 27 60 0c st %g1, [ %i5 + 0xc ]
pipe->Start = 0;
200e29c: c0 27 60 08 clr [ %i5 + 8 ]
if (pipe->waitingWriters > 0)
200e2a0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200e2a4: 80 a0 60 00 cmp %g1, 0
200e2a8: 22 80 00 06 be,a 200e2c0 <pipe_read+0x158>
200e2ac: b0 06 00 1c add %i0, %i4, %i0
PIPE_WAKEUPWRITERS(pipe);
200e2b0: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e2b4: 40 00 05 1e call 200f72c <rtems_barrier_release>
200e2b8: 92 07 bf fc add %fp, -4, %o1
read += chunk;
200e2bc: b0 06 00 1c add %i0, %i4, %i0
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
200e2c0: 80 a6 00 1a cmp %i0, %i2
200e2c4: 2a bf ff d3 bcs,a 200e210 <pipe_read+0xa8>
200e2c8: f8 07 60 0c ld [ %i5 + 0xc ], %i4
200e2cc: b8 10 20 00 clr %i4
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
200e2d0: 7f ff eb 6a call 2009078 <rtems_semaphore_release>
200e2d4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
if (read > 0)
200e2d8: 10 80 00 04 b 200e2e8 <pipe_read+0x180>
200e2dc: 80 a6 20 00 cmp %i0, 0
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
200e2e0: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
200e2e4: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
200e2e8: 14 80 00 04 bg 200e2f8 <pipe_read+0x190>
200e2ec: 01 00 00 00 nop
return read;
return ret;
200e2f0: 81 c7 e0 08 ret
200e2f4: 91 e8 00 1c restore %g0, %i4, %o0
}
200e2f8: 81 c7 e0 08 ret
200e2fc: 81 e8 00 00 restore
0200dc58 <pipe_release>:
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200dc58: 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);
200dc5c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
200dc60: 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)
200dc64: 80 88 60 02 btst 2, %g1
200dc68: 02 80 00 05 be 200dc7c <pipe_release+0x24>
200dc6c: b8 08 60 06 and %g1, 6, %i4
pipe->Readers --;
200dc70: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200dc74: 84 00 bf ff add %g2, -1, %g2
200dc78: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
if (mode & LIBIO_FLAGS_WRITE)
200dc7c: 80 88 60 04 btst 4, %g1
200dc80: 02 80 00 05 be 200dc94 <pipe_release+0x3c>
200dc84: 01 00 00 00 nop
pipe->Writers --;
200dc88: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200dc8c: 82 00 7f ff add %g1, -1, %g1
200dc90: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
PIPE_UNLOCK(pipe);
200dc94: 7f ff ec f9 call 2009078 <rtems_semaphore_release>
200dc98: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (pipe->Readers == 0 && pipe->Writers == 0) {
200dc9c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200dca0: 80 a0 60 00 cmp %g1, 0
200dca4: 12 80 00 0d bne 200dcd8 <pipe_release+0x80>
200dca8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200dcac: 80 a0 60 00 cmp %g1, 0
200dcb0: 12 80 00 06 bne 200dcc8 <pipe_release+0x70>
200dcb4: 80 a7 20 04 cmp %i4, 4
#if 0
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
200dcb8: 7f ff ff dd call 200dc2c <pipe_free>
200dcbc: 90 10 00 1d mov %i5, %o0
*pipep = NULL;
200dcc0: 10 80 00 0e b 200dcf8 <pipe_release+0xa0>
200dcc4: c0 26 00 00 clr [ %i0 ]
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
200dcc8: 02 80 00 05 be 200dcdc <pipe_release+0x84> <== NEVER TAKEN
200dccc: 80 a0 60 00 cmp %g1, 0
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
200dcd0: 10 80 00 08 b 200dcf0 <pipe_release+0x98>
200dcd4: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
200dcd8: 80 a0 60 00 cmp %g1, 0
200dcdc: 12 80 00 07 bne 200dcf8 <pipe_release+0xa0> <== NEVER TAKEN
200dce0: 80 a7 20 02 cmp %i4, 2
200dce4: 02 80 00 06 be 200dcfc <pipe_release+0xa4> <== NEVER TAKEN
200dce8: 03 00 80 8c sethi %hi(0x2023000), %g1
PIPE_WAKEUPREADERS(pipe);
200dcec: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200dcf0: 40 00 06 8f call 200f72c <rtems_barrier_release>
200dcf4: 92 07 bf fc add %fp, -4, %o1
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
200dcf8: 03 00 80 8c sethi %hi(0x2023000), %g1
200dcfc: 7f ff ec df call 2009078 <rtems_semaphore_release>
200dd00: d0 00 61 80 ld [ %g1 + 0x180 ], %o0 ! 2023180 <pipe_semaphore>
200dd04: 81 c7 e0 08 ret
200dd08: 81 e8 00 00 restore
0200e300 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
200e300: 9d e3 bf 98 save %sp, -104, %sp
200e304: ba 10 00 18 mov %i0, %i5
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
200e308: 80 a6 a0 00 cmp %i2, 0
200e30c: 02 80 00 70 be 200e4cc <pipe_write+0x1cc> <== NEVER TAKEN
200e310: b0 10 20 00 clr %i0
return 0;
if (! PIPE_LOCK(pipe))
200e314: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e318: 92 10 20 00 clr %o1
200e31c: 7f ff eb 0e call 2008f54 <rtems_semaphore_obtain>
200e320: 94 10 20 00 clr %o2
200e324: 80 a2 20 00 cmp %o0, 0
200e328: 32 80 00 69 bne,a 200e4cc <pipe_write+0x1cc> <== NEVER TAKEN
200e32c: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
return -EINTR;
if (pipe->Readers == 0) {
200e330: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e334: 80 a0 60 00 cmp %g1, 0
200e338: 02 80 00 54 be 200e488 <pipe_write+0x188>
200e33c: b8 10 3f e0 mov -32, %i4
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
200e340: c2 07 60 04 ld [ %i5 + 4 ], %g1
200e344: 80 a6 80 01 cmp %i2, %g1
200e348: 18 80 00 03 bgu 200e354 <pipe_write+0x54> <== NEVER TAKEN
200e34c: a2 10 20 01 mov 1, %l1
200e350: a2 10 00 1a mov %i2, %l1
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
200e354: 10 80 00 49 b 200e478 <pipe_write+0x178>
200e358: b0 10 20 00 clr %i0
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
200e35c: 80 88 60 01 btst 1, %g1
200e360: 32 80 00 4a bne,a 200e488 <pipe_write+0x188>
200e364: 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 ++;
200e368: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
PIPE_UNLOCK(pipe);
200e36c: 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 ++;
200e370: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
200e374: 7f ff eb 41 call 2009078 <rtems_semaphore_release>
200e378: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
if (! PIPE_WRITEWAIT(pipe))
200e37c: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e380: 40 00 05 01 call 200f784 <rtems_barrier_wait>
200e384: 92 10 20 00 clr %o1
200e388: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e38c: 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))
200e390: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e394: 92 10 20 00 clr %o1
200e398: 94 10 20 00 clr %o2
200e39c: 7f ff ea ee call 2008f54 <rtems_semaphore_obtain>
200e3a0: b8 0f 3f fc and %i4, -4, %i4
200e3a4: 80 a2 20 00 cmp %o0, 0
200e3a8: 12 80 00 43 bne 200e4b4 <pipe_write+0x1b4> <== NEVER TAKEN
200e3ac: 80 a7 20 00 cmp %i4, 0
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
200e3b0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200e3b4: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
200e3b8: 12 80 00 34 bne 200e488 <pipe_write+0x188> <== NEVER TAKEN
200e3bc: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
goto out_locked;
if (pipe->Readers == 0) {
200e3c0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e3c4: 80 a0 60 00 cmp %g1, 0
200e3c8: 02 80 00 30 be 200e488 <pipe_write+0x188> <== NEVER TAKEN
200e3cc: b8 10 3f e0 mov -32, %i4
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
200e3d0: e0 07 60 04 ld [ %i5 + 4 ], %l0
200e3d4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200e3d8: b8 24 00 01 sub %l0, %g1, %i4
200e3dc: 80 a7 00 11 cmp %i4, %l1
200e3e0: 2a bf ff df bcs,a 200e35c <pipe_write+0x5c>
200e3e4: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
200e3e8: 84 26 80 18 sub %i2, %i0, %g2
200e3ec: 80 a7 00 02 cmp %i4, %g2
200e3f0: 38 80 00 02 bgu,a 200e3f8 <pipe_write+0xf8>
200e3f4: b8 10 00 02 mov %g2, %i4
chunk1 = pipe->Size - PIPE_WSTART(pipe);
200e3f8: d0 07 60 08 ld [ %i5 + 8 ], %o0
200e3fc: 92 10 00 10 mov %l0, %o1
200e400: 40 00 40 b0 call 201e6c0 <.urem>
200e404: 90 00 40 08 add %g1, %o0, %o0
200e408: c2 07 40 00 ld [ %i5 ], %g1
200e40c: a0 24 00 08 sub %l0, %o0, %l0
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
200e410: 94 10 00 1c mov %i4, %o2
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
if (chunk > chunk1) {
200e414: 80 a7 00 10 cmp %i4, %l0
200e418: 92 06 40 18 add %i1, %i0, %o1
200e41c: 04 80 00 09 ble 200e440 <pipe_write+0x140>
200e420: 90 00 40 08 add %g1, %o0, %o0
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
200e424: 40 00 10 a8 call 20126c4 <memcpy>
200e428: 94 10 00 10 mov %l0, %o2
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
200e42c: 92 04 00 18 add %l0, %i0, %o1
200e430: d0 07 40 00 ld [ %i5 ], %o0
200e434: 92 06 40 09 add %i1, %o1, %o1
200e438: 10 80 00 02 b 200e440 <pipe_write+0x140>
200e43c: 94 27 00 10 sub %i4, %l0, %o2
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
200e440: 40 00 10 a1 call 20126c4 <memcpy>
200e444: 01 00 00 00 nop
pipe->Length += chunk;
200e448: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200e44c: 82 00 40 1c add %g1, %i4, %g1
200e450: c2 27 60 0c st %g1, [ %i5 + 0xc ]
if (pipe->waitingReaders > 0)
200e454: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200e458: 80 a0 60 00 cmp %g1, 0
200e45c: 22 80 00 06 be,a 200e474 <pipe_write+0x174>
200e460: b0 06 00 1c add %i0, %i4, %i0
PIPE_WAKEUPREADERS(pipe);
200e464: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e468: 40 00 04 b1 call 200f72c <rtems_barrier_release>
200e46c: 92 07 bf fc add %fp, -4, %o1
written += chunk;
200e470: b0 06 00 1c add %i0, %i4, %i0
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
200e474: a2 10 20 01 mov 1, %l1
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
200e478: 80 a6 00 1a cmp %i0, %i2
200e47c: 2a bf ff d6 bcs,a 200e3d4 <pipe_write+0xd4>
200e480: e0 07 60 04 ld [ %i5 + 4 ], %l0
200e484: b8 10 20 00 clr %i4
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
200e488: 7f ff ea fc call 2009078 <rtems_semaphore_release>
200e48c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
200e490: 80 a7 3f e0 cmp %i4, -32
200e494: 32 80 00 0a bne,a 200e4bc <pipe_write+0x1bc>
200e498: 80 a6 20 00 cmp %i0, 0
kill(getpid(), SIGPIPE);
200e49c: 40 00 01 23 call 200e928 <getpid>
200e4a0: 01 00 00 00 nop
200e4a4: 40 00 02 9b call 200ef10 <kill>
200e4a8: 92 10 20 0d mov 0xd, %o1 ! d <PROM_START+0xd>
#endif
if (written > 0)
200e4ac: 10 80 00 04 b 200e4bc <pipe_write+0x1bc>
200e4b0: 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;
200e4b4: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
200e4b8: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
200e4bc: 14 80 00 04 bg 200e4cc <pipe_write+0x1cc>
200e4c0: 01 00 00 00 nop
200e4c4: 81 c7 e0 08 ret
200e4c8: 91 e8 00 1c restore %g0, %i4, %o0
return written;
return ret;
}
200e4cc: 81 c7 e0 08 ret
200e4d0: 81 e8 00 00 restore
02007ab8 <posix_memalign>:
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
2007ab8: 05 00 80 90 sethi %hi(0x2024000), %g2
2007abc: 84 10 a2 00 or %g2, 0x200, %g2 ! 2024200 <rtems_malloc_statistics>
2007ac0: c6 00 a0 08 ld [ %g2 + 8 ], %g3
2007ac4: 86 00 e0 01 inc %g3
2007ac8: c6 20 a0 08 st %g3, [ %g2 + 8 ]
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
2007acc: 84 02 7f ff add %o1, -1, %g2
2007ad0: 80 88 80 09 btst %g2, %o1
2007ad4: 12 80 00 07 bne 2007af0 <posix_memalign+0x38> <== NEVER TAKEN
2007ad8: 80 a2 60 03 cmp %o1, 3
2007adc: 08 80 00 05 bleu 2007af0 <posix_memalign+0x38>
2007ae0: 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 );
2007ae4: 82 13 c0 00 mov %o7, %g1
2007ae8: 40 00 00 85 call 2007cfc <rtems_memalign>
2007aec: 9e 10 40 00 mov %g1, %o7
}
2007af0: 81 c3 e0 08 retl
2007af4: 90 10 20 16 mov 0x16, %o0
0200c1e8 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
200c1e8: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
200c1ec: 80 a0 60 00 cmp %g1, 0
200c1f0: 02 80 00 0f be 200c22c <pthread_attr_setschedpolicy+0x44>
200c1f4: 90 10 20 16 mov 0x16, %o0
200c1f8: c4 00 40 00 ld [ %g1 ], %g2
200c1fc: 80 a0 a0 00 cmp %g2, 0
200c200: 02 80 00 0b be 200c22c <pthread_attr_setschedpolicy+0x44>
200c204: 80 a2 60 04 cmp %o1, 4
return EINVAL;
switch ( policy ) {
200c208: 38 80 00 09 bgu,a 200c22c <pthread_attr_setschedpolicy+0x44>
200c20c: 90 10 20 86 mov 0x86, %o0
200c210: 84 10 20 01 mov 1, %g2
200c214: 85 28 80 09 sll %g2, %o1, %g2
200c218: 80 88 a0 17 btst 0x17, %g2
200c21c: 22 80 00 04 be,a 200c22c <pthread_attr_setschedpolicy+0x44><== NEVER TAKEN
200c220: 90 10 20 86 mov 0x86, %o0 <== NOT EXECUTED
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
200c224: d2 20 60 14 st %o1, [ %g1 + 0x14 ]
200c228: 90 10 20 00 clr %o0
return 0;
default:
return ENOTSUP;
}
}
200c22c: 81 c3 e0 08 retl
02007940 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
2007940: 9d e3 bf 90 save %sp, -112, %sp
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
2007944: 80 a6 20 00 cmp %i0, 0
2007948: 12 80 00 04 bne 2007958 <pthread_barrier_init+0x18>
200794c: 80 a6 a0 00 cmp %i2, 0
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
2007950: 81 c7 e0 08 ret
2007954: 91 e8 20 16 restore %g0, 0x16, %o0
* Error check parameters
*/
if ( !barrier )
return EINVAL;
if ( count == 0 )
2007958: 22 80 00 1e be,a 20079d0 <pthread_barrier_init+0x90>
200795c: b0 10 20 16 mov 0x16, %i0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
2007960: 80 a6 60 00 cmp %i1, 0
2007964: 32 80 00 06 bne,a 200797c <pthread_barrier_init+0x3c>
2007968: c2 06 40 00 ld [ %i1 ], %g1
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
200796c: 90 07 bf f8 add %fp, -8, %o0
2007970: 7f ff ff bc call 2007860 <pthread_barrierattr_init>
2007974: 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 )
2007978: c2 06 40 00 ld [ %i1 ], %g1
200797c: 80 a0 60 00 cmp %g1, 0
2007980: 22 80 00 14 be,a 20079d0 <pthread_barrier_init+0x90>
2007984: b0 10 20 16 mov 0x16, %i0
return EINVAL;
switch ( the_attr->process_shared ) {
2007988: c2 06 60 04 ld [ %i1 + 4 ], %g1
200798c: 80 a0 60 00 cmp %g1, 0
2007990: 32 80 00 10 bne,a 20079d0 <pthread_barrier_init+0x90> <== NEVER TAKEN
2007994: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2007998: 03 00 80 7a sethi %hi(0x201e800), %g1
200799c: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 201ebe0 <_Thread_Dispatch_disable_level>
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
20079a0: c0 27 bf f0 clr [ %fp + -16 ]
the_attributes.maximum_count = count;
20079a4: f4 27 bf f4 st %i2, [ %fp + -12 ]
++level;
20079a8: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
20079ac: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ]
* 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 *)
20079b0: 39 00 80 7b sethi %hi(0x201ec00), %i4
20079b4: 40 00 08 7a call 2009b9c <_Objects_Allocate>
20079b8: 90 17 23 74 or %i4, 0x374, %o0 ! 201ef74 <_POSIX_Barrier_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
20079bc: ba 92 20 00 orcc %o0, 0, %i5
20079c0: 12 80 00 06 bne 20079d8 <pthread_barrier_init+0x98>
20079c4: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
20079c8: 40 00 0d 73 call 200af94 <_Thread_Enable_dispatch>
20079cc: b0 10 20 0b mov 0xb, %i0
20079d0: 81 c7 e0 08 ret
20079d4: 81 e8 00 00 restore
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
20079d8: 40 00 05 ee call 2009190 <_CORE_barrier_Initialize>
20079dc: 92 07 bf f0 add %fp, -16, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20079e0: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20079e4: b8 17 23 74 or %i4, 0x374, %i4
20079e8: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20079ec: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20079f0: 85 28 a0 02 sll %g2, 2, %g2
20079f4: 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;
20079f8: c0 27 60 0c clr [ %i5 + 0xc ]
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
20079fc: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
2007a00: 40 00 0d 65 call 200af94 <_Thread_Enable_dispatch>
2007a04: b0 10 20 00 clr %i0
2007a08: 81 c7 e0 08 ret
2007a0c: 81 e8 00 00 restore
02007230 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
2007230: 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 )
2007234: 80 a6 20 00 cmp %i0, 0
2007238: 02 80 00 12 be 2007280 <pthread_cleanup_push+0x50>
200723c: 03 00 80 79 sethi %hi(0x201e400), %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;
2007240: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 ! 201e420 <_Thread_Dispatch_disable_level>
++level;
2007244: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2007248: c4 20 60 20 st %g2, [ %g1 + 0x20 ]
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
200724c: 40 00 11 f8 call 200ba2c <_Workspace_Allocate>
2007250: 90 10 20 10 mov 0x10, %o0
if ( handler ) {
2007254: 92 92 20 00 orcc %o0, 0, %o1
2007258: 02 80 00 08 be 2007278 <pthread_cleanup_push+0x48> <== NEVER TAKEN
200725c: 03 00 80 7a sethi %hi(0x201e800), %g1
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
2007260: c2 00 61 50 ld [ %g1 + 0x150 ], %g1 ! 201e950 <_Per_CPU_Information+0x10>
handler_stack = &thread_support->Cancellation_Handlers;
2007264: d0 00 61 5c ld [ %g1 + 0x15c ], %o0
handler->routine = routine;
2007268: f0 22 60 08 st %i0, [ %o1 + 8 ]
handler->arg = arg;
200726c: f2 22 60 0c st %i1, [ %o1 + 0xc ]
_Chain_Append( handler_stack, &handler->Node );
2007270: 40 00 06 30 call 2008b30 <_Chain_Append>
2007274: 90 02 20 e4 add %o0, 0xe4, %o0
}
_Thread_Enable_dispatch();
2007278: 40 00 0d ab call 200a924 <_Thread_Enable_dispatch>
200727c: 81 e8 00 00 restore
2007280: 81 c7 e0 08 ret
2007284: 81 e8 00 00 restore
02008210 <pthread_cond_init>:
*/
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
2008210: 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;
2008214: 80 a6 60 00 cmp %i1, 0
2008218: 32 80 00 05 bne,a 200822c <pthread_cond_init+0x1c>
200821c: c4 06 60 04 ld [ %i1 + 4 ], %g2
else the_attr = &_POSIX_Condition_variables_Default_attributes;
2008220: 33 00 80 77 sethi %hi(0x201dc00), %i1
2008224: b2 16 60 cc or %i1, 0xcc, %i1 ! 201dccc <_POSIX_Condition_variables_Default_attributes>
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
2008228: c4 06 60 04 ld [ %i1 + 4 ], %g2
200822c: 80 a0 a0 01 cmp %g2, 1
2008230: 02 80 00 25 be 20082c4 <pthread_cond_init+0xb4> <== NEVER TAKEN
2008234: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ( !the_attr->is_initialized )
2008238: c4 06 40 00 ld [ %i1 ], %g2
200823c: 80 a0 a0 00 cmp %g2, 0
2008240: 02 80 00 21 be 20082c4 <pthread_cond_init+0xb4>
2008244: 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;
2008248: 03 00 80 7f sethi %hi(0x201fc00), %g1
200824c: c4 00 62 50 ld [ %g1 + 0x250 ], %g2 ! 201fe50 <_Thread_Dispatch_disable_level>
++level;
2008250: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2008254: c4 20 62 50 st %g2, [ %g1 + 0x250 ]
*/
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
2008258: 39 00 80 80 sethi %hi(0x2020000), %i4
200825c: 40 00 0a 23 call 200aae8 <_Objects_Allocate>
2008260: 90 17 22 7c or %i4, 0x27c, %o0 ! 202027c <_POSIX_Condition_variables_Information>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
2008264: ba 92 20 00 orcc %o0, 0, %i5
2008268: 32 80 00 06 bne,a 2008280 <pthread_cond_init+0x70>
200826c: c2 06 60 04 ld [ %i1 + 4 ], %g1
_Thread_Enable_dispatch();
2008270: 40 00 0f 1c call 200bee0 <_Thread_Enable_dispatch>
2008274: 01 00 00 00 nop
return ENOMEM;
2008278: 10 80 00 13 b 20082c4 <pthread_cond_init+0xb4>
200827c: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
2008280: 90 07 60 18 add %i5, 0x18, %o0
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
2008284: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
2008288: 92 10 20 00 clr %o1
200828c: 15 04 00 02 sethi %hi(0x10000800), %o2
2008290: 96 10 20 74 mov 0x74, %o3
2008294: 40 00 11 19 call 200c6f8 <_Thread_queue_Initialize>
2008298: c0 27 60 14 clr [ %i5 + 0x14 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
200829c: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20082a0: b8 17 22 7c or %i4, 0x27c, %i4
20082a4: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20082a8: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20082ac: 85 28 a0 02 sll %g2, 2, %g2
20082b0: 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;
20082b4: c0 27 60 0c clr [ %i5 + 0xc ]
0
);
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
20082b8: 40 00 0f 0a call 200bee0 <_Thread_Enable_dispatch>
20082bc: c2 26 00 00 st %g1, [ %i0 ]
return 0;
20082c0: 82 10 20 00 clr %g1
}
20082c4: 81 c7 e0 08 ret
20082c8: 91 e8 00 01 restore %g0, %g1, %o0
02008070 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
2008070: 82 10 00 08 mov %o0, %g1
if ( !attr || attr->is_initialized == false )
2008074: 80 a0 60 00 cmp %g1, 0
2008078: 02 80 00 08 be 2008098 <pthread_condattr_destroy+0x28>
200807c: 90 10 20 16 mov 0x16, %o0
2008080: c4 00 40 00 ld [ %g1 ], %g2
2008084: 80 a0 a0 00 cmp %g2, 0
2008088: 02 80 00 04 be 2008098 <pthread_condattr_destroy+0x28> <== NEVER TAKEN
200808c: 01 00 00 00 nop
return EINVAL;
attr->is_initialized = false;
2008090: c0 20 40 00 clr [ %g1 ]
return 0;
2008094: 90 10 20 00 clr %o0
}
2008098: 81 c3 e0 08 retl
02007608 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
2007608: 9d e3 bf 58 save %sp, -168, %sp
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
200760c: 80 a6 a0 00 cmp %i2, 0
2007610: 02 80 00 8c be 2007840 <pthread_create+0x238>
2007614: ba 10 20 0e mov 0xe, %i5
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
2007618: 80 a6 60 00 cmp %i1, 0
200761c: 32 80 00 05 bne,a 2007630 <pthread_create+0x28>
2007620: c2 06 40 00 ld [ %i1 ], %g1
2007624: 33 00 80 80 sethi %hi(0x2020000), %i1
2007628: b2 16 62 74 or %i1, 0x274, %i1 ! 2020274 <_POSIX_Threads_Default_attributes>
if ( !the_attr->is_initialized )
200762c: c2 06 40 00 ld [ %i1 ], %g1
2007630: 80 a0 60 00 cmp %g1, 0
2007634: 02 80 00 83 be 2007840 <pthread_create+0x238>
2007638: ba 10 20 16 mov 0x16, %i5
* stack space if it is allowed to allocate it itself.
*
* NOTE: If the user provides the stack we will let it drop below
* twice the minimum.
*/
if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
200763c: c2 06 60 04 ld [ %i1 + 4 ], %g1
2007640: 80 a0 60 00 cmp %g1, 0
2007644: 02 80 00 07 be 2007660 <pthread_create+0x58>
2007648: 03 00 80 85 sethi %hi(0x2021400), %g1
200764c: c4 06 60 08 ld [ %i1 + 8 ], %g2
2007650: c2 00 63 70 ld [ %g1 + 0x370 ], %g1
2007654: 80 a0 80 01 cmp %g2, %g1
2007658: 2a 80 00 7b bcs,a 2007844 <pthread_create+0x23c>
200765c: b0 10 00 1d mov %i5, %i0
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
2007660: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
2007664: 80 a0 60 01 cmp %g1, 1
2007668: 02 80 00 06 be 2007680 <pthread_create+0x78>
200766c: 80 a0 60 02 cmp %g1, 2
2007670: 32 80 00 74 bne,a 2007840 <pthread_create+0x238>
2007674: ba 10 20 16 mov 0x16, %i5
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
2007678: 10 80 00 09 b 200769c <pthread_create+0x94>
200767c: e2 06 60 14 ld [ %i1 + 0x14 ], %l1
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
2007680: 03 00 80 8a sethi %hi(0x2022800), %g1
2007684: c2 00 61 30 ld [ %g1 + 0x130 ], %g1 ! 2022930 <_Per_CPU_Information+0x10>
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
2007688: 90 07 bf e4 add %fp, -28, %o0
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
200768c: d2 00 61 5c ld [ %g1 + 0x15c ], %o1
schedpolicy = api->schedpolicy;
2007690: e2 02 60 84 ld [ %o1 + 0x84 ], %l1
schedparam = api->schedparam;
2007694: 10 80 00 04 b 20076a4 <pthread_create+0x9c>
2007698: 92 02 60 88 add %o1, 0x88, %o1
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
200769c: 90 07 bf e4 add %fp, -28, %o0
20076a0: 92 06 60 18 add %i1, 0x18, %o1
20076a4: 40 00 25 72 call 2010c6c <memcpy>
20076a8: 94 10 20 1c mov 0x1c, %o2
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
20076ac: c2 06 60 0c ld [ %i1 + 0xc ], %g1
20076b0: 80 a0 60 00 cmp %g1, 0
20076b4: 12 80 00 63 bne 2007840 <pthread_create+0x238>
20076b8: ba 10 20 86 mov 0x86, %i5
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
20076bc: 40 00 19 09 call 200dae0 <_POSIX_Priority_Is_valid>
20076c0: d0 07 bf e4 ld [ %fp + -28 ], %o0
20076c4: 80 8a 20 ff btst 0xff, %o0
20076c8: 02 80 00 5e be 2007840 <pthread_create+0x238> <== NEVER TAKEN
20076cc: 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);
20076d0: 03 00 80 85 sethi %hi(0x2021400), %g1
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
20076d4: e4 07 bf e4 ld [ %fp + -28 ], %l2
20076d8: e6 08 63 6c ldub [ %g1 + 0x36c ], %l3
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
20076dc: 90 10 00 11 mov %l1, %o0
20076e0: 92 07 bf e4 add %fp, -28, %o1
20076e4: 94 07 bf dc add %fp, -36, %o2
20076e8: 40 00 19 09 call 200db0c <_POSIX_Thread_Translate_sched_param>
20076ec: 96 07 bf e0 add %fp, -32, %o3
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
20076f0: ba 92 20 00 orcc %o0, 0, %i5
20076f4: 32 80 00 54 bne,a 2007844 <pthread_create+0x23c>
20076f8: b0 10 00 1d mov %i5, %i0
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
20076fc: 39 00 80 89 sethi %hi(0x2022400), %i4
2007700: 40 00 06 48 call 2009020 <_API_Mutex_Lock>
2007704: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 ! 2022484 <_RTEMS_Allocator_Mutex>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
2007708: 11 00 80 89 sethi %hi(0x2022400), %o0
200770c: 40 00 08 e4 call 2009a9c <_Objects_Allocate>
2007710: 90 12 22 14 or %o0, 0x214, %o0 ! 2022614 <_POSIX_Threads_Information>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
2007714: a0 92 20 00 orcc %o0, 0, %l0
2007718: 32 80 00 04 bne,a 2007728 <pthread_create+0x120>
200771c: c2 06 60 08 ld [ %i1 + 8 ], %g1
_RTEMS_Unlock_allocator();
2007720: 10 80 00 21 b 20077a4 <pthread_create+0x19c>
2007724: d0 07 20 84 ld [ %i4 + 0x84 ], %o0
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
2007728: 05 00 80 85 sethi %hi(0x2021400), %g2
200772c: d6 00 a3 70 ld [ %g2 + 0x370 ], %o3 ! 2021770 <rtems_minimum_stack_size>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
2007730: c0 27 bf d4 clr [ %fp + -44 ]
2007734: 97 2a e0 01 sll %o3, 1, %o3
2007738: 80 a2 c0 01 cmp %o3, %g1
200773c: 1a 80 00 03 bcc 2007748 <pthread_create+0x140>
2007740: d4 06 60 04 ld [ %i1 + 4 ], %o2
2007744: 96 10 00 01 mov %g1, %o3
2007748: 82 10 20 01 mov 1, %g1
200774c: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2007750: c2 07 bf dc ld [ %fp + -36 ], %g1
2007754: 9a 0c e0 ff and %l3, 0xff, %o5
2007758: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
200775c: c2 07 bf e0 ld [ %fp + -32 ], %g1
2007760: c0 23 a0 68 clr [ %sp + 0x68 ]
2007764: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
2007768: 82 07 bf d4 add %fp, -44, %g1
200776c: 39 00 80 89 sethi %hi(0x2022400), %i4
2007770: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
2007774: 90 17 22 14 or %i4, 0x214, %o0
2007778: 92 10 00 10 mov %l0, %o1
200777c: 98 10 20 01 mov 1, %o4
2007780: 40 00 0d fd call 200af74 <_Thread_Initialize>
2007784: 9a 23 40 12 sub %o5, %l2, %o5
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
2007788: 80 8a 20 ff btst 0xff, %o0
200778c: 12 80 00 0a bne 20077b4 <pthread_create+0x1ac>
2007790: 90 17 22 14 or %i4, 0x214, %o0
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
2007794: 40 00 09 a1 call 2009e18 <_Objects_Free>
2007798: 92 10 00 10 mov %l0, %o1
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
200779c: 03 00 80 89 sethi %hi(0x2022400), %g1
20077a0: d0 00 60 84 ld [ %g1 + 0x84 ], %o0 ! 2022484 <_RTEMS_Allocator_Mutex>
20077a4: 40 00 06 34 call 2009074 <_API_Mutex_Unlock>
20077a8: ba 10 20 0b mov 0xb, %i5
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
20077ac: 81 c7 e0 08 ret
20077b0: 91 e8 00 1d restore %g0, %i5, %o0
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
20077b4: f8 04 21 5c ld [ %l0 + 0x15c ], %i4
api->Attributes = *the_attr;
20077b8: 92 10 00 19 mov %i1, %o1
20077bc: 94 10 20 40 mov 0x40, %o2
20077c0: 40 00 25 2b call 2010c6c <memcpy>
20077c4: 90 10 00 1c mov %i4, %o0
api->detachstate = the_attr->detachstate;
20077c8: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
20077cc: 92 07 bf e4 add %fp, -28, %o1
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
20077d0: c2 27 20 40 st %g1, [ %i4 + 0x40 ]
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
20077d4: 94 10 20 1c mov 0x1c, %o2
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
20077d8: e2 27 20 84 st %l1, [ %i4 + 0x84 ]
api->schedparam = schedparam;
20077dc: 40 00 25 24 call 2010c6c <memcpy>
20077e0: 90 07 20 88 add %i4, 0x88, %o0
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
20077e4: 90 10 00 10 mov %l0, %o0
20077e8: 92 10 20 01 mov 1, %o1
20077ec: 94 10 00 1a mov %i2, %o2
20077f0: 96 10 00 1b mov %i3, %o3
20077f4: 40 00 10 2f call 200b8b0 <_Thread_Start>
20077f8: 98 10 20 00 clr %o4
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
20077fc: 80 a4 60 04 cmp %l1, 4
2007800: 32 80 00 0a bne,a 2007828 <pthread_create+0x220>
2007804: c2 04 20 08 ld [ %l0 + 8 ], %g1
_Watchdog_Insert_ticks(
2007808: 40 00 10 54 call 200b958 <_Timespec_To_ticks>
200780c: 90 07 20 90 add %i4, 0x90, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2007810: 92 07 20 a8 add %i4, 0xa8, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2007814: d0 27 20 b4 st %o0, [ %i4 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2007818: 11 00 80 89 sethi %hi(0x2022400), %o0
200781c: 40 00 11 04 call 200bc2c <_Watchdog_Insert>
2007820: 90 12 20 9c or %o0, 0x9c, %o0 ! 202249c <_Watchdog_Ticks_chain>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
2007824: c2 04 20 08 ld [ %l0 + 8 ], %g1
2007828: c2 26 00 00 st %g1, [ %i0 ]
_RTEMS_Unlock_allocator();
200782c: 03 00 80 89 sethi %hi(0x2022400), %g1
2007830: 40 00 06 11 call 2009074 <_API_Mutex_Unlock>
2007834: d0 00 60 84 ld [ %g1 + 0x84 ], %o0 ! 2022484 <_RTEMS_Allocator_Mutex>
return 0;
}
2007838: 81 c7 e0 08 ret
200783c: 91 e8 00 1d restore %g0, %i5, %o0
2007840: b0 10 00 1d mov %i5, %i0
2007844: 81 c7 e0 08 ret
2007848: 81 e8 00 00 restore
0201a3f4 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
201a3f4: 9d e3 bf 98 save %sp, -104, %sp
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
201a3f8: 80 a6 60 00 cmp %i1, 0
201a3fc: 32 80 00 03 bne,a 201a408 <pthread_kill+0x14>
201a400: b8 06 7f ff add %i1, -1, %i4
201a404: 30 80 00 04 b,a 201a414 <pthread_kill+0x20>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
201a408: 80 a7 20 1f cmp %i4, 0x1f
201a40c: 28 80 00 06 bleu,a 201a424 <pthread_kill+0x30>
201a410: 90 10 00 18 mov %i0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
201a414: 7f ff d4 96 call 200f66c <__errno>
201a418: 01 00 00 00 nop
201a41c: 10 80 00 30 b 201a4dc <pthread_kill+0xe8>
201a420: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
the_thread = _Thread_Get( thread, &location );
201a424: 7f ff bf 17 call 200a080 <_Thread_Get>
201a428: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
201a42c: c2 07 bf fc ld [ %fp + -4 ], %g1
201a430: 80 a0 60 00 cmp %g1, 0
201a434: 12 80 00 27 bne 201a4d0 <pthread_kill+0xdc> <== NEVER TAKEN
201a438: ba 10 00 08 mov %o0, %i5
201a43c: 11 00 80 72 sethi %hi(0x201c800), %o0
201a440: 7f ff b7 04 call 2008050 <_API_extensions_Add_post_switch>
201a444: 90 12 23 a4 or %o0, 0x3a4, %o0 ! 201cba4 <_POSIX_signals_Post_switch>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
201a448: 85 2e 60 02 sll %i1, 2, %g2
201a44c: 87 2e 60 04 sll %i1, 4, %g3
201a450: 86 20 c0 02 sub %g3, %g2, %g3
201a454: 05 00 80 76 sethi %hi(0x201d800), %g2
201a458: 84 10 a3 50 or %g2, 0x350, %g2 ! 201db50 <_POSIX_signals_Vectors>
201a45c: 84 00 80 03 add %g2, %g3, %g2
201a460: c4 00 a0 08 ld [ %g2 + 8 ], %g2
201a464: 80 a0 a0 01 cmp %g2, 1
201a468: 12 80 00 06 bne 201a480 <pthread_kill+0x8c>
201a46c: c2 07 61 5c ld [ %i5 + 0x15c ], %g1
_Thread_Enable_dispatch();
201a470: 7f ff be f8 call 200a050 <_Thread_Enable_dispatch>
201a474: b0 10 20 00 clr %i0
201a478: 81 c7 e0 08 ret
201a47c: 81 e8 00 00 restore
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
201a480: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2
201a484: b6 10 20 01 mov 1, %i3
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
201a488: 90 10 00 1d mov %i5, %o0
201a48c: b9 2e c0 1c sll %i3, %i4, %i4
201a490: 92 10 00 19 mov %i1, %o1
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
201a494: b8 10 80 1c or %g2, %i4, %i4
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
201a498: 94 10 20 00 clr %o2
201a49c: 7f ff ff 84 call 201a2ac <_POSIX_signals_Unblock_thread>
201a4a0: f8 20 60 d4 st %i4, [ %g1 + 0xd4 ]
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
201a4a4: 03 00 80 76 sethi %hi(0x201d800), %g1
201a4a8: 82 10 62 f0 or %g1, 0x2f0, %g1 ! 201daf0 <_Per_CPU_Information>
201a4ac: c4 00 60 08 ld [ %g1 + 8 ], %g2
201a4b0: 80 a0 a0 00 cmp %g2, 0
201a4b4: 02 bf ff ef be 201a470 <pthread_kill+0x7c>
201a4b8: 01 00 00 00 nop
201a4bc: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
201a4c0: 80 a7 40 02 cmp %i5, %g2
201a4c4: 22 bf ff eb be,a 201a470 <pthread_kill+0x7c>
201a4c8: f6 28 60 0c stb %i3, [ %g1 + 0xc ]
201a4cc: 30 bf ff e9 b,a 201a470 <pthread_kill+0x7c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
201a4d0: 7f ff d4 67 call 200f66c <__errno> <== NOT EXECUTED
201a4d4: 01 00 00 00 nop <== NOT EXECUTED
201a4d8: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3> <== NOT EXECUTED
201a4dc: c2 22 00 00 st %g1, [ %o0 ]
}
201a4e0: 81 c7 e0 08 ret
201a4e4: 91 e8 3f ff restore %g0, -1, %o0
020097e4 <pthread_mutex_timedlock>:
*/
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
20097e4: 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 );
20097e8: 92 07 bf fc add %fp, -4, %o1
20097ec: 40 00 00 37 call 20098c8 <_POSIX_Absolute_timeout_to_ticks>
20097f0: 90 10 00 19 mov %i1, %o0
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
20097f4: 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 )
20097f8: 82 1a 20 03 xor %o0, 3, %g1
20097fc: 80 a0 00 01 cmp %g0, %g1
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
2009800: ba 10 00 08 mov %o0, %i5
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
2009804: b8 60 3f ff subx %g0, -1, %i4
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
2009808: 90 10 00 18 mov %i0, %o0
200980c: 7f ff ff b7 call 20096e8 <_POSIX_Mutex_Lock_support>
2009810: 92 10 00 1c mov %i4, %o1
* This service only gives us the option to block. We used a polling
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
2009814: 80 a7 20 00 cmp %i4, 0
2009818: 12 80 00 0c bne 2009848 <pthread_mutex_timedlock+0x64>
200981c: b0 10 00 08 mov %o0, %i0
2009820: 80 a2 20 10 cmp %o0, 0x10
2009824: 12 80 00 09 bne 2009848 <pthread_mutex_timedlock+0x64>
2009828: 80 a7 60 00 cmp %i5, 0
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
200982c: 02 80 00 07 be 2009848 <pthread_mutex_timedlock+0x64> <== NEVER TAKEN
2009830: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
2009834: ba 07 7f ff add %i5, -1, %i5
2009838: 80 a7 60 01 cmp %i5, 1
200983c: 18 80 00 03 bgu 2009848 <pthread_mutex_timedlock+0x64> <== NEVER TAKEN
2009840: b0 10 20 10 mov 0x10, %i0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
2009844: b0 10 20 74 mov 0x74, %i0
}
return lock_status;
}
2009848: 81 c7 e0 08 ret
200984c: 81 e8 00 00 restore
02006eec <pthread_mutexattr_gettype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
2006eec: 82 10 00 08 mov %o0, %g1
if ( !attr )
2006ef0: 80 a0 60 00 cmp %g1, 0
2006ef4: 02 80 00 0b be 2006f20 <pthread_mutexattr_gettype+0x34>
2006ef8: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
2006efc: c4 00 40 00 ld [ %g1 ], %g2
2006f00: 80 a0 a0 00 cmp %g2, 0
2006f04: 02 80 00 07 be 2006f20 <pthread_mutexattr_gettype+0x34>
2006f08: 80 a2 60 00 cmp %o1, 0
return EINVAL;
if ( !type )
2006f0c: 02 80 00 05 be 2006f20 <pthread_mutexattr_gettype+0x34> <== NEVER TAKEN
2006f10: 01 00 00 00 nop
return EINVAL;
*type = attr->type;
2006f14: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
return 0;
2006f18: 90 10 20 00 clr %o0
return EINVAL;
if ( !type )
return EINVAL;
*type = attr->type;
2006f1c: c2 22 40 00 st %g1, [ %o1 ]
return 0;
}
2006f20: 81 c3 e0 08 retl
0200939c <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
200939c: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
20093a0: 80 a0 60 00 cmp %g1, 0
20093a4: 02 80 00 0a be 20093cc <pthread_mutexattr_setpshared+0x30>
20093a8: 90 10 20 16 mov 0x16, %o0
20093ac: c4 00 40 00 ld [ %g1 ], %g2
20093b0: 80 a0 a0 00 cmp %g2, 0
20093b4: 02 80 00 06 be 20093cc <pthread_mutexattr_setpshared+0x30>
20093b8: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
20093bc: 18 80 00 04 bgu 20093cc <pthread_mutexattr_setpshared+0x30><== NEVER TAKEN
20093c0: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
20093c4: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
20093c8: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
20093cc: 81 c3 e0 08 retl
02006f58 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
2006f58: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
2006f5c: 80 a0 60 00 cmp %g1, 0
2006f60: 02 80 00 0a be 2006f88 <pthread_mutexattr_settype+0x30>
2006f64: 90 10 20 16 mov 0x16, %o0
2006f68: c4 00 40 00 ld [ %g1 ], %g2
2006f6c: 80 a0 a0 00 cmp %g2, 0
2006f70: 02 80 00 06 be 2006f88 <pthread_mutexattr_settype+0x30> <== NEVER TAKEN
2006f74: 80 a2 60 03 cmp %o1, 3
return EINVAL;
switch ( type ) {
2006f78: 18 80 00 04 bgu 2006f88 <pthread_mutexattr_settype+0x30>
2006f7c: 01 00 00 00 nop
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
2006f80: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
2006f84: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
2006f88: 81 c3 e0 08 retl
02007c90 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
2007c90: 9d e3 bf 98 save %sp, -104, %sp
if ( !once_control || !init_routine )
2007c94: 80 a6 60 00 cmp %i1, 0
2007c98: 02 80 00 1c be 2007d08 <pthread_once+0x78>
2007c9c: ba 10 00 18 mov %i0, %i5
2007ca0: 80 a6 20 00 cmp %i0, 0
2007ca4: 22 80 00 17 be,a 2007d00 <pthread_once+0x70>
2007ca8: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( !once_control->init_executed ) {
2007cac: c2 06 20 04 ld [ %i0 + 4 ], %g1
2007cb0: 80 a0 60 00 cmp %g1, 0
2007cb4: 12 80 00 13 bne 2007d00 <pthread_once+0x70>
2007cb8: b0 10 20 00 clr %i0
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
2007cbc: 90 10 21 00 mov 0x100, %o0
2007cc0: 92 10 21 00 mov 0x100, %o1
2007cc4: 40 00 03 0d call 20088f8 <rtems_task_mode>
2007cc8: 94 07 bf fc add %fp, -4, %o2
if ( !once_control->init_executed ) {
2007ccc: c2 07 60 04 ld [ %i5 + 4 ], %g1
2007cd0: 80 a0 60 00 cmp %g1, 0
2007cd4: 12 80 00 07 bne 2007cf0 <pthread_once+0x60> <== NEVER TAKEN
2007cd8: d0 07 bf fc ld [ %fp + -4 ], %o0
once_control->is_initialized = true;
2007cdc: 82 10 20 01 mov 1, %g1
2007ce0: c2 27 40 00 st %g1, [ %i5 ]
once_control->init_executed = true;
(*init_routine)();
2007ce4: 9f c6 40 00 call %i1
2007ce8: c2 27 60 04 st %g1, [ %i5 + 4 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2007cec: d0 07 bf fc ld [ %fp + -4 ], %o0
2007cf0: 92 10 21 00 mov 0x100, %o1
2007cf4: 94 07 bf fc add %fp, -4, %o2
2007cf8: 40 00 03 00 call 20088f8 <rtems_task_mode>
2007cfc: b0 10 20 00 clr %i0
2007d00: 81 c7 e0 08 ret
2007d04: 81 e8 00 00 restore
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
2007d08: b0 10 20 16 mov 0x16, %i0
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
2007d0c: 81 c7 e0 08 ret
2007d10: 81 e8 00 00 restore
02007db0 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
2007db0: 9d e3 bf 90 save %sp, -112, %sp
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
2007db4: 80 a6 20 00 cmp %i0, 0
2007db8: 12 80 00 04 bne 2007dc8 <pthread_rwlock_init+0x18>
2007dbc: 80 a6 60 00 cmp %i1, 0
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
2007dc0: 81 c7 e0 08 ret
2007dc4: 91 e8 20 16 restore %g0, 0x16, %o0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
2007dc8: 32 80 00 06 bne,a 2007de0 <pthread_rwlock_init+0x30>
2007dcc: c2 06 40 00 ld [ %i1 ], %g1
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
2007dd0: 90 07 bf f8 add %fp, -8, %o0
2007dd4: 40 00 01 b0 call 2008494 <pthread_rwlockattr_init>
2007dd8: 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 )
2007ddc: c2 06 40 00 ld [ %i1 ], %g1
2007de0: 80 a0 60 00 cmp %g1, 0
2007de4: 22 80 00 13 be,a 2007e30 <pthread_rwlock_init+0x80> <== NEVER TAKEN
2007de8: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
switch ( the_attr->process_shared ) {
2007dec: c2 06 60 04 ld [ %i1 + 4 ], %g1
2007df0: 80 a0 60 00 cmp %g1, 0
2007df4: 32 80 00 0f bne,a 2007e30 <pthread_rwlock_init+0x80> <== NEVER TAKEN
2007df8: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2007dfc: 03 00 80 88 sethi %hi(0x2022000), %g1
2007e00: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2022090 <_Thread_Dispatch_disable_level>
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
2007e04: c0 27 bf f4 clr [ %fp + -12 ]
++level;
2007e08: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2007e0c: c4 20 60 90 st %g2, [ %g1 + 0x90 ]
* 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 *)
2007e10: 39 00 80 88 sethi %hi(0x2022000), %i4
2007e14: 40 00 0a 7e call 200a80c <_Objects_Allocate>
2007e18: 90 17 22 a4 or %i4, 0x2a4, %o0 ! 20222a4 <_POSIX_RWLock_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
2007e1c: ba 92 20 00 orcc %o0, 0, %i5
2007e20: 12 80 00 06 bne 2007e38 <pthread_rwlock_init+0x88>
2007e24: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
2007e28: 40 00 0f b0 call 200bce8 <_Thread_Enable_dispatch>
2007e2c: b0 10 20 0b mov 0xb, %i0
2007e30: 81 c7 e0 08 ret
2007e34: 81 e8 00 00 restore
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
2007e38: 40 00 08 dd call 200a1ac <_CORE_RWLock_Initialize>
2007e3c: 92 07 bf f4 add %fp, -12, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2007e40: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007e44: b8 17 22 a4 or %i4, 0x2a4, %i4
2007e48: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2007e4c: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007e50: 85 28 a0 02 sll %g2, 2, %g2
2007e54: 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;
2007e58: c0 27 60 0c clr [ %i5 + 0xc ]
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
2007e5c: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
2007e60: 40 00 0f a2 call 200bce8 <_Thread_Enable_dispatch>
2007e64: b0 10 20 00 clr %i0
2007e68: 81 c7 e0 08 ret
2007e6c: 81 e8 00 00 restore
02008764 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
2008764: 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 )
2008768: 80 a6 20 00 cmp %i0, 0
200876c: 12 80 00 04 bne 200877c <pthread_rwlock_timedrdlock+0x18>
2008770: 92 07 bf fc add %fp, -4, %o1
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
2008774: 81 c7 e0 08 ret
2008778: 91 e8 20 16 restore %g0, 0x16, %o0
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
200877c: 40 00 19 cc call 200eeac <_POSIX_Absolute_timeout_to_ticks>
2008780: 90 10 00 19 mov %i1, %o0
2008784: d2 06 00 00 ld [ %i0 ], %o1
2008788: ba 10 00 08 mov %o0, %i5
200878c: 94 07 bf f8 add %fp, -8, %o2
2008790: 11 00 80 82 sethi %hi(0x2020800), %o0
2008794: 40 00 0b 30 call 200b454 <_Objects_Get>
2008798: 90 12 20 b4 or %o0, 0xb4, %o0 ! 20208b4 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
200879c: c2 07 bf f8 ld [ %fp + -8 ], %g1
20087a0: 80 a0 60 00 cmp %g1, 0
20087a4: 32 80 00 21 bne,a 2008828 <pthread_rwlock_timedrdlock+0xc4>
20087a8: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
20087ac: d2 06 00 00 ld [ %i0 ], %o1
20087b0: 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 )
20087b4: 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(
20087b8: 90 02 20 10 add %o0, 0x10, %o0
20087bc: 80 a0 00 01 cmp %g0, %g1
20087c0: 98 10 20 00 clr %o4
20087c4: b8 60 3f ff subx %g0, -1, %i4
20087c8: 40 00 07 9e call 200a640 <_CORE_RWLock_Obtain_for_reading>
20087cc: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
20087d0: 40 00 0e d9 call 200c334 <_Thread_Enable_dispatch>
20087d4: 01 00 00 00 nop
if ( !do_wait ) {
20087d8: 80 a7 20 00 cmp %i4, 0
20087dc: 12 80 00 0e bne 2008814 <pthread_rwlock_timedrdlock+0xb0>
20087e0: 03 00 80 83 sethi %hi(0x2020c00), %g1
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
20087e4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 ! 2020c10 <_Per_CPU_Information+0x10>
20087e8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
20087ec: 80 a0 60 02 cmp %g1, 2
20087f0: 32 80 00 0a bne,a 2008818 <pthread_rwlock_timedrdlock+0xb4>
20087f4: 03 00 80 83 sethi %hi(0x2020c00), %g1
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
20087f8: 80 a7 60 00 cmp %i5, 0
20087fc: 22 80 00 0b be,a 2008828 <pthread_rwlock_timedrdlock+0xc4><== NEVER TAKEN
2008800: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
2008804: ba 07 7f ff add %i5, -1, %i5
2008808: 80 a7 60 01 cmp %i5, 1
200880c: 08 80 00 07 bleu 2008828 <pthread_rwlock_timedrdlock+0xc4><== ALWAYS TAKEN
2008810: b0 10 20 74 mov 0x74, %i0
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
2008814: 03 00 80 83 sethi %hi(0x2020c00), %g1
2008818: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 ! 2020c10 <_Per_CPU_Information+0x10>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
200881c: 40 00 00 38 call 20088fc <_POSIX_RWLock_Translate_core_RWLock_return_code>
2008820: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
2008824: b0 10 00 08 mov %o0, %i0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
2008828: 81 c7 e0 08 ret
200882c: 81 e8 00 00 restore
02008830 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
2008830: 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 )
2008834: 80 a6 20 00 cmp %i0, 0
2008838: 12 80 00 04 bne 2008848 <pthread_rwlock_timedwrlock+0x18>
200883c: 92 07 bf fc add %fp, -4, %o1
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
2008840: 81 c7 e0 08 ret
2008844: 91 e8 20 16 restore %g0, 0x16, %o0
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
2008848: 40 00 19 99 call 200eeac <_POSIX_Absolute_timeout_to_ticks>
200884c: 90 10 00 19 mov %i1, %o0
2008850: d2 06 00 00 ld [ %i0 ], %o1
2008854: ba 10 00 08 mov %o0, %i5
2008858: 94 07 bf f8 add %fp, -8, %o2
200885c: 11 00 80 82 sethi %hi(0x2020800), %o0
2008860: 40 00 0a fd call 200b454 <_Objects_Get>
2008864: 90 12 20 b4 or %o0, 0xb4, %o0 ! 20208b4 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
2008868: c2 07 bf f8 ld [ %fp + -8 ], %g1
200886c: 80 a0 60 00 cmp %g1, 0
2008870: 32 80 00 21 bne,a 20088f4 <pthread_rwlock_timedwrlock+0xc4>
2008874: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
2008878: d2 06 00 00 ld [ %i0 ], %o1
200887c: 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 )
2008880: 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(
2008884: 90 02 20 10 add %o0, 0x10, %o0
2008888: 80 a0 00 01 cmp %g0, %g1
200888c: 98 10 20 00 clr %o4
2008890: b8 60 3f ff subx %g0, -1, %i4
2008894: 40 00 07 9e call 200a70c <_CORE_RWLock_Obtain_for_writing>
2008898: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
200889c: 40 00 0e a6 call 200c334 <_Thread_Enable_dispatch>
20088a0: 01 00 00 00 nop
if ( !do_wait &&
20088a4: 80 a7 20 00 cmp %i4, 0
20088a8: 12 80 00 0e bne 20088e0 <pthread_rwlock_timedwrlock+0xb0>
20088ac: 03 00 80 83 sethi %hi(0x2020c00), %g1
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
20088b0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 ! 2020c10 <_Per_CPU_Information+0x10>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
20088b4: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
20088b8: 80 a0 60 02 cmp %g1, 2
20088bc: 32 80 00 0a bne,a 20088e4 <pthread_rwlock_timedwrlock+0xb4>
20088c0: 03 00 80 83 sethi %hi(0x2020c00), %g1
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
20088c4: 80 a7 60 00 cmp %i5, 0
20088c8: 22 80 00 0b be,a 20088f4 <pthread_rwlock_timedwrlock+0xc4><== NEVER TAKEN
20088cc: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
20088d0: ba 07 7f ff add %i5, -1, %i5
20088d4: 80 a7 60 01 cmp %i5, 1
20088d8: 08 80 00 07 bleu 20088f4 <pthread_rwlock_timedwrlock+0xc4><== ALWAYS TAKEN
20088dc: b0 10 20 74 mov 0x74, %i0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
20088e0: 03 00 80 83 sethi %hi(0x2020c00), %g1
20088e4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 ! 2020c10 <_Per_CPU_Information+0x10>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
20088e8: 40 00 00 05 call 20088fc <_POSIX_RWLock_Translate_core_RWLock_return_code>
20088ec: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
20088f0: b0 10 00 08 mov %o0, %i0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
20088f4: 81 c7 e0 08 ret
20088f8: 81 e8 00 00 restore
02009088 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
2009088: 82 10 00 08 mov %o0, %g1
if ( !attr )
200908c: 80 a0 60 00 cmp %g1, 0
2009090: 02 80 00 0a be 20090b8 <pthread_rwlockattr_setpshared+0x30>
2009094: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
2009098: c4 00 40 00 ld [ %g1 ], %g2
200909c: 80 a0 a0 00 cmp %g2, 0
20090a0: 02 80 00 06 be 20090b8 <pthread_rwlockattr_setpshared+0x30>
20090a4: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
20090a8: 18 80 00 04 bgu 20090b8 <pthread_rwlockattr_setpshared+0x30><== NEVER TAKEN
20090ac: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
20090b0: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
20090b4: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
20090b8: 81 c3 e0 08 retl
0200a0b0 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
200a0b0: 9d e3 bf 90 save %sp, -112, %sp
int rc;
/*
* Check all the parameters
*/
if ( !param )
200a0b4: 80 a6 a0 00 cmp %i2, 0
200a0b8: 02 80 00 40 be 200a1b8 <pthread_setschedparam+0x108>
200a0bc: b6 10 20 16 mov 0x16, %i3
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
200a0c0: 90 10 00 19 mov %i1, %o0
200a0c4: 92 10 00 1a mov %i2, %o1
200a0c8: 94 07 bf f4 add %fp, -12, %o2
200a0cc: 40 00 17 8e call 200ff04 <_POSIX_Thread_Translate_sched_param>
200a0d0: 96 07 bf f8 add %fp, -8, %o3
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
200a0d4: b6 92 20 00 orcc %o0, 0, %i3
200a0d8: 32 80 00 39 bne,a 200a1bc <pthread_setschedparam+0x10c>
200a0dc: b0 10 00 1b mov %i3, %i0
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
200a0e0: 90 10 00 18 mov %i0, %o0
200a0e4: 40 00 0c 3b call 200d1d0 <_Thread_Get>
200a0e8: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a0ec: c2 07 bf fc ld [ %fp + -4 ], %g1
200a0f0: 80 a0 60 00 cmp %g1, 0
200a0f4: 12 80 00 30 bne 200a1b4 <pthread_setschedparam+0x104>
200a0f8: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200a0fc: fa 02 21 5c ld [ %o0 + 0x15c ], %i5
if ( api->schedpolicy == SCHED_SPORADIC )
200a100: c2 07 60 84 ld [ %i5 + 0x84 ], %g1
200a104: 80 a0 60 04 cmp %g1, 4
200a108: 32 80 00 05 bne,a 200a11c <pthread_setschedparam+0x6c>
200a10c: f2 27 60 84 st %i1, [ %i5 + 0x84 ]
(void) _Watchdog_Remove( &api->Sporadic_timer );
200a110: 40 00 10 28 call 200e1b0 <_Watchdog_Remove>
200a114: 90 07 60 a8 add %i5, 0xa8, %o0
api->schedpolicy = policy;
200a118: f2 27 60 84 st %i1, [ %i5 + 0x84 ]
api->schedparam = *param;
200a11c: 90 07 60 88 add %i5, 0x88, %o0
200a120: 92 10 00 1a mov %i2, %o1
200a124: 40 00 23 d0 call 2013064 <memcpy>
200a128: 94 10 20 1c mov 0x1c, %o2
the_thread->budget_algorithm = budget_algorithm;
200a12c: c2 07 bf f4 ld [ %fp + -12 ], %g1
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
200a130: 80 a6 60 00 cmp %i1, 0
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
200a134: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
the_thread->budget_callout = budget_callout;
200a138: c2 07 bf f8 ld [ %fp + -8 ], %g1
switch ( api->schedpolicy ) {
200a13c: 06 80 00 1b bl 200a1a8 <pthread_setschedparam+0xf8> <== NEVER TAKEN
200a140: c2 27 20 7c st %g1, [ %i4 + 0x7c ]
200a144: 80 a6 60 02 cmp %i1, 2
200a148: 04 80 00 07 ble 200a164 <pthread_setschedparam+0xb4>
200a14c: 03 00 80 8a sethi %hi(0x2022800), %g1
200a150: 80 a6 60 04 cmp %i1, 4
200a154: 12 80 00 15 bne 200a1a8 <pthread_setschedparam+0xf8> <== NEVER TAKEN
200a158: 01 00 00 00 nop
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
200a15c: 10 80 00 0d b 200a190 <pthread_setschedparam+0xe0>
200a160: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
200a164: c2 00 63 10 ld [ %g1 + 0x310 ], %g1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
200a168: 90 10 00 1c mov %i4, %o0
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
200a16c: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
200a170: 03 00 80 87 sethi %hi(0x2021c00), %g1
200a174: d2 08 62 ac ldub [ %g1 + 0x2ac ], %o1 ! 2021eac <rtems_maximum_priority>
200a178: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
200a17c: 94 10 20 01 mov 1, %o2
200a180: 92 22 40 01 sub %o1, %g1, %o1
200a184: 40 00 0a d5 call 200ccd8 <_Thread_Change_priority>
200a188: d2 27 20 18 st %o1, [ %i4 + 0x18 ]
the_thread,
the_thread->real_priority,
true
);
break;
200a18c: 30 80 00 07 b,a 200a1a8 <pthread_setschedparam+0xf8>
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
_Watchdog_Remove( &api->Sporadic_timer );
200a190: 90 07 60 a8 add %i5, 0xa8, %o0
200a194: 40 00 10 07 call 200e1b0 <_Watchdog_Remove>
200a198: c2 27 60 a4 st %g1, [ %i5 + 0xa4 ]
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
200a19c: 90 10 20 00 clr %o0
200a1a0: 7f ff ff 7e call 2009f98 <_POSIX_Threads_Sporadic_budget_TSR>
200a1a4: 92 10 00 1c mov %i4, %o1
break;
}
_Thread_Enable_dispatch();
200a1a8: 40 00 0b fe call 200d1a0 <_Thread_Enable_dispatch>
200a1ac: b0 10 00 1b mov %i3, %i0
200a1b0: 30 80 00 03 b,a 200a1bc <pthread_setschedparam+0x10c>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
200a1b4: b6 10 20 03 mov 3, %i3
}
200a1b8: b0 10 00 1b mov %i3, %i0
200a1bc: 81 c7 e0 08 ret
200a1c0: 81 e8 00 00 restore
020079d4 <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
20079d4: 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() )
20079d8: 03 00 80 7a sethi %hi(0x201e800), %g1
20079dc: 82 10 61 40 or %g1, 0x140, %g1 ! 201e940 <_Per_CPU_Information>
20079e0: c4 00 60 08 ld [ %g1 + 8 ], %g2
20079e4: 80 a0 a0 00 cmp %g2, 0
20079e8: 12 80 00 16 bne 2007a40 <pthread_testcancel+0x6c> <== NEVER TAKEN
20079ec: 05 00 80 79 sethi %hi(0x201e400), %g2
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
20079f0: c2 00 60 10 ld [ %g1 + 0x10 ], %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;
20079f4: c6 00 a0 20 ld [ %g2 + 0x20 ], %g3
20079f8: c2 00 61 5c ld [ %g1 + 0x15c ], %g1
++level;
20079fc: 86 00 e0 01 inc %g3
_Thread_Dispatch_disable_level = level;
2007a00: c6 20 a0 20 st %g3, [ %g2 + 0x20 ]
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
2007a04: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2
2007a08: 80 a0 a0 00 cmp %g2, 0
2007a0c: 12 80 00 05 bne 2007a20 <pthread_testcancel+0x4c> <== NEVER TAKEN
2007a10: ba 10 20 00 clr %i5
2007a14: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1
2007a18: 80 a0 00 01 cmp %g0, %g1
2007a1c: ba 40 20 00 addx %g0, 0, %i5
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
2007a20: 40 00 0b c1 call 200a924 <_Thread_Enable_dispatch>
2007a24: 01 00 00 00 nop
if ( cancel )
2007a28: 80 8f 60 ff btst 0xff, %i5
2007a2c: 02 80 00 05 be 2007a40 <pthread_testcancel+0x6c>
2007a30: 03 00 80 7a sethi %hi(0x201e800), %g1
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
2007a34: f0 00 61 50 ld [ %g1 + 0x150 ], %i0 ! 201e950 <_Per_CPU_Information+0x10>
2007a38: 40 00 17 43 call 200d744 <_POSIX_Thread_Exit>
2007a3c: 93 e8 3f ff restore %g0, -1, %o1
2007a40: 81 c7 e0 08 ret
2007a44: 81 e8 00 00 restore
0200c82c <ramdisk_allocate>:
void *area_begin,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace
)
{
200c82c: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
200c830: 7f ff e1 3c call 2004d20 <malloc>
200c834: 90 10 20 10 mov 0x10, %o0
if (rd == NULL) {
200c838: ba 92 20 00 orcc %o0, 0, %i5
200c83c: 02 80 00 16 be 200c894 <ramdisk_allocate+0x68> <== NEVER TAKEN
200c840: 80 a6 20 00 cmp %i0, 0
return NULL;
}
if (area_begin == NULL) {
200c844: 32 80 00 0e bne,a 200c87c <ramdisk_allocate+0x50>
200c848: c0 2f 60 0d clrb [ %i5 + 0xd ]
area_begin = calloc(media_block_count, media_block_size);
200c84c: 90 10 00 1a mov %i2, %o0
200c850: 7f ff df 1f call 20044cc <calloc>
200c854: 92 10 00 19 mov %i1, %o1
if (area_begin == NULL) {
200c858: b0 92 20 00 orcc %o0, 0, %i0
200c85c: 12 80 00 07 bne 200c878 <ramdisk_allocate+0x4c> <== ALWAYS TAKEN
200c860: 82 10 20 01 mov 1, %g1
free(rd);
200c864: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200c868: 7f ff df ed call 200481c <free> <== NOT EXECUTED
200c86c: ba 10 20 00 clr %i5 <== NOT EXECUTED
return NULL;
200c870: 81 c7 e0 08 ret <== NOT EXECUTED
200c874: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
200c878: c2 2f 60 0d stb %g1, [ %i5 + 0xd ]
}
rd->block_size = media_block_size;
rd->block_num = media_block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
200c87c: 82 10 20 01 mov 1, %g1
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = media_block_size;
200c880: f2 27 40 00 st %i1, [ %i5 ]
rd->block_num = media_block_count;
200c884: f4 27 60 04 st %i2, [ %i5 + 4 ]
rd->area = area_begin;
200c888: f0 27 60 08 st %i0, [ %i5 + 8 ]
rd->trace = trace;
200c88c: f6 2f 60 0e stb %i3, [ %i5 + 0xe ]
rd->initialized = true;
200c890: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
return rd;
}
200c894: b0 10 00 1d mov %i5, %i0
200c898: 81 c7 e0 08 ret
200c89c: 81 e8 00 00 restore
0200c8a0 <ramdisk_free>:
void ramdisk_free(ramdisk *rd)
{
200c8a0: 9d e3 bf a0 save %sp, -96, %sp
if (rd != NULL) {
200c8a4: 80 a6 20 00 cmp %i0, 0
200c8a8: 02 80 00 0a be 200c8d0 <ramdisk_free+0x30> <== NEVER TAKEN
200c8ac: 01 00 00 00 nop
if (rd->malloced) {
200c8b0: c2 0e 20 0d ldub [ %i0 + 0xd ], %g1
200c8b4: 80 a0 60 00 cmp %g1, 0
200c8b8: 02 80 00 04 be 200c8c8 <ramdisk_free+0x28>
200c8bc: 01 00 00 00 nop
free(rd->area);
200c8c0: 7f ff df d7 call 200481c <free>
200c8c4: d0 06 20 08 ld [ %i0 + 8 ], %o0
}
free(rd);
200c8c8: 7f ff df d5 call 200481c <free>
200c8cc: 81 e8 00 00 restore
200c8d0: 81 c7 e0 08 ret <== NOT EXECUTED
200c8d4: 81 e8 00 00 restore <== NOT EXECUTED
0200daac <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
200daac: 9d e3 bf 88 save %sp, -120, %sp
rtems_device_minor_number i;
rtems_ramdisk_config *c = rtems_ramdisk_configuration;
struct ramdisk *r;
rtems_status_code rc;
rc = rtems_disk_io_initialize();
200dab0: 7f ff da ff call 20046ac <rtems_disk_io_initialize>
200dab4: a8 10 00 18 mov %i0, %l4
if (rc != RTEMS_SUCCESSFUL)
200dab8: b0 92 20 00 orcc %o0, 0, %i0
200dabc: 12 80 00 46 bne 200dbd4 <ramdisk_initialize+0x128> <== NEVER TAKEN
200dac0: 3b 00 80 98 sethi %hi(0x2026000), %i5
* This is allocating memory for a RAM disk which will persist for
* the life of the system. RTEMS has no "de-initialize" driver call
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
200dac4: d0 07 60 5c ld [ %i5 + 0x5c ], %o0 ! 202605c <rtems_ramdisk_configuration_size>
200dac8: 92 10 20 10 mov 0x10, %o1
200dacc: 7f ff de 9b call 2005538 <calloc>
200dad0: 33 00 80 98 sethi %hi(0x2026000), %i1
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
200dad4: a6 10 00 1d mov %i5, %l3
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
200dad8: 39 0b d9 19 sethi %hi(0x2f646400), %i4
200dadc: 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,
200dae0: 2b 00 80 36 sethi %hi(0x200d800), %l5
* This is allocating memory for a RAM disk which will persist for
* the life of the system. RTEMS has no "de-initialize" driver call
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
200dae4: b6 10 00 08 mov %o0, %i3
r->trace = false;
200dae8: c0 2a 20 0e clrb [ %o0 + 0xe ]
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
rtems_device_minor_number i;
rtems_ramdisk_config *c = rtems_ramdisk_configuration;
200daec: b2 16 60 60 or %i1, 0x60, %i1
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
200daf0: b4 10 20 00 clr %i2
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
200daf4: b8 17 21 76 or %i4, 0x176, %i4
200daf8: 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);
200dafc: b0 07 bf f0 add %fp, -16, %i0
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
200db00: aa 15 63 dc or %l5, 0x3dc, %l5
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
200db04: 10 80 00 2f b 200dbc0 <ramdisk_initialize+0x114>
200db08: a0 10 20 01 mov 1, %l0
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
200db0c: f4 2f bf f8 stb %i2, [ %fp + -8 ]
r->block_size = c->block_size;
200db10: e4 06 40 00 ld [ %i1 ], %l2
r->block_num = c->block_num;
200db14: e2 06 60 04 ld [ %i1 + 4 ], %l1
if (c->location == NULL)
200db18: c2 06 60 08 ld [ %i1 + 8 ], %g1
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
200db1c: e4 26 c0 00 st %l2, [ %i3 ]
r->block_num = c->block_num;
if (c->location == NULL)
200db20: 80 a0 60 00 cmp %g1, 0
200db24: 12 80 00 0f bne 200db60 <ramdisk_initialize+0xb4> <== NEVER TAKEN
200db28: e2 26 e0 04 st %l1, [ %i3 + 4 ]
{
r->malloced = true;
r->area = malloc(r->block_size * r->block_num);
200db2c: 92 10 00 12 mov %l2, %o1
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
{
r->malloced = true;
200db30: e0 2e e0 0d stb %l0, [ %i3 + 0xd ]
r->area = malloc(r->block_size * r->block_num);
200db34: 40 00 4f 4d call 2021868 <.umul>
200db38: 90 10 00 11 mov %l1, %o0
200db3c: 7f ff e0 e4 call 2005ecc <malloc>
200db40: 01 00 00 00 nop
if (r->area == NULL) /* No enough memory for this disk */
200db44: 80 a2 20 00 cmp %o0, 0
200db48: 12 80 00 04 bne 200db58 <ramdisk_initialize+0xac> <== ALWAYS TAKEN
200db4c: d0 26 e0 08 st %o0, [ %i3 + 8 ]
{
if (r->malloced)
{
free(r->area);
}
r->initialized = false;
200db50: 10 80 00 19 b 200dbb4 <ramdisk_initialize+0x108> <== NOT EXECUTED
200db54: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
r->initialized = false;
continue;
}
else
{
r->initialized = true;
200db58: 10 80 00 05 b 200db6c <ramdisk_initialize+0xc0>
200db5c: e0 2e e0 0c stb %l0, [ %i3 + 0xc ]
}
}
else
{
r->malloced = false;
200db60: c0 2e e0 0d clrb [ %i3 + 0xd ] <== NOT EXECUTED
r->initialized = true;
200db64: e0 2e e0 0c stb %l0, [ %i3 + 0xc ] <== NOT EXECUTED
r->area = c->location;
200db68: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
200db6c: f0 23 a0 5c st %i0, [ %sp + 0x5c ]
200db70: 90 10 00 14 mov %l4, %o0
200db74: 92 10 00 1a mov %i2, %o1
200db78: 94 10 00 12 mov %l2, %o2
200db7c: 96 10 00 11 mov %l1, %o3
200db80: 98 10 00 15 mov %l5, %o4
200db84: 7f ff da 34 call 2004454 <rtems_disk_create_phys>
200db88: 9a 10 00 1b mov %i3, %o5
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
200db8c: 80 a2 20 00 cmp %o0, 0
200db90: 22 80 00 0a be,a 200dbb8 <ramdisk_initialize+0x10c> <== ALWAYS TAKEN
200db94: b4 06 a0 01 inc %i2
{
if (r->malloced)
200db98: c2 0e e0 0d ldub [ %i3 + 0xd ], %g1 <== NOT EXECUTED
200db9c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200dba0: 22 80 00 05 be,a 200dbb4 <ramdisk_initialize+0x108> <== NOT EXECUTED
200dba4: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
{
free(r->area);
200dba8: 7f ff df 38 call 2005888 <free> <== NOT EXECUTED
200dbac: d0 06 e0 08 ld [ %i3 + 8 ], %o0 <== NOT EXECUTED
}
r->initialized = false;
200dbb0: 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++)
200dbb4: b4 06 a0 01 inc %i2 <== NOT EXECUTED
200dbb8: b2 06 60 0c add %i1, 0xc, %i1
200dbbc: b6 06 e0 10 add %i3, 0x10, %i3
200dbc0: c2 04 e0 5c ld [ %l3 + 0x5c ], %g1
200dbc4: 80 a6 80 01 cmp %i2, %g1
200dbc8: 2a bf ff d1 bcs,a 200db0c <ramdisk_initialize+0x60>
200dbcc: f8 3f bf f0 std %i4, [ %fp + -16 ]
free(r->area);
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
200dbd0: b0 10 20 00 clr %i0
}
200dbd4: 81 c7 e0 08 ret
200dbd8: 81 e8 00 00 restore
0200c700 <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200c700: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
200c704: 05 08 00 10 sethi %hi(0x20004000), %g2
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200c708: ba 10 00 1a mov %i2, %i5
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
200c70c: 84 10 a2 07 or %g2, 0x207, %g2
200c710: 80 a6 40 02 cmp %i1, %g2
200c714: 02 80 00 37 be 200c7f0 <ramdisk_ioctl+0xf0>
200c718: f8 06 20 3c ld [ %i0 + 0x3c ], %i4
200c71c: 05 30 06 10 sethi %hi(0xc0184000), %g2
200c720: 84 10 a2 01 or %g2, 0x201, %g2 ! c0184201 <RAM_END+0xbdd84201>
200c724: 80 a6 40 02 cmp %i1, %g2
200c728: 12 80 00 39 bne 200c80c <ramdisk_ioctl+0x10c>
200c72c: 01 00 00 00 nop
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
200c730: c2 06 80 00 ld [ %i2 ], %g1
200c734: 80 a0 60 00 cmp %g1, 0
200c738: 02 80 00 07 be 200c754 <ramdisk_ioctl+0x54>
200c73c: b6 06 a0 18 add %i2, 0x18, %i3
200c740: 80 a0 60 01 cmp %g1, 1
200c744: 12 80 00 34 bne 200c814 <ramdisk_ioctl+0x114> <== NEVER TAKEN
200c748: 01 00 00 00 nop
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
200c74c: 10 80 00 14 b 200c79c <ramdisk_ioctl+0x9c>
200c750: f2 07 20 08 ld [ %i4 + 8 ], %i1
#endif
static int
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *from = rd->area;
200c754: f2 07 20 08 ld [ %i4 + 8 ], %i1
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
200c758: 10 80 00 0b b 200c784 <ramdisk_ioctl+0x84>
200c75c: 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);
200c760: d2 07 00 00 ld [ %i4 ], %o1
200c764: 40 00 3f ce call 201c69c <.umul>
200c768: f0 06 e0 08 ld [ %i3 + 8 ], %i0
200c76c: d4 06 e0 04 ld [ %i3 + 4 ], %o2
200c770: 92 06 40 08 add %i1, %o0, %o1
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
200c774: b4 06 a0 01 inc %i2
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
from + (sg->block * rd->block_size));
#endif
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
200c778: 90 10 00 18 mov %i0, %o0
200c77c: 40 00 1e ee call 2014334 <memcpy>
200c780: b6 06 e0 10 add %i3, 0x10, %i3
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
200c784: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200c788: 80 a6 80 01 cmp %i2, %g1
200c78c: 2a bf ff f5 bcs,a 200c760 <ramdisk_ioctl+0x60>
200c790: d0 06 c0 00 ld [ %i3 ], %o0
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
200c794: 10 80 00 11 b 200c7d8 <ramdisk_ioctl+0xd8>
200c798: c2 07 60 04 ld [ %i5 + 4 ], %g1
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
200c79c: 10 80 00 0a b 200c7c4 <ramdisk_ioctl+0xc4>
200c7a0: 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);
200c7a4: d2 07 00 00 ld [ %i4 ], %o1
200c7a8: 40 00 3f bd call 201c69c <.umul>
200c7ac: b4 06 a0 01 inc %i2
200c7b0: d2 06 e0 08 ld [ %i3 + 8 ], %o1
200c7b4: d4 06 e0 04 ld [ %i3 + 4 ], %o2
200c7b8: 90 06 40 08 add %i1, %o0, %o0
200c7bc: 40 00 1e de call 2014334 <memcpy>
200c7c0: b6 06 e0 10 add %i3, 0x10, %i3
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
200c7c4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200c7c8: 80 a6 80 01 cmp %i2, %g1
200c7cc: 2a bf ff f6 bcs,a 200c7a4 <ramdisk_ioctl+0xa4>
200c7d0: d0 06 c0 00 ld [ %i3 ], %o0
200c7d4: c2 07 60 04 ld [ %i5 + 4 ], %g1
200c7d8: 90 10 00 1d mov %i5, %o0
200c7dc: 92 10 20 00 clr %o1
200c7e0: 9f c0 40 00 call %g1
200c7e4: 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);
200c7e8: 81 c7 e0 08 ret
200c7ec: 81 e8 00 00 restore
}
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
200c7f0: c2 0f 20 0f ldub [ %i4 + 0xf ], %g1
200c7f4: 80 a0 60 00 cmp %g1, 0
200c7f8: 02 80 00 07 be 200c814 <ramdisk_ioctl+0x114>
200c7fc: 01 00 00 00 nop
ramdisk_free(rd);
200c800: 40 00 00 28 call 200c8a0 <ramdisk_free>
200c804: 90 10 00 1c mov %i4, %o0
200c808: 30 80 00 03 b,a 200c814 <ramdisk_ioctl+0x114>
}
break;
default:
return rtems_blkdev_ioctl (dd, req, argp);
200c80c: 40 00 0a 01 call 200f010 <rtems_blkdev_ioctl>
200c810: 81 e8 00 00 restore
break;
}
errno = EINVAL;
200c814: 40 00 1c 77 call 20139f0 <__errno>
200c818: b0 10 3f ff mov -1, %i0
200c81c: 82 10 20 16 mov 0x16, %g1
200c820: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
200c824: 81 c7 e0 08 ret
200c828: 81 e8 00 00 restore
0200c8d8 <ramdisk_register>:
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
200c8d8: 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);
200c8dc: 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;
200c8e0: c0 27 bf fc clr [ %fp + -4 ]
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
200c8e4: 13 00 80 7e sethi %hi(0x201f800), %o1
200c8e8: 94 07 bf fc add %fp, -4, %o2
200c8ec: 92 12 62 18 or %o1, 0x218, %o1
200c8f0: 7f ff f2 86 call 2009308 <rtems_io_register_driver>
200c8f4: a0 10 20 0d mov 0xd, %l0
if (sc != RTEMS_SUCCESSFUL) {
200c8f8: 80 a2 20 00 cmp %o0, 0
200c8fc: 32 80 00 20 bne,a 200c97c <ramdisk_register+0xa4> <== NEVER TAKEN
200c900: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);
200c904: 96 10 00 1a mov %i2, %o3
200c908: 92 10 00 18 mov %i0, %o1
200c90c: 7f ff ff c8 call 200c82c <ramdisk_allocate>
200c910: 94 10 00 19 mov %i1, %o2
if (rd == NULL) {
200c914: b4 92 20 00 orcc %o0, 0, %i2
200c918: 12 80 00 04 bne 200c928 <ramdisk_register+0x50> <== ALWAYS TAKEN
200c91c: fa 07 bf fc ld [ %fp + -4 ], %i5
rtems_io_unregister_driver(major);
200c920: 10 80 00 11 b 200c964 <ramdisk_register+0x8c> <== NOT EXECUTED
200c924: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
200c928: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
200c92c: 90 10 00 1d mov %i5, %o0
200c930: 92 10 20 00 clr %o1
200c934: 94 10 00 18 mov %i0, %o2
200c938: 96 10 00 19 mov %i1, %o3
200c93c: 19 00 80 31 sethi %hi(0x200c400), %o4
200c940: 9a 10 00 1a mov %i2, %o5
200c944: 7f ff dc 3b call 2003a30 <rtems_disk_create_phys>
200c948: 98 13 23 00 or %o4, 0x300, %o4
media_block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
200c94c: 80 a2 20 00 cmp %o0, 0
200c950: 22 80 00 08 be,a 200c970 <ramdisk_register+0x98> <== ALWAYS TAKEN
200c954: fa 27 00 00 st %i5, [ %i4 ]
ramdisk_free(rd);
200c958: 7f ff ff d2 call 200c8a0 <ramdisk_free> <== NOT EXECUTED
200c95c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_io_unregister_driver(major);
200c960: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
200c964: 7f ff f2 c8 call 2009484 <rtems_io_unregister_driver> <== NOT EXECUTED
200c968: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
200c96c: 30 80 00 04 b,a 200c97c <ramdisk_register+0xa4> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
200c970: c0 27 20 04 clr [ %i4 + 4 ]
return RTEMS_SUCCESSFUL;
200c974: a0 10 20 00 clr %l0
}
200c978: b0 10 00 10 mov %l0, %i0
200c97c: 81 c7 e0 08 ret
200c980: 81 e8 00 00 restore
02019dfc <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
2019dfc: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2019e00: 03 00 80 72 sethi %hi(0x201c800), %g1
2019e04: c2 00 61 f4 ld [ %g1 + 0x1f4 ], %g1 ! 201c9f4 <rtems_libio_number_iops>
2019e08: 80 a6 00 01 cmp %i0, %g1
2019e0c: 1a 80 00 16 bcc 2019e64 <read+0x68>
2019e10: 83 2e 20 03 sll %i0, 3, %g1
iop = rtems_libio_iop( fd );
2019e14: b1 2e 20 06 sll %i0, 6, %i0
2019e18: b0 26 00 01 sub %i0, %g1, %i0
2019e1c: 03 00 80 75 sethi %hi(0x201d400), %g1
2019e20: d0 00 60 44 ld [ %g1 + 0x44 ], %o0 ! 201d444 <rtems_libio_iops>
2019e24: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
2019e28: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
2019e2c: 80 88 61 00 btst 0x100, %g1
2019e30: 02 80 00 0d be 2019e64 <read+0x68>
2019e34: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
2019e38: 12 80 00 06 bne 2019e50 <read+0x54> <== ALWAYS TAKEN
2019e3c: 80 a6 a0 00 cmp %i2, 0
2019e40: 7f ff d6 0b call 200f66c <__errno> <== NOT EXECUTED
2019e44: 01 00 00 00 nop <== NOT EXECUTED
2019e48: 10 80 00 0a b 2019e70 <read+0x74> <== NOT EXECUTED
2019e4c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rtems_libio_check_count( count );
2019e50: 02 80 00 10 be 2019e90 <read+0x94>
2019e54: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
2019e58: 80 88 60 02 btst 2, %g1
2019e5c: 32 80 00 08 bne,a 2019e7c <read+0x80>
2019e60: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
2019e64: 7f ff d6 02 call 200f66c <__errno>
2019e68: 01 00 00 00 nop
2019e6c: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
2019e70: c2 22 00 00 st %g1, [ %o0 ]
2019e74: 81 c7 e0 08 ret
2019e78: 91 e8 3f ff restore %g0, -1, %o0
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
2019e7c: 92 10 00 19 mov %i1, %o1
2019e80: c2 00 60 08 ld [ %g1 + 8 ], %g1
2019e84: 9f c0 40 00 call %g1
2019e88: 94 10 00 1a mov %i2, %o2
2019e8c: b0 10 00 08 mov %o0, %i0
}
2019e90: 81 c7 e0 08 ret
2019e94: 81 e8 00 00 restore
020049d0 <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)
{
20049d0: 9d e3 bf 98 save %sp, -104, %sp
int i;
rtems_sector_data_t *sector = NULL;
20049d4: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t here;
uint8_t *data;
rtems_part_desc_t *new_part_desc;
rtems_status_code rc;
if ((ext_part == NULL) || (ext_part->disk_desc == NULL))
20049d8: 80 a6 a0 00 cmp %i2, 0
20049dc: 02 80 00 61 be 2004b60 <read_extended_partition+0x190> <== NEVER TAKEN
20049e0: ba 10 20 19 mov 0x19, %i5
20049e4: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
20049e8: 80 a0 60 00 cmp %g1, 0
20049ec: 02 80 00 5d be 2004b60 <read_extended_partition+0x190> <== NEVER TAKEN
20049f0: 90 10 00 18 mov %i0, %o0
{
return RTEMS_INTERNAL_ERROR;
}
/* get start sector of current extended partition */
here = ext_part->start;
20049f4: f6 06 a0 04 ld [ %i2 + 4 ], %i3
if (sector == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
20049f8: bb 2e e0 09 sll %i3, 9, %i5
new_off = lseek(fd, off, SEEK_SET);
20049fc: 92 10 20 00 clr %o1
2004a00: 94 10 00 1d mov %i5, %o2
2004a04: 40 00 04 be call 2005cfc <lseek>
2004a08: 96 10 20 00 clr %o3
if (new_off != off) {
2004a0c: 80 a2 20 00 cmp %o0, 0
2004a10: 32 80 00 0e bne,a 2004a48 <read_extended_partition+0x78> <== NEVER TAKEN
2004a14: ba 10 20 1b mov 0x1b, %i5 <== NOT EXECUTED
2004a18: 80 a2 40 1d cmp %o1, %i5
2004a1c: 12 80 00 0b bne 2004a48 <read_extended_partition+0x78> <== NEVER TAKEN
2004a20: ba 10 20 1b mov 0x1b, %i5
2004a24: 90 10 00 18 mov %i0, %o0
2004a28: 92 10 00 1b mov %i3, %o1
2004a2c: 7f ff ff a2 call 20048b4 <get_sector.part.0>
2004a30: 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)
2004a34: ba 92 20 00 orcc %o0, 0, %i5
2004a38: 02 80 00 09 be 2004a5c <read_extended_partition+0x8c> <== ALWAYS TAKEN
2004a3c: d0 07 bf f8 ld [ %fp + -8 ], %o0
{
if (sector)
2004a40: 10 80 00 04 b 2004a50 <read_extended_partition+0x80> <== NOT EXECUTED
2004a44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004a48: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
2004a4c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004a50: 22 80 00 45 be,a 2004b64 <read_extended_partition+0x194> <== NOT EXECUTED
2004a54: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
2004a58: 30 80 00 40 b,a 2004b58 <read_extended_partition+0x188> <== NOT EXECUTED
static bool
msdos_signature_check (rtems_sector_data_t *sector)
{
uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&
2004a5c: c6 0a 22 02 ldub [ %o0 + 0x202 ], %g3
2004a60: 80 a0 e0 55 cmp %g3, 0x55
2004a64: 12 80 00 06 bne 2004a7c <read_extended_partition+0xac> <== NEVER TAKEN
2004a68: 84 10 20 00 clr %g2
2004a6c: c4 0a 22 03 ldub [ %o0 + 0x203 ], %g2
2004a70: 84 18 a0 aa xor %g2, 0xaa, %g2
2004a74: 80 a0 00 02 cmp %g0, %g2
2004a78: 84 60 3f ff subx %g0, -1, %g2
if (sector)
free(sector);
return rc;
}
if (!msdos_signature_check(sector))
2004a7c: 80 a0 a0 00 cmp %g2, 0
2004a80: 12 80 00 06 bne 2004a98 <read_extended_partition+0xc8> <== ALWAYS TAKEN
2004a84: a0 02 21 d2 add %o0, 0x1d2, %l0
{
free(sector);
2004a88: 40 00 03 80 call 2005888 <free> <== NOT EXECUTED
2004a8c: ba 10 20 19 mov 0x19, %i5 <== NOT EXECUTED
}
free(sector);
return RTEMS_SUCCESSFUL;
}
2004a90: 81 c7 e0 08 ret <== NOT EXECUTED
2004a94: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
2004a98: 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)
2004a9c: a2 06 a0 10 add %i2, 0x10, %l1
2004aa0: 90 04 3f f0 add %l0, -16, %o0
2004aa4: 7f ff ff 9a call 200490c <data_to_part_desc.part.1>
2004aa8: 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)
2004aac: ba 92 20 00 orcc %o0, 0, %i5
2004ab0: 02 80 00 04 be 2004ac0 <read_extended_partition+0xf0> <== ALWAYS TAKEN
2004ab4: d4 07 bf fc ld [ %fp + -4 ], %o2
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
2004ab8: 10 80 00 28 b 2004b58 <read_extended_partition+0x188> <== NOT EXECUTED
2004abc: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
{
free(sector);
return rc;
}
if (new_part_desc == NULL)
2004ac0: 80 a2 a0 00 cmp %o2, 0
2004ac4: 22 80 00 21 be,a 2004b48 <read_extended_partition+0x178>
2004ac8: b8 07 20 04 add %i4, 4, %i4
{
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
2004acc: d4 27 20 18 st %o2, [ %i4 + 0x18 ]
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
2004ad0: 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));
2004ad4: 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;
2004ad8: 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))
2004adc: 84 08 a0 7f and %g2, 0x7f, %g2
continue;
}
ext_part->sub_part[i] = new_part_desc;
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
2004ae0: c2 22 a0 10 st %g1, [ %o2 + 0x10 ]
if (is_extended(new_part_desc->sys_type))
2004ae4: 80 a0 a0 05 cmp %g2, 5
2004ae8: 12 80 00 0a bne 2004b10 <read_extended_partition+0x140>
2004aec: c4 02 a0 04 ld [ %o2 + 4 ], %g2
{
new_part_desc->log_id = EMPTY_PARTITION;
new_part_desc->start += start;
2004af0: 84 00 80 19 add %g2, %i1, %g2
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
{
new_part_desc->log_id = EMPTY_PARTITION;
2004af4: c0 2a a0 02 clrb [ %o2 + 2 ]
new_part_desc->start += start;
2004af8: c4 22 a0 04 st %g2, [ %o2 + 4 ]
read_extended_partition(fd, start, new_part_desc);
2004afc: 90 10 00 18 mov %i0, %o0
2004b00: 7f ff ff b4 call 20049d0 <read_extended_partition>
2004b04: 92 10 00 19 mov %i1, %o1
2004b08: 10 80 00 10 b 2004b48 <read_extended_partition+0x178>
2004b0c: b8 07 20 04 add %i4, 4, %i4
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
2004b10: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
2004b14: 88 00 e0 0a add %g3, 0xa, %g4
new_part_desc->log_id = ++disk_desc->last_log_id;
2004b18: 86 00 e0 01 inc %g3
read_extended_partition(fd, start, new_part_desc);
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
2004b1c: 89 29 20 02 sll %g4, 2, %g4
new_part_desc->log_id = ++disk_desc->last_log_id;
2004b20: c6 20 60 24 st %g3, [ %g1 + 0x24 ]
read_extended_partition(fd, start, new_part_desc);
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
2004b24: d4 20 40 04 st %o2, [ %g1 + %g4 ]
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
2004b28: 82 06 c0 02 add %i3, %g2, %g1
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
2004b2c: c4 02 a0 08 ld [ %o2 + 8 ], %g2
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
2004b30: c2 22 a0 04 st %g1, [ %o2 + 4 ]
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
2004b34: 84 00 bf ff add %g2, -1, %g2
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
new_part_desc->log_id = ++disk_desc->last_log_id;
2004b38: c6 2a a0 02 stb %g3, [ %o2 + 2 ]
new_part_desc->start += here;
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
2004b3c: 82 00 80 01 add %g2, %g1, %g1
2004b40: c2 22 a0 0c st %g1, [ %o2 + 0xc ]
2004b44: 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++)
2004b48: 80 a7 00 11 cmp %i4, %l1
2004b4c: 12 bf ff d5 bne 2004aa0 <read_extended_partition+0xd0>
2004b50: a0 04 20 10 add %l0, 0x10, %l0
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
2004b54: d0 07 bf f8 ld [ %fp + -8 ], %o0
2004b58: 40 00 03 4c call 2005888 <free>
2004b5c: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
2004b60: b0 10 00 1d mov %i5, %i0
2004b64: 81 c7 e0 08 ret
2004b68: 81 e8 00 00 restore
020050e0 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
20050e0: 9d e3 bf a0 save %sp, -96, %sp
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
20050e4: 03 00 80 75 sethi %hi(0x201d400), %g1
20050e8: c2 00 60 f4 ld [ %g1 + 0xf4 ], %g1 ! 201d4f4 <rtems_libio_number_iops>
20050ec: 80 a6 00 01 cmp %i0, %g1
20050f0: 2a 80 00 03 bcs,a 20050fc <readv+0x1c>
20050f4: 83 2e 20 03 sll %i0, 3, %g1
20050f8: 30 80 00 0c b,a 2005128 <readv+0x48>
iop = rtems_libio_iop( fd );
20050fc: b1 2e 20 06 sll %i0, 6, %i0
2005100: b0 26 00 01 sub %i0, %g1, %i0
2005104: 03 00 80 77 sethi %hi(0x201dc00), %g1
2005108: f8 00 63 44 ld [ %g1 + 0x344 ], %i4 ! 201df44 <rtems_libio_iops>
200510c: b8 07 00 18 add %i4, %i0, %i4
rtems_libio_check_is_open( iop );
2005110: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
2005114: 80 88 61 00 btst 0x100, %g1
2005118: 02 80 00 04 be 2005128 <readv+0x48>
200511c: 80 88 60 02 btst 2, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
2005120: 12 80 00 06 bne 2005138 <readv+0x58> <== ALWAYS TAKEN
2005124: 80 a6 60 00 cmp %i1, 0
2005128: 40 00 2c a0 call 20103a8 <__errno>
200512c: 01 00 00 00 nop
2005130: 10 80 00 1a b 2005198 <readv+0xb8>
2005134: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* Argument validation on IO vector
*/
if ( !iov )
2005138: 02 80 00 15 be 200518c <readv+0xac>
200513c: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
2005140: 04 80 00 13 ble 200518c <readv+0xac>
2005144: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
2005148: 24 80 00 03 ble,a 2005154 <readv+0x74> <== ALWAYS TAKEN
200514c: b5 2e a0 03 sll %i2, 3, %i2
2005150: 30 80 00 0f b,a 200518c <readv+0xac> <== NOT EXECUTED
*
* OpenGroup URL:
*
* http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
*/
ssize_t readv(
2005154: 82 10 20 00 clr %g1
2005158: 84 10 20 01 mov 1, %g2
200515c: 10 80 00 03 b 2005168 <readv+0x88>
2005160: 86 10 20 00 clr %g3
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
2005164: 86 10 00 1d mov %i5, %g3
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
2005168: c8 06 40 01 ld [ %i1 + %g1 ], %g4
200516c: 80 a1 20 00 cmp %g4, 0
2005170: 02 80 00 07 be 200518c <readv+0xac>
2005174: 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;
2005178: c8 01 20 04 ld [ %g4 + 4 ], %g4
200517c: ba 01 00 03 add %g4, %g3, %i5
if ( total < old )
2005180: 80 a7 40 03 cmp %i5, %g3
2005184: 16 80 00 07 bge 20051a0 <readv+0xc0>
2005188: 80 a0 00 04 cmp %g0, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
200518c: 40 00 2c 87 call 20103a8 <__errno>
2005190: 01 00 00 00 nop
2005194: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2005198: 10 80 00 20 b 2005218 <readv+0x138>
200519c: c2 22 00 00 st %g1, [ %o0 ]
20051a0: 82 00 60 08 add %g1, 8, %g1
if ( iov[v].iov_len )
all_zeros = false;
20051a4: 86 40 3f ff addx %g0, -1, %g3
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
20051a8: 80 a0 40 1a cmp %g1, %i2
20051ac: 12 bf ff ee bne 2005164 <readv+0x84>
20051b0: 84 08 80 03 and %g2, %g3, %g2
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
20051b4: 80 88 a0 ff btst 0xff, %g2
20051b8: 12 80 00 16 bne 2005210 <readv+0x130>
20051bc: b0 10 20 00 clr %i0
20051c0: ba 10 20 00 clr %i5
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
20051c4: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
*
* OpenGroup URL:
*
* http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
*/
ssize_t readv(
20051c8: b6 06 40 1d add %i1, %i5, %i3
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
20051cc: c2 00 60 08 ld [ %g1 + 8 ], %g1
20051d0: d2 06 40 1d ld [ %i1 + %i5 ], %o1
20051d4: d4 06 e0 04 ld [ %i3 + 4 ], %o2
20051d8: 9f c0 40 00 call %g1
20051dc: 90 10 00 1c mov %i4, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
20051e0: 80 a2 20 00 cmp %o0, 0
20051e4: 26 80 00 0b bl,a 2005210 <readv+0x130> <== NEVER TAKEN
20051e8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
20051ec: 32 80 00 02 bne,a 20051f4 <readv+0x114> <== ALWAYS TAKEN
20051f0: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
20051f4: c2 06 e0 04 ld [ %i3 + 4 ], %g1
20051f8: 80 a2 00 01 cmp %o0, %g1
20051fc: 12 80 00 05 bne 2005210 <readv+0x130> <== NEVER TAKEN
2005200: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
2005204: 80 a7 40 1a cmp %i5, %i2
2005208: 32 bf ff f0 bne,a 20051c8 <readv+0xe8>
200520c: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
2005210: 81 c7 e0 08 ret
2005214: 81 e8 00 00 restore
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
2005218: b0 10 3f ff mov -1, %i0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
200521c: 81 c7 e0 08 ret
2005220: 81 e8 00 00 restore
02004418 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
2004418: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
200441c: 03 00 80 75 sethi %hi(0x201d400), %g1
2004420: 82 10 60 50 or %g1, 0x50, %g1 ! 201d450 <rtems_malloc_statistics>
2004424: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
2004428: 84 00 a0 01 inc %g2
200442c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
2004430: 03 00 80 76 sethi %hi(0x201d800), %g1
2004434: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 201dae8 <_System_state_Current>
2004438: 80 a0 60 03 cmp %g1, 3
200443c: 12 80 00 09 bne 2004460 <realloc+0x48>
2004440: 80 a6 20 00 cmp %i0, 0
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
2004444: 03 00 80 75 sethi %hi(0x201d400), %g1
2004448: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 ! 201d5d0 <_Thread_Dispatch_disable_level>
200444c: 80 a0 60 00 cmp %g1, 0
2004450: 02 80 00 38 be 2004530 <realloc+0x118> <== ALWAYS TAKEN
2004454: 03 00 80 76 sethi %hi(0x201d800), %g1
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
return (void *) 0;
2004458: 81 c7 e0 08 ret <== NOT EXECUTED
200445c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
/*
* Continue with realloc().
*/
if ( !ptr )
2004460: 12 80 00 04 bne 2004470 <realloc+0x58>
2004464: 80 a6 60 00 cmp %i1, 0
return malloc( size );
2004468: 7f ff fd 26 call 2003900 <malloc>
200446c: 91 e8 00 19 restore %g0, %i1, %o0
if ( !size ) {
2004470: 12 80 00 06 bne 2004488 <realloc+0x70> <== ALWAYS TAKEN
2004474: 3b 00 80 72 sethi %hi(0x201c800), %i5
free( ptr );
2004478: 7f ff fc 4e call 20035b0 <free> <== NOT EXECUTED
200447c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
return (void *) 0;
2004480: 81 c7 e0 08 ret <== NOT EXECUTED
2004484: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
if ( !size ) {
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
2004488: d0 07 61 b0 ld [ %i5 + 0x1b0 ], %o0
200448c: 92 10 00 18 mov %i0, %o1
2004490: 40 00 13 e5 call 2009424 <_Protected_heap_Get_block_size>
2004494: 94 07 bf fc add %fp, -4, %o2
2004498: 80 8a 20 ff btst 0xff, %o0
200449c: 12 80 00 08 bne 20044bc <realloc+0xa4>
20044a0: d0 07 61 b0 ld [ %i5 + 0x1b0 ], %o0
errno = EINVAL;
20044a4: 40 00 2c 72 call 200f66c <__errno>
20044a8: 01 00 00 00 nop
20044ac: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
20044b0: c2 22 00 00 st %g1, [ %o0 ]
return (void *) 0;
20044b4: 81 c7 e0 08 ret
20044b8: 91 e8 20 00 restore %g0, 0, %o0
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
20044bc: 92 10 00 18 mov %i0, %o1
20044c0: 40 00 13 e9 call 2009464 <_Protected_heap_Resize_block>
20044c4: 94 10 00 19 mov %i1, %o2
20044c8: 80 8a 20 ff btst 0xff, %o0
20044cc: 12 80 00 1e bne 2004544 <realloc+0x12c>
20044d0: 01 00 00 00 nop
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
20044d4: 7f ff fd 0b call 2003900 <malloc>
20044d8: 90 10 00 19 mov %i1, %o0
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
20044dc: 03 00 80 75 sethi %hi(0x201d400), %g1
20044e0: 82 10 60 50 or %g1, 0x50, %g1 ! 201d450 <rtems_malloc_statistics>
20044e4: c4 00 60 04 ld [ %g1 + 4 ], %g2
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
20044e8: ba 10 00 08 mov %o0, %i5
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
20044ec: 84 00 bf ff add %g2, -1, %g2
if ( !new_area ) {
20044f0: 80 a2 20 00 cmp %o0, 0
20044f4: 02 bf ff f0 be 20044b4 <realloc+0x9c>
20044f8: c4 20 60 04 st %g2, [ %g1 + 4 ]
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
20044fc: c2 07 bf fc ld [ %fp + -4 ], %g1
2004500: 80 a6 40 01 cmp %i1, %g1
2004504: 08 80 00 03 bleu 2004510 <realloc+0xf8> <== NEVER TAKEN
2004508: 94 10 00 19 mov %i1, %o2
200450c: 94 10 00 01 mov %g1, %o2
2004510: 92 10 00 18 mov %i0, %o1
2004514: 40 00 2e a7 call 200ffb0 <memcpy>
2004518: 90 10 00 1d mov %i5, %o0
free( ptr );
200451c: 90 10 00 18 mov %i0, %o0
2004520: 7f ff fc 24 call 20035b0 <free>
2004524: b0 10 00 1d mov %i5, %i0
2004528: 81 c7 e0 08 ret
200452c: 81 e8 00 00 restore
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
2004530: c2 00 62 f8 ld [ %g1 + 0x2f8 ], %g1
2004534: 80 a0 60 00 cmp %g1, 0
2004538: 02 bf ff ca be 2004460 <realloc+0x48> <== ALWAYS TAKEN
200453c: 80 a6 20 00 cmp %i0, 0
2004540: 30 bf ff dd b,a 20044b4 <realloc+0x9c> <== NOT EXECUTED
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
2004544: 81 c7 e0 08 ret
2004548: 81 e8 00 00 restore
02007ed8 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
2007ed8: 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);
2007edc: 37 00 80 7e sethi %hi(0x201f800), %i3
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
2007ee0: ba 10 00 18 mov %i0, %i5
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
2007ee4: 40 00 02 85 call 20088f8 <pthread_mutex_lock>
2007ee8: 90 16 e1 bc or %i3, 0x1bc, %o0
if (result != 0) {
2007eec: b0 92 20 00 orcc %o0, 0, %i0
2007ef0: 02 80 00 06 be 2007f08 <rtems_aio_enqueue+0x30> <== ALWAYS TAKEN
2007ef4: 01 00 00 00 nop
free (req);
2007ef8: 7f ff ef 0f call 2003b34 <free> <== NOT EXECUTED
2007efc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2007f00: 81 c7 e0 08 ret <== NOT EXECUTED
2007f04: 81 e8 00 00 restore <== NOT EXECUTED
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
2007f08: 40 00 04 90 call 2009148 <pthread_self>
2007f0c: b6 16 e1 bc or %i3, 0x1bc, %i3
2007f10: 92 07 bf e0 add %fp, -32, %o1
2007f14: 40 00 03 9d call 2008d88 <pthread_getschedparam>
2007f18: 94 07 bf e4 add %fp, -28, %o2
req->caller_thread = pthread_self ();
2007f1c: 40 00 04 8b call 2009148 <pthread_self>
2007f20: 01 00 00 00 nop
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
2007f24: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2007f28: c6 07 bf e4 ld [ %fp + -28 ], %g3
2007f2c: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
2007f30: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
2007f34: 84 20 c0 02 sub %g3, %g2, %g2
2007f38: c4 27 60 0c st %g2, [ %i5 + 0xc ]
req->policy = policy;
2007f3c: c4 07 bf e0 ld [ %fp + -32 ], %g2
2007f40: c4 27 60 08 st %g2, [ %i5 + 8 ]
req->aiocbp->error_code = EINPROGRESS;
2007f44: 84 10 20 77 mov 0x77, %g2
2007f48: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
2007f4c: c4 06 e0 68 ld [ %i3 + 0x68 ], %g2
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
2007f50: c0 20 60 38 clr [ %g1 + 0x38 ]
if ((aio_request_queue.idle_threads == 0) &&
2007f54: 80 a0 a0 00 cmp %g2, 0
2007f58: 12 80 00 2e bne 2008010 <rtems_aio_enqueue+0x138> <== NEVER TAKEN
2007f5c: d2 00 40 00 ld [ %g1 ], %o1
2007f60: c2 06 e0 64 ld [ %i3 + 0x64 ], %g1
2007f64: 80 a0 60 04 cmp %g1, 4
2007f68: 14 80 00 2b bg 2008014 <rtems_aio_enqueue+0x13c>
2007f6c: 11 00 80 7e sethi %hi(0x201f800), %o0
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
2007f70: 90 06 e0 48 add %i3, 0x48, %o0
2007f74: 7f ff ff 7d call 2007d68 <rtems_aio_search_fd>
2007f78: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
2007f7c: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
2007f80: b8 10 00 08 mov %o0, %i4
if (r_chain->new_fd == 1) {
2007f84: 80 a0 60 01 cmp %g1, 1
2007f88: 12 80 00 1d bne 2007ffc <rtems_aio_enqueue+0x124>
2007f8c: b4 02 20 08 add %o0, 8, %i2
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
2007f90: 92 10 00 1d mov %i5, %o1
2007f94: 40 00 09 15 call 200a3e8 <_Chain_Insert>
2007f98: 90 10 00 1a mov %i2, %o0
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
2007f9c: 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;
2007fa0: c0 27 20 18 clr [ %i4 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
2007fa4: 40 00 01 fd call 2008798 <pthread_mutex_init>
2007fa8: 90 07 20 1c add %i4, 0x1c, %o0
pthread_cond_init (&r_chain->cond, NULL);
2007fac: 92 10 20 00 clr %o1
2007fb0: 40 00 00 ff call 20083ac <pthread_cond_init>
2007fb4: 90 07 20 20 add %i4, 0x20, %o0
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
2007fb8: 90 07 bf dc add %fp, -36, %o0
2007fbc: 92 06 e0 08 add %i3, 8, %o1
2007fc0: 15 00 80 1e sethi %hi(0x2007800), %o2
2007fc4: 96 10 00 1c mov %i4, %o3
2007fc8: 40 00 02 df call 2008b44 <pthread_create>
2007fcc: 94 12 a1 b0 or %o2, 0x1b0, %o2
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
2007fd0: ba 92 20 00 orcc %o0, 0, %i5
2007fd4: 22 80 00 07 be,a 2007ff0 <rtems_aio_enqueue+0x118> <== ALWAYS TAKEN
2007fd8: c2 06 e0 64 ld [ %i3 + 0x64 ], %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
2007fdc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2007fe0: 40 00 02 67 call 200897c <pthread_mutex_unlock> <== NOT EXECUTED
2007fe4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
2007fe8: 81 c7 e0 08 ret <== NOT EXECUTED
2007fec: 81 e8 00 00 restore <== NOT EXECUTED
return result;
}
++aio_request_queue.active_threads;
2007ff0: 82 00 60 01 inc %g1
2007ff4: 10 80 00 3a b 20080dc <rtems_aio_enqueue+0x204>
2007ff8: c2 26 e0 64 st %g1, [ %i3 + 0x64 ]
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
2007ffc: b6 02 20 1c add %o0, 0x1c, %i3
2008000: 40 00 02 3e call 20088f8 <pthread_mutex_lock>
2008004: 90 10 00 1b mov %i3, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
2008008: 10 80 00 0c b 2008038 <rtems_aio_enqueue+0x160>
200800c: 90 10 00 1a mov %i2, %o0
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
2008010: 11 00 80 7e sethi %hi(0x201f800), %o0 <== NOT EXECUTED
2008014: 94 10 20 00 clr %o2
2008018: 7f ff ff 54 call 2007d68 <rtems_aio_search_fd>
200801c: 90 12 22 04 or %o0, 0x204, %o0
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
2008020: b8 92 20 00 orcc %o0, 0, %i4
2008024: 02 80 00 0d be 2008058 <rtems_aio_enqueue+0x180>
2008028: b6 07 20 1c add %i4, 0x1c, %i3
{
pthread_mutex_lock (&r_chain->mutex);
200802c: 40 00 02 33 call 20088f8 <pthread_mutex_lock>
2008030: 90 10 00 1b mov %i3, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
2008034: 90 07 20 08 add %i4, 8, %o0
2008038: 7f ff fe fc call 2007c28 <rtems_aio_insert_prio>
200803c: 92 10 00 1d mov %i5, %o1
pthread_cond_signal (&r_chain->cond);
2008040: 40 00 01 0a call 2008468 <pthread_cond_signal>
2008044: 90 07 20 20 add %i4, 0x20, %o0
pthread_mutex_unlock (&r_chain->mutex);
2008048: 40 00 02 4d call 200897c <pthread_mutex_unlock>
200804c: 90 10 00 1b mov %i3, %o0
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
2008050: 10 80 00 24 b 20080e0 <rtems_aio_enqueue+0x208>
2008054: 11 00 80 7e sethi %hi(0x201f800), %o0
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
2008058: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200805c: 11 00 80 7e sethi %hi(0x201f800), %o0
2008060: d2 00 40 00 ld [ %g1 ], %o1
2008064: 90 12 22 10 or %o0, 0x210, %o0
2008068: 7f ff ff 40 call 2007d68 <rtems_aio_search_fd>
200806c: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
2008070: 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);
2008074: b8 10 00 08 mov %o0, %i4
2008078: 92 10 00 1d mov %i5, %o1
if (r_chain->new_fd == 1) {
200807c: 80 a0 60 01 cmp %g1, 1
2008080: 12 80 00 0d bne 20080b4 <rtems_aio_enqueue+0x1dc>
2008084: 90 02 20 08 add %o0, 8, %o0
2008088: 40 00 08 d8 call 200a3e8 <_Chain_Insert>
200808c: 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);
2008090: 90 07 20 1c add %i4, 0x1c, %o0
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
2008094: c0 27 20 18 clr [ %i4 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
2008098: 40 00 01 c0 call 2008798 <pthread_mutex_init>
200809c: 92 10 20 00 clr %o1
pthread_cond_init (&r_chain->cond, NULL);
20080a0: 90 07 20 20 add %i4, 0x20, %o0
20080a4: 40 00 00 c2 call 20083ac <pthread_cond_init>
20080a8: 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)
20080ac: 10 80 00 05 b 20080c0 <rtems_aio_enqueue+0x1e8>
20080b0: 11 00 80 7e sethi %hi(0x201f800), %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);
20080b4: 7f ff fe dd call 2007c28 <rtems_aio_insert_prio>
20080b8: 01 00 00 00 nop
if (aio_request_queue.idle_threads > 0)
20080bc: 11 00 80 7e sethi %hi(0x201f800), %o0
20080c0: 90 12 21 bc or %o0, 0x1bc, %o0 ! 201f9bc <aio_request_queue>
20080c4: c2 02 20 68 ld [ %o0 + 0x68 ], %g1
20080c8: 80 a0 60 00 cmp %g1, 0
20080cc: 24 80 00 05 ble,a 20080e0 <rtems_aio_enqueue+0x208> <== ALWAYS TAKEN
20080d0: 11 00 80 7e sethi %hi(0x201f800), %o0
pthread_cond_signal (&aio_request_queue.new_req);
20080d4: 40 00 00 e5 call 2008468 <pthread_cond_signal> <== NOT EXECUTED
20080d8: 90 02 20 04 add %o0, 4, %o0 ! 201f804 <__nlocale_changed> <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
20080dc: 11 00 80 7e sethi %hi(0x201f800), %o0
20080e0: 40 00 02 27 call 200897c <pthread_mutex_unlock>
20080e4: 90 12 21 bc or %o0, 0x1bc, %o0 ! 201f9bc <aio_request_queue>
return 0;
}
20080e8: 81 c7 e0 08 ret
20080ec: 81 e8 00 00 restore
020079b0 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
20079b0: 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);
20079b4: 3b 00 80 7e sethi %hi(0x201f800), %i5
20079b8: ba 17 61 bc or %i5, 0x1bc, %i5 ! 201f9bc <aio_request_queue>
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
20079bc: b4 07 60 58 add %i5, 0x58, %i2
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
20079c0: b2 07 60 4c add %i5, 0x4c, %i1
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
20079c4: a0 07 60 04 add %i5, 4, %l0
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
20079c8: b6 06 20 1c add %i0, 0x1c, %i3
20079cc: 40 00 03 cb call 20088f8 <pthread_mutex_lock>
20079d0: 90 10 00 1b mov %i3, %o0
if (result != 0)
20079d4: 80 a2 20 00 cmp %o0, 0
20079d8: 12 80 00 91 bne 2007c1c <rtems_aio_handle+0x26c> <== NEVER TAKEN
20079dc: 82 06 20 0c add %i0, 0xc, %g1
20079e0: f8 06 20 08 ld [ %i0 + 8 ], %i4
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
20079e4: 80 a7 00 01 cmp %i4, %g1
20079e8: 02 80 00 3b be 2007ad4 <rtems_aio_handle+0x124>
20079ec: 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);
20079f0: 40 00 05 d6 call 2009148 <pthread_self>
20079f4: 01 00 00 00 nop
20079f8: 92 07 bf d8 add %fp, -40, %o1
20079fc: 40 00 04 e3 call 2008d88 <pthread_getschedparam>
2007a00: 94 07 bf e4 add %fp, -28, %o2
param.sched_priority = req->priority;
2007a04: c2 07 20 0c ld [ %i4 + 0xc ], %g1
pthread_setschedparam (pthread_self(), req->policy, ¶m);
2007a08: 40 00 05 d0 call 2009148 <pthread_self>
2007a0c: c2 27 bf e4 st %g1, [ %fp + -28 ]
2007a10: d2 07 20 08 ld [ %i4 + 8 ], %o1
2007a14: 40 00 05 d1 call 2009158 <pthread_setschedparam>
2007a18: 94 07 bf e4 add %fp, -28, %o2
2007a1c: 40 00 0a 5a call 200a384 <_Chain_Extract>
2007a20: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
2007a24: 40 00 03 d6 call 200897c <pthread_mutex_unlock>
2007a28: 90 10 00 1b mov %i3, %o0
switch (req->aiocbp->aio_lio_opcode) {
2007a2c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2007a30: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
2007a34: 80 a0 a0 02 cmp %g2, 2
2007a38: 22 80 00 10 be,a 2007a78 <rtems_aio_handle+0xc8>
2007a3c: c4 18 60 08 ldd [ %g1 + 8 ], %g2
2007a40: 80 a0 a0 03 cmp %g2, 3
2007a44: 02 80 00 15 be 2007a98 <rtems_aio_handle+0xe8> <== NEVER TAKEN
2007a48: 80 a0 a0 01 cmp %g2, 1
2007a4c: 32 80 00 19 bne,a 2007ab0 <rtems_aio_handle+0x100> <== NEVER TAKEN
2007a50: f8 07 20 14 ld [ %i4 + 0x14 ], %i4 <== NOT EXECUTED
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
2007a54: c4 18 60 08 ldd [ %g1 + 8 ], %g2
2007a58: d0 00 40 00 ld [ %g1 ], %o0
2007a5c: d2 00 60 10 ld [ %g1 + 0x10 ], %o1
2007a60: d4 00 60 14 ld [ %g1 + 0x14 ], %o2
2007a64: 96 10 00 02 mov %g2, %o3
2007a68: 40 00 2a d0 call 20125a8 <pread>
2007a6c: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
2007a70: 10 80 00 0d b 2007aa4 <rtems_aio_handle+0xf4>
2007a74: 80 a2 3f ff cmp %o0, -1
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
2007a78: d0 00 40 00 ld [ %g1 ], %o0
2007a7c: d2 00 60 10 ld [ %g1 + 0x10 ], %o1
2007a80: d4 00 60 14 ld [ %g1 + 0x14 ], %o2
2007a84: 96 10 00 02 mov %g2, %o3
2007a88: 40 00 2b 06 call 20126a0 <pwrite>
2007a8c: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
2007a90: 10 80 00 05 b 2007aa4 <rtems_aio_handle+0xf4>
2007a94: 80 a2 3f ff cmp %o0, -1
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
2007a98: 40 00 1a a8 call 200e538 <fsync> <== NOT EXECUTED
2007a9c: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
2007aa0: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
2007aa4: 32 80 00 09 bne,a 2007ac8 <rtems_aio_handle+0x118> <== ALWAYS TAKEN
2007aa8: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
req->aiocbp->return_value = -1;
2007aac: f8 07 20 14 ld [ %i4 + 0x14 ], %i4 <== NOT EXECUTED
2007ab0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
req->aiocbp->error_code = errno;
2007ab4: 40 00 27 b7 call 2011990 <__errno> <== NOT EXECUTED
2007ab8: c2 27 20 38 st %g1, [ %i4 + 0x38 ] <== NOT EXECUTED
2007abc: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
2007ac0: 10 bf ff c2 b 20079c8 <rtems_aio_handle+0x18> <== NOT EXECUTED
2007ac4: c2 27 20 34 st %g1, [ %i4 + 0x34 ] <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
2007ac8: d0 20 60 38 st %o0, [ %g1 + 0x38 ]
req->aiocbp->error_code = 0;
2007acc: 10 bf ff bf b 20079c8 <rtems_aio_handle+0x18>
2007ad0: c0 20 60 34 clr [ %g1 + 0x34 ]
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
2007ad4: 40 00 03 aa call 200897c <pthread_mutex_unlock>
2007ad8: 90 10 00 1b mov %i3, %o0
pthread_mutex_lock (&aio_request_queue.mutex);
2007adc: 40 00 03 87 call 20088f8 <pthread_mutex_lock>
2007ae0: 90 10 00 1d mov %i5, %o0
if (rtems_chain_is_empty (chain))
2007ae4: c2 06 20 08 ld [ %i0 + 8 ], %g1
2007ae8: 80 a0 40 1c cmp %g1, %i4
2007aec: 12 80 00 48 bne 2007c0c <rtems_aio_handle+0x25c> <== NEVER TAKEN
2007af0: 92 07 bf dc add %fp, -36, %o1
{
clock_gettime (CLOCK_REALTIME, &timeout);
2007af4: 40 00 01 c9 call 2008218 <clock_gettime>
2007af8: 90 10 20 01 mov 1, %o0
timeout.tv_sec += 3;
2007afc: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
2007b00: 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;
2007b04: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
2007b08: b8 06 20 20 add %i0, 0x20, %i4
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
2007b0c: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
2007b10: 90 10 00 1c mov %i4, %o0
2007b14: 92 10 00 1d mov %i5, %o1
2007b18: 40 00 02 71 call 20084dc <pthread_cond_timedwait>
2007b1c: 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) {
2007b20: 80 a2 20 74 cmp %o0, 0x74
2007b24: 12 80 00 3a bne 2007c0c <rtems_aio_handle+0x25c> <== NEVER TAKEN
2007b28: 01 00 00 00 nop
2007b2c: 40 00 0a 16 call 200a384 <_Chain_Extract>
2007b30: 90 10 00 18 mov %i0, %o0
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
2007b34: 40 00 02 c4 call 2008644 <pthread_mutex_destroy>
2007b38: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->cond);
2007b3c: 40 00 01 e5 call 20082d0 <pthread_cond_destroy>
2007b40: 90 10 00 1c mov %i4, %o0
free (r_chain);
2007b44: 7f ff ef fc call 2003b34 <free>
2007b48: 90 10 00 18 mov %i0, %o0
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
2007b4c: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
2007b50: 80 a0 40 1a cmp %g1, %i2
2007b54: 12 80 00 1b bne 2007bc0 <rtems_aio_handle+0x210>
2007b58: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
2007b5c: 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;
2007b60: 82 00 60 01 inc %g1
2007b64: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
--aio_request_queue.active_threads;
2007b68: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
clock_gettime (CLOCK_REALTIME, &timeout);
2007b6c: 90 10 20 01 mov 1, %o0
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
2007b70: 82 00 7f ff add %g1, -1, %g1
clock_gettime (CLOCK_REALTIME, &timeout);
2007b74: 40 00 01 a9 call 2008218 <clock_gettime>
2007b78: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
timeout.tv_sec += 3;
2007b7c: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
2007b80: 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;
2007b84: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
2007b88: 90 10 00 10 mov %l0, %o0
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
2007b8c: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
2007b90: 92 10 00 1d mov %i5, %o1
2007b94: 40 00 02 52 call 20084dc <pthread_cond_timedwait>
2007b98: 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) {
2007b9c: 80 a2 20 74 cmp %o0, 0x74
2007ba0: 12 80 00 08 bne 2007bc0 <rtems_aio_handle+0x210> <== NEVER TAKEN
2007ba4: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
pthread_mutex_unlock (&aio_request_queue.mutex);
2007ba8: 90 10 00 1d mov %i5, %o0
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
2007bac: 82 00 7f ff add %g1, -1, %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
2007bb0: 40 00 03 73 call 200897c <pthread_mutex_unlock>
2007bb4: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
2007bb8: 81 c7 e0 08 ret
2007bbc: 91 e8 20 00 restore %g0, 0, %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
2007bc0: f0 07 60 54 ld [ %i5 + 0x54 ], %i0
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
2007bc4: 82 00 7f ff add %g1, -1, %g1
2007bc8: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
++aio_request_queue.active_threads;
2007bcc: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
2007bd0: 90 10 00 18 mov %i0, %o0
2007bd4: 82 00 60 01 inc %g1
2007bd8: 40 00 09 eb call 200a384 <_Chain_Extract>
2007bdc: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
2007be0: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
2007be4: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
2007be8: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
2007bec: 80 a0 c0 02 cmp %g3, %g2
2007bf0: 16 80 00 04 bge 2007c00 <rtems_aio_handle+0x250>
2007bf4: 80 a0 40 19 cmp %g1, %i1
2007bf8: 32 bf ff fc bne,a 2007be8 <rtems_aio_handle+0x238> <== ALWAYS TAKEN
2007bfc: c2 00 40 00 ld [ %g1 ], %g1
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
2007c00: d0 00 60 04 ld [ %g1 + 4 ], %o0
2007c04: 40 00 09 f9 call 200a3e8 <_Chain_Insert>
2007c08: 92 10 00 18 mov %i0, %o1
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
2007c0c: 40 00 03 5c call 200897c <pthread_mutex_unlock>
2007c10: 90 10 00 1d mov %i5, %o0
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
2007c14: 10 bf ff 6e b 20079cc <rtems_aio_handle+0x1c>
2007c18: b6 06 20 1c add %i0, 0x1c, %i3
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
2007c1c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2007c20: 81 c7 e0 08 ret <== NOT EXECUTED
2007c24: 81 e8 00 00 restore <== NOT EXECUTED
02007c88 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
2007c88: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
2007c8c: 3b 00 80 7e sethi %hi(0x201f800), %i5
2007c90: 40 00 03 93 call 2008adc <pthread_attr_init>
2007c94: 90 17 61 c4 or %i5, 0x1c4, %o0 ! 201f9c4 <aio_request_queue+0x8>
if (result != 0)
2007c98: b0 92 20 00 orcc %o0, 0, %i0
2007c9c: 12 80 00 31 bne 2007d60 <rtems_aio_init+0xd8> <== NEVER TAKEN
2007ca0: 90 17 61 c4 or %i5, 0x1c4, %o0
return result;
result =
2007ca4: 40 00 03 9a call 2008b0c <pthread_attr_setdetachstate>
2007ca8: 92 10 20 00 clr %o1
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
2007cac: 80 a2 20 00 cmp %o0, 0
2007cb0: 22 80 00 05 be,a 2007cc4 <rtems_aio_init+0x3c> <== ALWAYS TAKEN
2007cb4: 11 00 80 7e sethi %hi(0x201f800), %o0
pthread_attr_destroy (&aio_request_queue.attr);
2007cb8: 40 00 03 7d call 2008aac <pthread_attr_destroy> <== NOT EXECUTED
2007cbc: 90 17 61 c4 or %i5, 0x1c4, %o0 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
2007cc0: 11 00 80 7e sethi %hi(0x201f800), %o0 <== NOT EXECUTED
2007cc4: 92 10 20 00 clr %o1
2007cc8: 40 00 02 b4 call 2008798 <pthread_mutex_init>
2007ccc: 90 12 21 bc or %o0, 0x1bc, %o0
if (result != 0)
2007cd0: 80 a2 20 00 cmp %o0, 0
2007cd4: 22 80 00 06 be,a 2007cec <rtems_aio_init+0x64> <== ALWAYS TAKEN
2007cd8: 11 00 80 7e sethi %hi(0x201f800), %o0
pthread_attr_destroy (&aio_request_queue.attr);
2007cdc: 11 00 80 7e sethi %hi(0x201f800), %o0 <== NOT EXECUTED
2007ce0: 40 00 03 73 call 2008aac <pthread_attr_destroy> <== NOT EXECUTED
2007ce4: 90 12 21 c4 or %o0, 0x1c4, %o0 ! 201f9c4 <aio_request_queue+0x8><== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
2007ce8: 11 00 80 7e sethi %hi(0x201f800), %o0 <== NOT EXECUTED
2007cec: 92 10 20 00 clr %o1
2007cf0: 40 00 01 af call 20083ac <pthread_cond_init>
2007cf4: 90 12 21 c0 or %o0, 0x1c0, %o0
if (result != 0) {
2007cf8: b0 92 20 00 orcc %o0, 0, %i0
2007cfc: 02 80 00 09 be 2007d20 <rtems_aio_init+0x98> <== ALWAYS TAKEN
2007d00: 03 00 80 7e sethi %hi(0x201f800), %g1
pthread_mutex_destroy (&aio_request_queue.mutex);
2007d04: 11 00 80 7e sethi %hi(0x201f800), %o0 <== NOT EXECUTED
2007d08: 40 00 02 4f call 2008644 <pthread_mutex_destroy> <== NOT EXECUTED
2007d0c: 90 12 21 bc or %o0, 0x1bc, %o0 ! 201f9bc <aio_request_queue><== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
2007d10: 11 00 80 7e sethi %hi(0x201f800), %o0 <== NOT EXECUTED
2007d14: 40 00 03 66 call 2008aac <pthread_attr_destroy> <== NOT EXECUTED
2007d18: 90 12 21 c4 or %o0, 0x1c4, %o0 ! 201f9c4 <aio_request_queue+0x8><== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2007d1c: 03 00 80 7e sethi %hi(0x201f800), %g1 <== NOT EXECUTED
2007d20: 82 10 61 bc or %g1, 0x1bc, %g1 ! 201f9bc <aio_request_queue>
2007d24: 84 00 60 4c add %g1, 0x4c, %g2
2007d28: c4 20 60 48 st %g2, [ %g1 + 0x48 ]
head->previous = NULL;
tail->previous = head;
2007d2c: 84 00 60 48 add %g1, 0x48, %g2
2007d30: c4 20 60 50 st %g2, [ %g1 + 0x50 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2007d34: 84 00 60 58 add %g1, 0x58, %g2
2007d38: c4 20 60 54 st %g2, [ %g1 + 0x54 ]
head->previous = NULL;
tail->previous = head;
2007d3c: 84 00 60 54 add %g1, 0x54, %g2
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
2007d40: c0 20 60 4c clr [ %g1 + 0x4c ]
tail->previous = head;
2007d44: c4 20 60 5c st %g2, [ %g1 + 0x5c ]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
2007d48: c0 20 60 58 clr [ %g1 + 0x58 ]
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
2007d4c: 05 00 00 2c sethi %hi(0xb000), %g2
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
2007d50: c0 20 60 64 clr [ %g1 + 0x64 ]
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
2007d54: 84 10 a0 0b or %g2, 0xb, %g2
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
2007d58: c0 20 60 68 clr [ %g1 + 0x68 ]
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
2007d5c: c4 20 60 60 st %g2, [ %g1 + 0x60 ]
return result;
}
2007d60: 81 c7 e0 08 ret
2007d64: 81 e8 00 00 restore
02007c28 <rtems_aio_insert_prio>:
2007c28: 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 );
2007c2c: 86 02 20 04 add %o0, 4, %g3
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
2007c30: 80 a0 40 03 cmp %g1, %g3
2007c34: 02 80 00 0e be 2007c6c <rtems_aio_insert_prio+0x44> <== NEVER TAKEN
2007c38: 84 10 00 09 mov %o1, %g2
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
2007c3c: c8 00 60 14 ld [ %g1 + 0x14 ], %g4
while (req->aiocbp->aio_reqprio > prio &&
2007c40: da 02 60 14 ld [ %o1 + 0x14 ], %o5
if (rtems_chain_is_empty (chain)) {
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
2007c44: c8 01 20 18 ld [ %g4 + 0x18 ], %g4
while (req->aiocbp->aio_reqprio > prio &&
2007c48: 10 80 00 04 b 2007c58 <rtems_aio_insert_prio+0x30>
2007c4c: da 03 60 18 ld [ %o5 + 0x18 ], %o5
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
2007c50: c8 00 60 14 ld [ %g1 + 0x14 ], %g4 <== NOT EXECUTED
2007c54: c8 01 20 18 ld [ %g4 + 0x18 ], %g4 <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
2007c58: 80 a3 40 04 cmp %o5, %g4
2007c5c: 14 80 00 07 bg 2007c78 <rtems_aio_insert_prio+0x50> <== NEVER TAKEN
2007c60: 80 a0 40 03 cmp %g1, %g3
2007c64: d0 00 60 04 ld [ %g1 + 4 ], %o0
2007c68: 92 10 00 02 mov %g2, %o1
2007c6c: 82 13 c0 00 mov %o7, %g1
2007c70: 40 00 09 de call 200a3e8 <_Chain_Insert>
2007c74: 9e 10 40 00 mov %g1, %o7
2007c78: 32 bf ff f6 bne,a 2007c50 <rtems_aio_insert_prio+0x28> <== NOT EXECUTED
2007c7c: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
2007c80: 10 bf ff fa b 2007c68 <rtems_aio_insert_prio+0x40> <== NOT EXECUTED
2007c84: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
02007e58 <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)
{
2007e58: 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;
2007e5c: 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 );
2007e60: 82 06 20 04 add %i0, 4, %g1
if (rtems_chain_is_empty (chain))
2007e64: 80 a7 40 01 cmp %i5, %g1
2007e68: 12 80 00 09 bne 2007e8c <rtems_aio_remove_req+0x34>
2007e6c: b0 10 20 02 mov 2, %i0
2007e70: 81 c7 e0 08 ret
2007e74: 81 e8 00 00 restore
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
2007e78: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
2007e7c: 32 80 00 05 bne,a 2007e90 <rtems_aio_remove_req+0x38> <== NOT EXECUTED
2007e80: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
2007e84: 81 c7 e0 08 ret <== NOT EXECUTED
2007e88: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
2007e8c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
2007e90: 80 a0 80 19 cmp %g2, %i1
2007e94: 32 bf ff f9 bne,a 2007e78 <rtems_aio_remove_req+0x20> <== NEVER TAKEN
2007e98: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
2007e9c: 80 a7 40 01 cmp %i5, %g1
2007ea0: 02 bf ff f4 be 2007e70 <rtems_aio_remove_req+0x18> <== NEVER TAKEN
2007ea4: b0 10 20 01 mov 1, %i0
2007ea8: 40 00 09 37 call 200a384 <_Chain_Extract>
2007eac: 90 10 00 1d mov %i5, %o0
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
2007eb0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2007eb4: 84 10 20 8c mov 0x8c, %g2
2007eb8: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
current->aiocbp->return_value = -1;
2007ebc: 84 10 3f ff mov -1, %g2
free (current);
2007ec0: 90 10 00 1d mov %i5, %o0
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
2007ec4: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
free (current);
2007ec8: 7f ff ef 1b call 2003b34 <free>
2007ecc: b0 10 20 00 clr %i0
}
return AIO_CANCELED;
}
2007ed0: 81 c7 e0 08 ret
2007ed4: 81 e8 00 00 restore
0200d18c <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
200d18c: 9d e3 bf a0 save %sp, -96, %sp
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
200d190: 3b 00 80 85 sethi %hi(0x2021400), %i5
200d194: ba 17 62 4c or %i5, 0x24c, %i5 ! 202164c <bdbuf_cache>
200d198: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
200d19c: 80 a0 60 00 cmp %g1, 0
200d1a0: 22 80 00 12 be,a 200d1e8 <rtems_bdbuf_add_to_modified_list_after_access+0x5c><== ALWAYS TAKEN
200d1a4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
200d1a8: c4 07 60 38 ld [ %i5 + 0x38 ], %g2 <== NOT EXECUTED
200d1ac: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
200d1b0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
200d1b4: 32 80 00 0d bne,a 200d1e8 <rtems_bdbuf_add_to_modified_list_after_access+0x5c><== NOT EXECUTED
200d1b8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
200d1bc: 7f ff fe 4c call 200caec <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200d1c0: 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);
200d1c4: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
200d1c8: 7f ff fe 28 call 200ca68 <rtems_bdbuf_lock> <== NOT EXECUTED
200d1cc: 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,
200d1d0: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
200d1d4: 7f ff fe 3c call 200cac4 <rtems_bdbuf_unlock> <== NOT EXECUTED
200d1d8: 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 ();
200d1dc: 7f ff fe 2f call 200ca98 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200d1e0: 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
200d1e4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
200d1e8: 80 a0 60 05 cmp %g1, 5
200d1ec: 22 80 00 06 be,a 200d204 <rtems_bdbuf_add_to_modified_list_after_access+0x78>
200d1f0: 03 00 80 7b sethi %hi(0x201ec00), %g1
200d1f4: 80 a0 60 03 cmp %g1, 3
200d1f8: 12 80 00 06 bne 200d210 <rtems_bdbuf_add_to_modified_list_after_access+0x84>
200d1fc: 82 10 20 07 mov 7, %g1
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
200d200: 03 00 80 7b sethi %hi(0x201ec00), %g1
200d204: c2 00 60 08 ld [ %g1 + 8 ], %g1 ! 201ec08 <rtems_bdbuf_configuration+0x10>
200d208: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d20c: 82 10 20 07 mov 7, %g1
200d210: 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;
200d214: 03 00 80 85 sethi %hi(0x2021400), %g1
200d218: 82 10 62 4c or %g1, 0x24c, %g1 ! 202164c <bdbuf_cache>
200d21c: c4 00 60 54 ld [ %g1 + 0x54 ], %g2
the_node->next = tail;
200d220: 86 00 60 50 add %g1, 0x50, %g3
tail->previous = the_node;
200d224: f0 20 60 54 st %i0, [ %g1 + 0x54 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200d228: c6 26 00 00 st %g3, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
200d22c: f0 20 80 00 st %i0, [ %g2 ]
the_node->previous = old_last;
200d230: c4 26 20 04 st %g2, [ %i0 + 4 ]
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
200d234: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
200d238: 80 a0 a0 00 cmp %g2, 0
200d23c: 22 80 00 04 be,a 200d24c <rtems_bdbuf_add_to_modified_list_after_access+0xc0>
200d240: c2 00 60 74 ld [ %g1 + 0x74 ], %g1
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
200d244: 7f ff fe be call 200cd3c <rtems_bdbuf_wake>
200d248: 91 e8 60 64 restore %g1, 0x64, %o0
else if (rtems_bdbuf_has_buffer_waiters ())
200d24c: 80 a0 60 00 cmp %g1, 0
200d250: 02 80 00 04 be 200d260 <rtems_bdbuf_add_to_modified_list_after_access+0xd4>
200d254: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
200d258: 7f ff fe 2b call 200cb04 <rtems_bdbuf_wake_swapper>
200d25c: 81 e8 00 00 restore
200d260: 81 c7 e0 08 ret
200d264: 81 e8 00 00 restore
0200cba0 <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)
{
200cba0: 9d e3 bf a0 save %sp, -96, %sp
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
200cba4: c2 06 00 00 ld [ %i0 ], %g1
200cba8: 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 ();
200cbac: 7f ff ff e2 call 200cb34 <rtems_bdbuf_disable_preemption>
200cbb0: c2 26 00 00 st %g1, [ %i0 ]
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
200cbb4: 7f ff ff ce call 200caec <rtems_bdbuf_unlock_cache>
200cbb8: ba 10 00 08 mov %o0, %i5
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
200cbbc: d0 06 20 04 ld [ %i0 + 4 ], %o0
200cbc0: 92 10 20 00 clr %o1
200cbc4: 7f ff ef cd call 2008af8 <rtems_semaphore_obtain>
200cbc8: 94 10 20 00 clr %o2
if (sc == RTEMS_TIMEOUT)
200cbcc: 80 a2 20 06 cmp %o0, 6
200cbd0: 12 80 00 04 bne 200cbe0 <rtems_bdbuf_anonymous_wait+0x40> <== ALWAYS TAKEN
200cbd4: 80 a2 20 0d cmp %o0, 0xd
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);
200cbd8: 10 80 00 04 b 200cbe8 <rtems_bdbuf_anonymous_wait+0x48> <== NOT EXECUTED
200cbdc: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
200cbe0: 02 80 00 04 be 200cbf0 <rtems_bdbuf_anonymous_wait+0x50> <== ALWAYS TAKEN
200cbe4: 90 10 20 02 mov 2, %o0
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);
200cbe8: 7f ff ff 9b call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200cbec: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
200cbf0: 7f ff ff aa call 200ca98 <rtems_bdbuf_lock_cache>
200cbf4: 01 00 00 00 nop
rtems_bdbuf_restore_preemption (prev_mode);
200cbf8: 7f ff ff dc call 200cb68 <rtems_bdbuf_restore_preemption>
200cbfc: 90 10 00 1d mov %i5, %o0
--waiters->count;
200cc00: c2 06 00 00 ld [ %i0 ], %g1
200cc04: 82 00 7f ff add %g1, -1, %g1
200cc08: c2 26 00 00 st %g1, [ %i0 ]
200cc0c: 81 c7 e0 08 ret
200cc10: 81 e8 00 00 restore
0200cd74 <rtems_bdbuf_create_task.constprop.10>:
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
200cd74: 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 ?
200cd78: 03 00 80 7b sethi %hi(0x201ec00), %g1
200cd7c: d4 00 60 14 ld [ %g1 + 0x14 ], %o2 ! 201ec14 <rtems_bdbuf_configuration+0x1c>
bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
200cd80: 80 a2 a0 00 cmp %o2, 0
200cd84: 12 80 00 03 bne 200cd90 <rtems_bdbuf_create_task.constprop.10+0x1c><== ALWAYS TAKEN
200cd88: 92 10 00 19 mov %i1, %o1
200cd8c: 15 00 00 04 sethi %hi(0x1000), %o2 <== NOT EXECUTED
priority = priority != 0 ? priority : default_priority;
200cd90: 80 a2 60 00 cmp %o1, 0
200cd94: 22 80 00 02 be,a 200cd9c <rtems_bdbuf_create_task.constprop.10+0x28><== NEVER TAKEN
200cd98: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
sc = rtems_task_create (name,
200cd9c: 90 10 00 18 mov %i0, %o0
200cda0: 96 10 24 00 mov 0x400, %o3
200cda4: 98 10 20 00 clr %o4
200cda8: 7f ff ef df call 2008d24 <rtems_task_create>
200cdac: 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)
200cdb0: b0 92 20 00 orcc %o0, 0, %i0
200cdb4: 12 80 00 05 bne 200cdc8 <rtems_bdbuf_create_task.constprop.10+0x54><== NEVER TAKEN
200cdb8: b2 10 00 1a mov %i2, %i1
sc = rtems_task_start (*id, entry, arg);
200cdbc: f0 07 00 00 ld [ %i4 ], %i0
200cdc0: 7f ff f0 66 call 2008f58 <rtems_task_start>
200cdc4: 95 e8 00 1b restore %g0, %i3, %o2
return sc;
}
200cdc8: 81 c7 e0 08 ret <== NOT EXECUTED
200cdcc: 81 e8 00 00 restore <== NOT EXECUTED
0200cb34 <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
200cb34: 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);
200cb38: 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;
200cb3c: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
200cb40: 92 10 21 00 mov 0x100, %o1
200cb44: 40 00 11 6e call 20110fc <rtems_task_mode>
200cb48: 94 07 bf fc add %fp, -4, %o2
if (sc != RTEMS_SUCCESSFUL)
200cb4c: 80 a2 20 00 cmp %o0, 0
200cb50: 22 80 00 04 be,a 200cb60 <rtems_bdbuf_disable_preemption+0x2c><== ALWAYS TAKEN
200cb54: f0 07 bf fc ld [ %fp + -4 ], %i0
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);
200cb58: 7f ff ff bf call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200cb5c: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
return prev_mode;
}
200cb60: 81 c7 e0 08 ret
200cb64: 81 e8 00 00 restore
0200e0b4 <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)
{
200e0b4: 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) +
200e0b8: 83 2e a0 04 sll %i2, 4, %g1
200e0bc: 82 00 60 20 add %g1, 0x20, %g1
200e0c0: 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;
200e0c4: 03 00 80 36 sethi %hi(0x200d800), %g1
200e0c8: 82 10 61 e0 or %g1, 0x1e0, %g1 ! 200d9e0 <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) +
200e0cc: ba 03 a0 60 add %sp, 0x60, %i5
rtems_bdbuf_execute_read_request (rtems_disk_device *dd,
rtems_bdbuf_buffer *bd,
uint32_t transfer_count)
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
200e0d0: f6 06 60 18 ld [ %i1 + 0x18 ], %i3
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
uint32_t block_size = dd->block_size;
200e0d4: 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;
200e0d8: e2 06 20 2c ld [ %i0 + 0x2c ], %l1
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
sizeof (rtems_blkdev_sg_buffer) * transfer_count);
req->req = RTEMS_BLKDEV_REQ_READ;
req->done = rtems_bdbuf_transfer_done;
200e0dc: c2 27 60 04 st %g1, [ %i5 + 4 ]
req->io_task = rtems_task_self ();
200e0e0: 40 00 0c 65 call 2011274 <rtems_task_self>
200e0e4: c0 27 40 00 clr [ %i5 ]
req->bufnum = 0;
200e0e8: c0 27 60 10 clr [ %i5 + 0x10 ]
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 ();
200e0ec: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e0f0: 82 10 20 09 mov 9, %g1
200e0f4: c2 26 60 20 st %g1, [ %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;
200e0f8: f2 27 60 24 st %i1, [ %i5 + 0x24 ]
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
req->bufs [0].buffer = bd->buffer;
200e0fc: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
req->bufnum = 0;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
200e100: f6 27 60 18 st %i3, [ %i5 + 0x18 ]
req->bufs [0].length = block_size;
200e104: e0 27 60 1c st %l0, [ %i5 + 0x1c ]
req->bufs [0].buffer = bd->buffer;
200e108: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
200e10c: b8 10 00 1d mov %i5, %i4
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
200e110: b2 10 20 01 mov 1, %i1
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
while (transfer_index < transfer_count)
200e114: 10 80 00 16 b 200e16c <rtems_bdbuf_execute_read_request+0xb8>
200e118: a4 10 20 09 mov 9, %l2
{
media_block += media_blocks_per_block;
bd = rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
200e11c: 90 10 00 18 mov %i0, %o0
200e120: 92 10 00 1b mov %i3, %o1
200e124: 7f ff fd 4d call 200d658 <rtems_bdbuf_get_buffer_for_read_ahead>
200e128: b8 07 20 10 add %i4, 0x10, %i4
if (bd == NULL)
200e12c: 80 a2 20 00 cmp %o0, 0
200e130: 32 80 00 09 bne,a 200e154 <rtems_bdbuf_execute_read_request+0xa0><== ALWAYS TAKEN
200e134: e4 22 20 20 st %l2, [ %o0 + 0x20 ]
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
200e138: f2 27 60 10 st %i1, [ %i5 + 0x10 ] <== NOT EXECUTED
return rtems_bdbuf_execute_transfer_request (dd, req, true);
200e13c: 90 10 00 18 mov %i0, %o0
200e140: 92 10 00 1d mov %i5, %o1
200e144: 7f ff fe 2d call 200d9f8 <rtems_bdbuf_execute_transfer_request>
200e148: 94 10 20 01 mov 1, %o2
200e14c: 81 c7 e0 08 ret
200e150: 91 e8 00 08 restore %g0, %o0, %o0
if (bd == NULL)
break;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
200e154: d0 27 20 24 st %o0, [ %i4 + 0x24 ]
req->bufs [transfer_index].block = media_block;
200e158: f6 27 20 18 st %i3, [ %i4 + 0x18 ]
req->bufs [transfer_index].length = block_size;
200e15c: e0 27 20 1c st %l0, [ %i4 + 0x1c ]
req->bufs [transfer_index].buffer = bd->buffer;
200e160: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
200e164: b2 06 60 01 inc %i1
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
req->bufs [transfer_index].block = media_block;
req->bufs [transfer_index].length = block_size;
req->bufs [transfer_index].buffer = bd->buffer;
200e168: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
while (transfer_index < transfer_count)
200e16c: 80 a6 40 1a cmp %i1, %i2
200e170: 2a bf ff eb bcs,a 200e11c <rtems_bdbuf_execute_read_request+0x68>
200e174: b6 06 c0 11 add %i3, %l1, %i3
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
200e178: 10 bf ff f1 b 200e13c <rtems_bdbuf_execute_read_request+0x88>
200e17c: f2 27 60 10 st %i1, [ %i5 + 0x10 ]
0200ca54 <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_fatal_code error)
{
200ca54: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_fatal (RTEMS_FATAL_SOURCE_BDBUF, error);
200ca58: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
200ca5c: 7f ff f1 e6 call 20091f4 <rtems_fatal> <== NOT EXECUTED
200ca60: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
0200cab0 <rtems_bdbuf_fatal_with_state>:
}
static void
rtems_bdbuf_fatal_with_state (rtems_bdbuf_buf_state state,
rtems_bdbuf_fatal_code error)
{
200cab0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_bdbuf_fatal ((((uint32_t) state) << 16) | error);
200cab4: b1 2e 20 10 sll %i0, 0x10, %i0 <== NOT EXECUTED
200cab8: 7f ff ff e7 call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200cabc: 90 16 40 18 or %i1, %i0, %o0 <== NOT EXECUTED
0200e798 <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
200e798: 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 ();
200e79c: 7f ff f8 bf call 200ca98 <rtems_bdbuf_lock_cache>
200e7a0: 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)
200e7a4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
200e7a8: 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)
200e7ac: 80 a6 40 01 cmp %i1, %g1
200e7b0: 1a 80 00 26 bcc 200e848 <rtems_bdbuf_get+0xb0> <== NEVER TAKEN
200e7b4: b0 10 20 04 mov 4, %i0
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
200e7b8: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
200e7bc: 80 a2 60 00 cmp %o1, 0
200e7c0: 26 80 00 04 bl,a 200e7d0 <rtems_bdbuf_get+0x38> <== NEVER TAKEN
200e7c4: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
200e7c8: 10 80 00 09 b 200e7ec <rtems_bdbuf_get+0x54>
200e7cc: 93 2e 40 09 sll %i1, %o1, %o1
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
200e7d0: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e7d4: 90 10 20 00 clr %o0 <== NOT EXECUTED
200e7d8: 40 00 39 43 call 201cce4 <__muldi3> <== NOT EXECUTED
200e7dc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e7e0: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
200e7e4: 40 00 3b 51 call 201d528 <__udivdi3> <== NOT EXECUTED
200e7e8: 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;
200e7ec: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dd->dev);
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
200e7f0: 90 10 00 1d mov %i5, %o0
200e7f4: 7f ff fb ac call 200d6a4 <rtems_bdbuf_get_buffer_for_access>
200e7f8: 92 02 40 01 add %o1, %g1, %o1
200e7fc: b8 10 00 08 mov %o0, %i4
switch (bd->state)
200e800: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
200e804: 80 a2 20 02 cmp %o0, 2
200e808: 02 80 00 08 be 200e828 <rtems_bdbuf_get+0x90>
200e80c: 80 a2 20 07 cmp %o0, 7
200e810: 02 80 00 0a be 200e838 <rtems_bdbuf_get+0xa0>
200e814: 80 a2 20 01 cmp %o0, 1
200e818: 12 80 00 0a bne 200e840 <rtems_bdbuf_get+0xa8> <== NEVER TAKEN
200e81c: 82 10 20 05 mov 5, %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e820: 10 80 00 04 b 200e830 <rtems_bdbuf_get+0x98>
200e824: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
200e828: 82 10 20 03 mov 3, %g1
200e82c: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
200e830: 10 80 00 06 b 200e848 <rtems_bdbuf_get+0xb0>
200e834: b0 10 20 00 clr %i0
200e838: 10 bf ff fd b 200e82c <rtems_bdbuf_get+0x94>
200e83c: 82 10 20 04 mov 4, %g1
* record of this so just gets the block to fill.
*/
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_2);
200e840: 7f ff f8 9c call 200cab0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200e844: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
200e848: 7f ff f8 a9 call 200caec <rtems_bdbuf_unlock_cache>
200e84c: 01 00 00 00 nop
*bd_ptr = bd;
200e850: f8 26 80 00 st %i4, [ %i2 ]
return sc;
}
200e854: 81 c7 e0 08 ret
200e858: 81 e8 00 00 restore
0200d6a4 <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
200d6a4: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d6a8: 39 00 80 85 sethi %hi(0x2021400), %i4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d6ac: 35 00 80 32 sethi %hi(0x200c800), %i2
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d6b0: b8 17 22 4c or %i4, 0x24c, %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);
200d6b4: a0 07 20 6c add %i4, 0x6c, %l0
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
200d6b8: a2 07 20 64 add %i4, 0x64, %l1
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200d6bc: a4 07 20 5c add %i4, 0x5c, %l2
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200d6c0: b6 07 20 74 add %i4, 0x74, %i3
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
200d6c4: a6 07 20 50 add %i4, 0x50, %l3
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d6c8: d0 07 20 3c ld [ %i4 + 0x3c ], %o0
200d6cc: 92 10 00 18 mov %i0, %o1
200d6d0: 7f ff fd 82 call 200ccd8 <rtems_bdbuf_avl_search.isra.0>
200d6d4: 94 10 00 19 mov %i1, %o2
if (bd != NULL)
200d6d8: ba 92 20 00 orcc %o0, 0, %i5
200d6dc: 02 80 00 2f be 200d798 <rtems_bdbuf_get_buffer_for_access+0xf4>
200d6e0: 90 10 00 18 mov %i0, %o0
{
if (bd->group->bds_per_group != dd->bds_per_group)
200d6e4: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
200d6e8: c4 00 60 08 ld [ %g1 + 8 ], %g2
200d6ec: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
200d6f0: 80 a0 80 01 cmp %g2, %g1
200d6f4: 02 80 00 35 be 200d7c8 <rtems_bdbuf_get_buffer_for_access+0x124>
200d6f8: a8 10 20 08 mov 8, %l4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d6fc: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200d700: 80 a2 20 0a cmp %o0, 0xa
200d704: 18 80 00 4f bgu 200d840 <rtems_bdbuf_get_buffer_for_access+0x19c><== NEVER TAKEN
200d708: 92 10 20 14 mov 0x14, %o1
200d70c: 82 16 a1 ac or %i2, 0x1ac, %g1
200d710: 91 2a 20 02 sll %o0, 2, %o0
200d714: c2 00 40 08 ld [ %g1 + %o0 ], %g1
200d718: 81 c0 40 00 jmp %g1
200d71c: 01 00 00 00 nop
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200d720: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200d724: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d728: e8 27 60 20 st %l4, [ %i5 + 0x20 ] <== NOT EXECUTED
previous = the_node->previous;
next->previous = previous;
200d72c: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
previous->next = next;
200d730: 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;
200d734: c2 07 20 60 ld [ %i4 + 0x60 ], %g1 <== NOT EXECUTED
the_node->next = tail;
200d738: e4 27 40 00 st %l2, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
200d73c: fa 27 20 60 st %i5, [ %i4 + 0x60 ] <== NOT EXECUTED
old_last->next = the_node;
200d740: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_extract_unprotected (&bd->link);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
200d744: 7f ff fc f0 call 200cb04 <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
200d748: c2 27 60 04 st %g1, [ %i5 + 4 ] <== NOT EXECUTED
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d74c: 10 bf ff ed b 200d700 <rtems_bdbuf_get_buffer_for_access+0x5c><== NOT EXECUTED
200d750: d0 07 60 20 ld [ %i5 + 0x20 ], %o0 <== NOT EXECUTED
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_request_sync_for_modified_buffer (bd);
break;
case RTEMS_BDBUF_STATE_CACHED:
case RTEMS_BDBUF_STATE_EMPTY:
if (bd->waiters == 0)
200d754: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200d758: 80 a0 60 00 cmp %g1, 0
200d75c: 02 80 00 3b be 200d848 <rtems_bdbuf_get_buffer_for_access+0x1a4><== NEVER TAKEN
200d760: 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);
200d764: 7f ff fd 0f call 200cba0 <rtems_bdbuf_anonymous_wait>
200d768: 90 10 00 1b mov %i3, %o0
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d76c: 10 bf ff d8 b 200d6cc <rtems_bdbuf_get_buffer_for_access+0x28>
200d770: d0 07 20 3c ld [ %i4 + 0x3c ], %o0
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
200d774: 90 10 00 1d mov %i5, %o0
200d778: 10 80 00 04 b 200d788 <rtems_bdbuf_get_buffer_for_access+0xe4>
200d77c: 92 10 00 11 mov %l1, %o1
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
200d780: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200d784: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
200d788: 7f ff fd 23 call 200cc14 <rtems_bdbuf_wait>
200d78c: 01 00 00 00 nop
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d790: 10 bf ff dc b 200d700 <rtems_bdbuf_get_buffer_for_access+0x5c>
200d794: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
200d798: 7f ff fe c7 call 200d2b4 <rtems_bdbuf_get_buffer_from_lru_list>
200d79c: 92 10 00 19 mov %i1, %o1
if (bd == NULL)
200d7a0: ba 92 20 00 orcc %o0, 0, %i5
200d7a4: 32 80 00 0a bne,a 200d7cc <rtems_bdbuf_get_buffer_for_access+0x128>
200d7a8: 39 00 80 85 sethi %hi(0x2021400), %i4
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
200d7ac: c2 07 20 4c ld [ %i4 + 0x4c ], %g1 ! 202144c <lc_message_charset+0x1c>
200d7b0: 80 a0 40 13 cmp %g1, %l3
200d7b4: 02 bf ff ec be 200d764 <rtems_bdbuf_get_buffer_for_access+0xc0>
200d7b8: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
200d7bc: 7f ff fc d2 call 200cb04 <rtems_bdbuf_wake_swapper>
200d7c0: 01 00 00 00 nop
200d7c4: 30 bf ff e8 b,a 200d764 <rtems_bdbuf_get_buffer_for_access+0xc0>
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
200d7c8: 39 00 80 85 sethi %hi(0x2021400), %i4
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d7cc: 37 00 80 32 sethi %hi(0x200c800), %i3
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
200d7d0: b8 17 22 b8 or %i4, 0x2b8, %i4
return;
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
200d7d4: b4 07 3f f8 add %i4, -8, %i2
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d7d8: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200d7dc: 82 02 3f ff add %o0, -1, %g1
200d7e0: 80 a0 60 09 cmp %g1, 9
200d7e4: 18 80 00 17 bgu 200d840 <rtems_bdbuf_get_buffer_for_access+0x19c><== NEVER TAKEN
200d7e8: 92 10 20 13 mov 0x13, %o1
200d7ec: 84 16 e1 84 or %i3, 0x184, %g2
200d7f0: 83 28 60 02 sll %g1, 2, %g1
200d7f4: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200d7f8: 81 c0 40 00 jmp %g1
200d7fc: 01 00 00 00 nop
{
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_group_release (bd);
200d800: 7f ff fc 90 call 200ca40 <rtems_bdbuf_group_release>
200d804: 90 10 00 1d mov %i5, %o0
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200d808: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
200d80c: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
200d810: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
200d814: 10 80 00 15 b 200d868 <rtems_bdbuf_get_buffer_for_access+0x1c4>
200d818: c4 20 40 00 st %g2, [ %g1 ]
return;
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
200d81c: 90 10 00 1d mov %i5, %o0
200d820: 10 80 00 04 b 200d830 <rtems_bdbuf_get_buffer_for_access+0x18c>
200d824: 92 10 00 1a mov %i2, %o1
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
200d828: 90 10 00 1d mov %i5, %o0
200d82c: 92 10 00 1c mov %i4, %o1
200d830: 7f ff fc f9 call 200cc14 <rtems_bdbuf_wait>
200d834: 01 00 00 00 nop
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d838: 10 bf ff e9 b 200d7dc <rtems_bdbuf_get_buffer_for_access+0x138>
200d83c: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_7);
200d840: 7f ff fc 9c call 200cab0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200d844: 01 00 00 00 nop <== NOT EXECUTED
{
if (bd->group->bds_per_group != dd->bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200d848: 7f ff fe 88 call 200d268 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
200d84c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
200d850: 7f ff fe 46 call 200d168 <rtems_bdbuf_make_free_and_add_to_lru_list><== NOT EXECUTED
200d854: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200d858: 7f ff fd 39 call 200cd3c <rtems_bdbuf_wake> <== NOT EXECUTED
200d85c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d860: 10 bf ff 9b b 200d6cc <rtems_bdbuf_get_buffer_for_access+0x28><== NOT EXECUTED
200d864: d0 07 20 3c ld [ %i4 + 0x3c ], %o0 <== NOT EXECUTED
}
}
while (bd == NULL);
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
200d868: 90 10 00 1d mov %i5, %o0
200d86c: 7f ff fc 70 call 200ca2c <rtems_bdbuf_group_obtain>
200d870: b0 10 00 1d mov %i5, %i0
return bd;
}
200d874: 81 c7 e0 08 ret
200d878: 81 e8 00 00 restore
0200d658 <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)
{
200d658: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d65c: 03 00 80 85 sethi %hi(0x2021400), %g1
200d660: d0 00 62 88 ld [ %g1 + 0x288 ], %o0 ! 2021688 <bdbuf_cache+0x3c>
200d664: 92 10 00 18 mov %i0, %o1
200d668: 94 10 00 19 mov %i1, %o2
200d66c: 7f ff fd 9b call 200ccd8 <rtems_bdbuf_avl_search.isra.0>
200d670: ba 10 20 00 clr %i5
if (bd == NULL)
200d674: 80 a2 20 00 cmp %o0, 0
200d678: 12 80 00 09 bne 200d69c <rtems_bdbuf_get_buffer_for_read_ahead+0x44><== NEVER TAKEN
200d67c: 90 10 00 18 mov %i0, %o0
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
200d680: 7f ff ff 0d call 200d2b4 <rtems_bdbuf_get_buffer_from_lru_list>
200d684: 92 10 00 19 mov %i1, %o1
if (bd != NULL)
200d688: ba 92 20 00 orcc %o0, 0, %i5
200d68c: 02 80 00 04 be 200d69c <rtems_bdbuf_get_buffer_for_read_ahead+0x44><== NEVER TAKEN
200d690: 01 00 00 00 nop
rtems_bdbuf_group_obtain (bd);
200d694: 7f ff fc e6 call 200ca2c <rtems_bdbuf_group_obtain>
200d698: 01 00 00 00 nop
* thus no need for a read ahead.
*/
bd = NULL;
return bd;
}
200d69c: 81 c7 e0 08 ret
200d6a0: 91 e8 00 1d restore %g0, %i5, %o0
0200d2b4 <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)
{
200d2b4: 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;
200d2b8: 25 00 80 85 sethi %hi(0x2021400), %l2
200d2bc: 90 14 a2 4c or %l2, 0x24c, %o0 ! 202164c <bdbuf_cache>
200d2c0: f8 02 20 40 ld [ %o0 + 0x40 ], %i4
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
200d2c4: a2 02 20 44 add %o0, 0x44, %l1
200d2c8: 10 80 00 de b 200d640 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
200d2cc: a6 02 20 74 add %o0, 0x74, %l3
bd->group->bds_per_group, dd->bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
200d2d0: 80 a0 60 00 cmp %g1, 0
200d2d4: 32 80 00 db bne,a 200d640 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
200d2d8: f8 07 00 00 ld [ %i4 ], %i4
{
if (bd->group->bds_per_group == dd->bds_per_group)
200d2dc: fa 07 20 28 ld [ %i4 + 0x28 ], %i5
200d2e0: f6 06 20 34 ld [ %i0 + 0x34 ], %i3
200d2e4: d2 07 60 08 ld [ %i5 + 8 ], %o1
200d2e8: 80 a2 40 1b cmp %o1, %i3
200d2ec: 32 80 00 06 bne,a 200d304 <rtems_bdbuf_get_buffer_from_lru_list+0x50>
200d2f0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200d2f4: 7f ff ff dd call 200d268 <rtems_bdbuf_remove_from_tree_and_lru_list>
200d2f8: 90 10 00 1c mov %i4, %o0
200d2fc: 10 80 00 30 b 200d3bc <rtems_bdbuf_get_buffer_from_lru_list+0x108>
200d300: 84 10 00 1c mov %i4, %g2
empty_bd = bd;
}
else if (bd->group->users == 0)
200d304: 80 a0 60 00 cmp %g1, 0
200d308: 32 80 00 ce bne,a 200d640 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
200d30c: f8 07 00 00 ld [ %i4 ], %i4
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
200d310: d0 04 7f dc ld [ %l1 + -36 ], %o0
200d314: 40 00 3d 1c call 201c784 <.udiv>
200d318: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
for (b = 0, bd = group->bdbuf;
200d31c: a0 10 20 00 clr %l0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
200d320: 83 2a 20 03 sll %o0, 3, %g1
200d324: 91 2a 20 06 sll %o0, 6, %o0
200d328: 10 80 00 05 b 200d33c <rtems_bdbuf_get_buffer_from_lru_list+0x88>
200d32c: a8 22 00 01 sub %o0, %g1, %l4
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200d330: 7f ff ff ce call 200d268 <rtems_bdbuf_remove_from_tree_and_lru_list>
200d334: a0 04 20 01 inc %l0
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
200d338: b4 06 80 14 add %i2, %l4, %i2
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
200d33c: c2 07 60 08 ld [ %i5 + 8 ], %g1
200d340: 80 a4 00 01 cmp %l0, %g1
200d344: 0a bf ff fb bcs 200d330 <rtems_bdbuf_get_buffer_from_lru_list+0x7c>
200d348: 90 10 00 1a mov %i2, %o0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
200d34c: 82 14 a2 4c or %l2, 0x24c, %g1
200d350: d0 00 60 20 ld [ %g1 + 0x20 ], %o0
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
200d354: f6 27 60 08 st %i3, [ %i5 + 8 ]
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
200d358: 40 00 3d 0b call 201c784 <.udiv>
200d35c: 92 10 00 1b mov %i3, %o1
for (b = 1, bd = group->bdbuf + bufs_per_bd;
200d360: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
200d364: 83 2a 20 03 sll %o0, 3, %g1
200d368: a1 2a 20 06 sll %o0, 6, %l0
200d36c: b6 10 20 01 mov 1, %i3
200d370: a0 24 00 01 sub %l0, %g1, %l0
200d374: 10 80 00 05 b 200d388 <rtems_bdbuf_get_buffer_from_lru_list+0xd4>
200d378: b4 06 80 10 add %i2, %l0, %i2
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
200d37c: 7f ff ff 7b call 200d168 <rtems_bdbuf_make_free_and_add_to_lru_list>
200d380: b6 06 e0 01 inc %i3
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
200d384: b4 06 80 10 add %i2, %l0, %i2
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
200d388: c2 07 60 08 ld [ %i5 + 8 ], %g1
200d38c: 80 a6 c0 01 cmp %i3, %g1
200d390: 0a bf ff fb bcs 200d37c <rtems_bdbuf_get_buffer_from_lru_list+0xc8>
200d394: 90 10 00 1a mov %i2, %o0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
200d398: 80 a6 e0 01 cmp %i3, 1
200d39c: 28 80 00 05 bleu,a 200d3b0 <rtems_bdbuf_get_buffer_from_lru_list+0xfc>
200d3a0: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200d3a4: 7f ff fe 66 call 200cd3c <rtems_bdbuf_wake>
200d3a8: 90 10 00 13 mov %l3, %o0
return group->bdbuf;
200d3ac: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, dd->bds_per_group);
}
if (empty_bd != NULL)
200d3b0: 80 a0 a0 00 cmp %g2, 0
200d3b4: 22 80 00 a3 be,a 200d640 <rtems_bdbuf_get_buffer_from_lru_list+0x38c><== NEVER TAKEN
200d3b8: f8 07 00 00 ld [ %i4 ], %i4 <== NOT EXECUTED
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
200d3bc: f0 20 a0 14 st %i0, [ %g2 + 0x14 ]
bd->block = block;
bd->avl.left = NULL;
200d3c0: c0 20 a0 08 clr [ %g2 + 8 ]
bd->avl.right = NULL;
200d3c4: c0 20 a0 0c clr [ %g2 + 0xc ]
rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
200d3c8: 07 00 80 85 sethi %hi(0x2021400), %g3
200d3cc: 86 10 e2 4c or %g3, 0x24c, %g3 ! 202164c <bdbuf_cache>
200d3d0: c2 00 e0 3c ld [ %g3 + 0x3c ], %g1
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
bd->block = block;
200d3d4: f2 20 a0 18 st %i1, [ %g2 + 0x18 ]
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
200d3d8: c0 20 a0 24 clr [ %g2 + 0x24 ]
rtems_bdbuf_buffer* p = *root;
rtems_bdbuf_buffer* q;
rtems_bdbuf_buffer* p1;
rtems_bdbuf_buffer* p2;
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
200d3dc: ba 07 bf 80 add %fp, -128, %i5
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
200d3e0: b8 10 3f ff mov -1, %i4
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
200d3e4: 80 a0 60 00 cmp %g1, 0
200d3e8: 12 80 00 1d bne 200d45c <rtems_bdbuf_get_buffer_from_lru_list+0x1a8>
200d3ec: b6 10 20 01 mov 1, %i3
{
*root = node;
200d3f0: c4 20 e0 3c st %g2, [ %g3 + 0x3c ]
node->avl.left = NULL;
200d3f4: c0 20 a0 08 clr [ %g2 + 8 ]
node->avl.right = NULL;
200d3f8: c0 20 a0 0c clr [ %g2 + 0xc ]
node->avl.bal = 0;
200d3fc: 10 80 00 8e b 200d634 <rtems_bdbuf_get_buffer_from_lru_list+0x380>
200d400: c0 28 a0 11 clrb [ %g2 + 0x11 ]
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
200d404: 32 80 00 0f bne,a 200d440 <rtems_bdbuf_get_buffer_from_lru_list+0x18c><== NEVER TAKEN
200d408: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED
200d40c: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
200d410: 80 a0 c0 19 cmp %g3, %i1
200d414: 1a 80 00 08 bcc 200d434 <rtems_bdbuf_get_buffer_from_lru_list+0x180>
200d418: 01 00 00 00 nop
{
p->avl.cache = 1;
q = p->avl.right;
200d41c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
if (q == NULL)
200d420: 80 a0 e0 00 cmp %g3, 0
200d424: 12 80 00 0c bne 200d454 <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
200d428: f6 28 60 10 stb %i3, [ %g1 + 0x10 ]
{
q = node;
p->avl.right = q = node;
200d42c: 10 80 00 12 b 200d474 <rtems_bdbuf_get_buffer_from_lru_list+0x1c0>
200d430: c4 20 60 0c st %g2, [ %g1 + 0xc ]
break;
}
}
else if ((p->dd != dd) || (p->block != block))
200d434: 02 80 00 7e be 200d62c <rtems_bdbuf_get_buffer_from_lru_list+0x378><== NEVER TAKEN
200d438: 01 00 00 00 nop
{
p->avl.cache = -1;
q = p->avl.left;
200d43c: c6 00 60 08 ld [ %g1 + 8 ], %g3
if (q == NULL)
200d440: 80 a0 e0 00 cmp %g3, 0
200d444: 12 80 00 04 bne 200d454 <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
200d448: f8 28 60 10 stb %i4, [ %g1 + 0x10 ]
{
q = node;
p->avl.left = q;
200d44c: 10 80 00 0a b 200d474 <rtems_bdbuf_get_buffer_from_lru_list+0x1c0>
200d450: c4 20 60 08 st %g2, [ %g1 + 8 ]
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
200d454: ba 10 00 04 mov %g4, %i5
200d458: 82 10 00 03 mov %g3, %g1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
200d45c: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
200d460: c2 27 40 00 st %g1, [ %i5 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
200d464: 80 a0 c0 18 cmp %g3, %i0
200d468: 0a bf ff ed bcs 200d41c <rtems_bdbuf_get_buffer_from_lru_list+0x168><== NEVER TAKEN
200d46c: 88 07 60 04 add %i5, 4, %g4
200d470: 30 bf ff e5 b,a 200d404 <rtems_bdbuf_get_buffer_from_lru_list+0x150>
}
p = q;
}
q->avl.left = q->avl.right = NULL;
200d474: c0 20 a0 0c clr [ %g2 + 0xc ]
200d478: c0 20 a0 08 clr [ %g2 + 8 ]
q->avl.bal = 0;
200d47c: c0 28 a0 11 clrb [ %g2 + 0x11 ]
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
200d480: b8 10 20 01 mov 1, %i4
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200d484: b4 10 3f ff mov -1, %i2
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
200d488: 10 80 00 03 b 200d494 <rtems_bdbuf_get_buffer_from_lru_list+0x1e0>
200d48c: b2 07 bf 80 add %fp, -128, %i1
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
200d490: 82 10 00 04 mov %g4, %g1
{
if (p->avl.cache == -1)
200d494: c8 48 60 10 ldsb [ %g1 + 0x10 ], %g4
200d498: c6 08 60 11 ldub [ %g1 + 0x11 ], %g3
200d49c: 80 a1 3f ff cmp %g4, -1
{
switch (p->avl.bal)
200d4a0: 87 28 e0 18 sll %g3, 0x18, %g3
modified = true;
buf_prev--;
while (modified)
{
if (p->avl.cache == -1)
200d4a4: 12 80 00 26 bne 200d53c <rtems_bdbuf_get_buffer_from_lru_list+0x288>
200d4a8: 87 38 e0 18 sra %g3, 0x18, %g3
{
switch (p->avl.bal)
200d4ac: 80 a0 e0 00 cmp %g3, 0
200d4b0: 22 80 00 4d be,a 200d5e4 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
200d4b4: c8 28 60 11 stb %g4, [ %g1 + 0x11 ]
200d4b8: 80 a0 e0 01 cmp %g3, 1
200d4bc: 02 80 00 28 be 200d55c <rtems_bdbuf_get_buffer_from_lru_list+0x2a8>
200d4c0: 80 a0 ff ff cmp %g3, -1
200d4c4: 32 80 00 49 bne,a 200d5e8 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== NEVER TAKEN
200d4c8: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
200d4cc: 10 80 00 02 b 200d4d4 <rtems_bdbuf_get_buffer_from_lru_list+0x220>
200d4d0: c6 00 60 08 ld [ %g1 + 8 ], %g3
if (p1->avl.bal == -1) /* simple LL-turn */
200d4d4: c8 48 e0 11 ldsb [ %g3 + 0x11 ], %g4
200d4d8: 80 a1 3f ff cmp %g4, -1
200d4dc: 12 80 00 05 bne 200d4f0 <rtems_bdbuf_get_buffer_from_lru_list+0x23c>
200d4e0: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
{
p->avl.left = p1->avl.right;
200d4e4: c8 20 60 08 st %g4, [ %g1 + 8 ]
p1->avl.right = p;
200d4e8: 10 80 00 26 b 200d580 <rtems_bdbuf_get_buffer_from_lru_list+0x2cc>
200d4ec: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d4f0: f0 01 20 08 ld [ %g4 + 8 ], %i0
p2->avl.left = p1;
200d4f4: c6 21 20 08 st %g3, [ %g4 + 8 ]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d4f8: f0 20 e0 0c st %i0, [ %g3 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200d4fc: f0 01 20 0c ld [ %g4 + 0xc ], %i0
p2->avl.right = p;
200d500: c2 21 20 0c st %g1, [ %g4 + 0xc ]
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200d504: f0 20 60 08 st %i0, [ %g1 + 8 ]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
200d508: f0 49 20 11 ldsb [ %g4 + 0x11 ], %i0
200d50c: 80 a6 3f ff cmp %i0, -1
200d510: 12 80 00 04 bne 200d520 <rtems_bdbuf_get_buffer_from_lru_list+0x26c>
200d514: b6 10 00 04 mov %g4, %i3
200d518: 10 80 00 03 b 200d524 <rtems_bdbuf_get_buffer_from_lru_list+0x270>
200d51c: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
200d520: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
200d524: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d528: 80 a0 60 01 cmp %g1, 1
200d52c: 32 80 00 2a bne,a 200d5d4 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
200d530: c0 28 e0 11 clrb [ %g3 + 0x11 ]
200d534: 10 80 00 28 b 200d5d4 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
200d538: f4 28 e0 11 stb %i2, [ %g3 + 0x11 ]
break;
}
}
else
{
switch (p->avl.bal)
200d53c: 80 a0 e0 00 cmp %g3, 0
200d540: 22 80 00 29 be,a 200d5e4 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
200d544: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
200d548: 80 a0 e0 01 cmp %g3, 1
200d54c: 02 80 00 06 be 200d564 <rtems_bdbuf_get_buffer_from_lru_list+0x2b0>
200d550: 80 a0 ff ff cmp %g3, -1
200d554: 32 80 00 25 bne,a 200d5e8 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== NEVER TAKEN
200d558: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
{
case -1:
p->avl.bal = 0;
200d55c: 10 80 00 20 b 200d5dc <rtems_bdbuf_get_buffer_from_lru_list+0x328>
200d560: c0 28 60 11 clrb [ %g1 + 0x11 ]
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
200d564: c6 00 60 0c ld [ %g1 + 0xc ], %g3
if (p1->avl.bal == 1) /* simple RR-turn */
200d568: c8 48 e0 11 ldsb [ %g3 + 0x11 ], %g4
200d56c: 80 a1 20 01 cmp %g4, 1
200d570: 12 80 00 07 bne 200d58c <rtems_bdbuf_get_buffer_from_lru_list+0x2d8>
200d574: c8 00 e0 08 ld [ %g3 + 8 ], %g4
{
p->avl.right = p1->avl.left;
200d578: c8 20 60 0c st %g4, [ %g1 + 0xc ]
p1->avl.left = p;
200d57c: c2 20 e0 08 st %g1, [ %g3 + 8 ]
p->avl.bal = 0;
200d580: c0 28 60 11 clrb [ %g1 + 0x11 ]
200d584: 10 80 00 14 b 200d5d4 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
200d588: b6 10 00 03 mov %g3, %i3
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200d58c: f0 01 20 0c ld [ %g4 + 0xc ], %i0
p2->avl.right = p1;
200d590: c6 21 20 0c st %g3, [ %g4 + 0xc ]
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200d594: f0 20 e0 08 st %i0, [ %g3 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200d598: f0 01 20 08 ld [ %g4 + 8 ], %i0
p2->avl.left = p;
200d59c: c2 21 20 08 st %g1, [ %g4 + 8 ]
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200d5a0: f0 20 60 0c st %i0, [ %g1 + 0xc ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200d5a4: f0 49 20 11 ldsb [ %g4 + 0x11 ], %i0
200d5a8: 80 a6 20 01 cmp %i0, 1
200d5ac: 12 80 00 04 bne 200d5bc <rtems_bdbuf_get_buffer_from_lru_list+0x308><== ALWAYS TAKEN
200d5b0: b6 10 00 04 mov %g4, %i3
200d5b4: 10 80 00 03 b 200d5c0 <rtems_bdbuf_get_buffer_from_lru_list+0x30c><== NOT EXECUTED
200d5b8: f4 28 60 11 stb %i2, [ %g1 + 0x11 ] <== NOT EXECUTED
200d5bc: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
200d5c0: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d5c4: 80 a0 7f ff cmp %g1, -1
200d5c8: 32 80 00 03 bne,a 200d5d4 <rtems_bdbuf_get_buffer_from_lru_list+0x320><== ALWAYS TAKEN
200d5cc: c0 28 e0 11 clrb [ %g3 + 0x11 ]
200d5d0: f8 28 e0 11 stb %i4, [ %g3 + 0x11 ] <== NOT EXECUTED
p = p2;
}
p->avl.bal = 0;
200d5d4: c0 2e e0 11 clrb [ %i3 + 0x11 ]
200d5d8: 82 10 00 1b mov %i3, %g1
modified = false;
200d5dc: 10 80 00 03 b 200d5e8 <rtems_bdbuf_get_buffer_from_lru_list+0x334>
200d5e0: 86 10 20 00 clr %g3
break;
}
}
else
{
switch (p->avl.bal)
200d5e4: 86 10 20 01 mov 1, %g3
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
200d5e8: 80 a7 40 19 cmp %i5, %i1
200d5ec: 28 80 00 09 bleu,a 200d610 <rtems_bdbuf_get_buffer_from_lru_list+0x35c>
200d5f0: 07 00 80 85 sethi %hi(0x2021400), %g3
{
p = *--buf_prev;
200d5f4: c8 07 7f fc ld [ %i5 + -4 ], %g4
if (p->avl.cache == -1)
200d5f8: f6 49 20 10 ldsb [ %g4 + 0x10 ], %i3
200d5fc: 80 a6 ff ff cmp %i3, -1
200d600: 32 80 00 06 bne,a 200d618 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
200d604: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
p->avl.left = q;
200d608: 10 80 00 04 b 200d618 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
200d60c: c2 21 20 08 st %g1, [ %g4 + 8 ]
p->avl.right = q;
}
}
else
{
*root = p;
200d610: 10 80 00 09 b 200d634 <rtems_bdbuf_get_buffer_from_lru_list+0x380>
200d614: c2 20 e2 88 st %g1, [ %g3 + 0x288 ]
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
200d618: 80 88 e0 ff btst 0xff, %g3
200d61c: 12 bf ff 9d bne 200d490 <rtems_bdbuf_get_buffer_from_lru_list+0x1dc>
200d620: ba 07 7f fc add %i5, -4, %i5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d624: 10 80 00 05 b 200d638 <rtems_bdbuf_get_buffer_from_lru_list+0x384>
200d628: 82 10 20 01 mov 1, %g1
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
if (rtems_bdbuf_avl_insert (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RECYCLE);
200d62c: 7f ff fd 0a call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d630: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d634: 82 10 20 01 mov 1, %g1
200d638: 10 80 00 06 b 200d650 <rtems_bdbuf_get_buffer_from_lru_list+0x39c>
200d63c: c2 20 a0 20 st %g1, [ %g2 + 0x20 ]
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
200d640: 80 a7 00 11 cmp %i4, %l1
200d644: 32 bf ff 23 bne,a 200d2d0 <rtems_bdbuf_get_buffer_from_lru_list+0x1c>
200d648: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
}
node = rtems_chain_next (node);
}
return NULL;
200d64c: 84 10 20 00 clr %g2
}
200d650: 81 c7 e0 08 ret
200d654: 91 e8 00 02 restore %g0, %g2, %o0
0200e350 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
200e350: 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())
200e354: 03 00 80 87 sethi %hi(0x2021c00), %g1
200e358: c2 00 63 18 ld [ %g1 + 0x318 ], %g1 ! 2021f18 <_Per_CPU_Information+0x8>
200e35c: 80 a0 60 00 cmp %g1, 0
200e360: 12 80 00 16 bne 200e3b8 <rtems_bdbuf_init+0x68> <== NEVER TAKEN
200e364: 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)
200e368: 35 00 80 7a sethi %hi(0x201e800), %i2
200e36c: b4 16 a3 f8 or %i2, 0x3f8, %i2 ! 201ebf8 <rtems_bdbuf_configuration>
200e370: f2 06 a0 28 ld [ %i2 + 0x28 ], %i1
200e374: f8 06 a0 24 ld [ %i2 + 0x24 ], %i4
200e378: 90 10 00 19 mov %i1, %o0
200e37c: 92 10 00 1c mov %i4, %o1
200e380: 40 00 39 ad call 201ca34 <.urem>
200e384: b0 10 20 0a mov 0xa, %i0
200e388: 80 a2 20 00 cmp %o0, 0
200e38c: 12 80 01 01 bne 200e790 <rtems_bdbuf_init+0x440> <== NEVER TAKEN
200e390: 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 ();
200e394: 7f ff f9 e8 call 200cb34 <rtems_bdbuf_disable_preemption>
200e398: 3b 00 80 85 sethi %hi(0x2021400), %i5
if (bdbuf_cache.initialised)
200e39c: ba 17 62 4c or %i5, 0x24c, %i5 ! 202164c <bdbuf_cache>
200e3a0: c2 0f 60 95 ldub [ %i5 + 0x95 ], %g1
200e3a4: 80 a0 60 00 cmp %g1, 0
200e3a8: 02 80 00 06 be 200e3c0 <rtems_bdbuf_init+0x70> <== ALWAYS TAKEN
200e3ac: b6 10 00 08 mov %o0, %i3
{
rtems_bdbuf_restore_preemption (prev_mode);
200e3b0: 7f ff f9 ee call 200cb68 <rtems_bdbuf_restore_preemption> <== NOT EXECUTED
200e3b4: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
200e3b8: 81 c7 e0 08 ret <== NOT EXECUTED
200e3bc: 81 e8 00 00 restore <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
200e3c0: 92 10 20 00 clr %o1
200e3c4: 94 10 20 98 mov 0x98, %o2
200e3c8: 40 00 18 18 call 2014428 <memset>
200e3cc: 90 10 00 1d mov %i5, %o0
bdbuf_cache.initialised = true;
200e3d0: 82 10 20 01 mov 1, %g1
rtems_bdbuf_restore_preemption (prev_mode);
200e3d4: 90 10 00 1b mov %i3, %o0
200e3d8: 7f ff f9 e4 call 200cb68 <rtems_bdbuf_restore_preemption>
200e3dc: c2 2f 60 95 stb %g1, [ %i5 + 0x95 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e3e0: 82 07 60 0c add %i5, 0xc, %g1
200e3e4: c2 27 60 08 st %g1, [ %i5 + 8 ]
head->previous = NULL;
tail->previous = head;
200e3e8: 82 07 60 08 add %i5, 8, %g1
200e3ec: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e3f0: 82 07 60 44 add %i5, 0x44, %g1
200e3f4: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
head->previous = NULL;
tail->previous = head;
200e3f8: 82 07 60 40 add %i5, 0x40, %g1
200e3fc: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e400: 82 07 60 50 add %i5, 0x50, %g1
200e404: c2 27 60 4c st %g1, [ %i5 + 0x4c ]
head->previous = NULL;
tail->previous = head;
200e408: 82 07 60 4c add %i5, 0x4c, %g1
200e40c: c2 27 60 54 st %g1, [ %i5 + 0x54 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e410: 82 07 60 5c add %i5, 0x5c, %g1
200e414: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
head->previous = NULL;
tail->previous = head;
200e418: 82 07 60 58 add %i5, 0x58, %g1
200e41c: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e420: 82 07 60 8c add %i5, 0x8c, %g1
200e424: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
head->previous = NULL;
tail->previous = head;
200e428: 82 07 60 88 add %i5, 0x88, %g1
*/
cache_aligment = 32; /* FIXME rtems_cache_get_data_line_size() */
if (cache_aligment <= 0)
cache_aligment = CPU_ALIGNMENT;
bdbuf_cache.sync_device = BDBUF_INVALID_DEV;
200e42c: c0 27 60 38 clr [ %i5 + 0x38 ]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
200e430: c0 27 60 0c clr [ %i5 + 0xc ]
200e434: c0 27 60 44 clr [ %i5 + 0x44 ]
200e438: c0 27 60 50 clr [ %i5 + 0x50 ]
200e43c: c0 27 60 5c clr [ %i5 + 0x5c ]
200e440: c0 27 60 8c clr [ %i5 + 0x8c ]
tail->previous = head;
200e444: c2 27 60 90 st %g1, [ %i5 + 0x90 ]
rtems_chain_initialize_empty (&bdbuf_cache.read_ahead_chain);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
200e448: 37 10 91 10 sethi %hi(0x42444000), %i3
200e44c: 92 10 20 01 mov 1, %o1
200e450: 90 16 e3 6c or %i3, 0x36c, %o0
200e454: 94 10 20 54 mov 0x54, %o2
200e458: 96 10 20 00 clr %o3
200e45c: 7f ff e9 0a call 2008884 <rtems_semaphore_create>
200e460: 98 07 60 28 add %i5, 0x28, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
200e464: 80 a2 20 00 cmp %o0, 0
200e468: 12 80 00 a3 bne 200e6f4 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e46c: 03 00 80 85 sethi %hi(0x2021400), %g1
goto error;
rtems_bdbuf_lock_cache ();
200e470: 7f ff f9 8a call 200ca98 <rtems_bdbuf_lock_cache>
200e474: 01 00 00 00 nop
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
200e478: 90 16 e3 73 or %i3, 0x373, %o0
200e47c: 92 10 20 01 mov 1, %o1
200e480: 94 10 20 54 mov 0x54, %o2
200e484: 96 10 20 00 clr %o3
200e488: 7f ff e8 ff call 2008884 <rtems_semaphore_create>
200e48c: 98 07 60 2c add %i5, 0x2c, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
200e490: 80 a2 20 00 cmp %o0, 0
200e494: 12 80 00 98 bne 200e6f4 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e498: 03 00 80 85 sethi %hi(0x2021400), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
200e49c: 90 16 e3 61 or %i3, 0x361, %o0
200e4a0: 92 10 20 00 clr %o1
200e4a4: 94 10 20 24 mov 0x24, %o2
200e4a8: 96 10 20 00 clr %o3
200e4ac: 7f ff e8 f6 call 2008884 <rtems_semaphore_create>
200e4b0: 98 07 60 68 add %i5, 0x68, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200e4b4: 80 a2 20 00 cmp %o0, 0
200e4b8: 12 80 00 8f bne 200e6f4 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e4bc: 03 00 80 85 sethi %hi(0x2021400), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
200e4c0: 90 16 e3 74 or %i3, 0x374, %o0
200e4c4: 92 10 20 00 clr %o1
200e4c8: 94 10 20 24 mov 0x24, %o2
200e4cc: 96 10 20 00 clr %o3
200e4d0: 7f ff e8 ed call 2008884 <rtems_semaphore_create>
200e4d4: 98 07 60 70 add %i5, 0x70, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200e4d8: 80 a2 20 00 cmp %o0, 0
200e4dc: 12 80 00 86 bne 200e6f4 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e4e0: 03 00 80 85 sethi %hi(0x2021400), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
200e4e4: 90 16 e3 62 or %i3, 0x362, %o0
200e4e8: 92 10 20 00 clr %o1
200e4ec: 94 10 20 24 mov 0x24, %o2
200e4f0: 96 10 20 00 clr %o3
200e4f4: 7f ff e8 e4 call 2008884 <rtems_semaphore_create>
200e4f8: 98 07 60 78 add %i5, 0x78, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200e4fc: 80 a2 20 00 cmp %o0, 0
200e500: 12 80 00 7d bne 200e6f4 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e504: 03 00 80 85 sethi %hi(0x2021400), %g1
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
200e508: d0 06 a0 20 ld [ %i2 + 0x20 ], %o0
200e50c: 40 00 38 9e call 201c784 <.udiv>
200e510: 92 10 00 1c mov %i4, %o1
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
200e514: 92 10 00 1c mov %i4, %o1
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
200e518: b6 10 00 08 mov %o0, %i3
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
200e51c: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
200e520: 40 00 38 99 call 201c784 <.udiv>
200e524: 90 10 00 19 mov %i1, %o0
200e528: 92 10 00 08 mov %o0, %o1
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
200e52c: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
200e530: 40 00 38 95 call 201c784 <.udiv>
200e534: 90 10 00 1b mov %i3, %o0
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
200e538: 92 10 00 1b mov %i3, %o1
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
200e53c: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
200e540: b4 10 00 08 mov %o0, %i2
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
200e544: 7f ff d7 e2 call 20044cc <calloc>
200e548: 90 10 20 38 mov 0x38, %o0
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
200e54c: 80 a2 20 00 cmp %o0, 0
200e550: 02 80 00 68 be 200e6f0 <rtems_bdbuf_init+0x3a0> <== NEVER TAKEN
200e554: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
200e558: 90 10 20 14 mov 0x14, %o0
200e55c: 7f ff d7 dc call 20044cc <calloc>
200e560: 92 10 00 1a mov %i2, %o1
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
200e564: 80 a2 20 00 cmp %o0, 0
200e568: 02 80 00 62 be 200e6f0 <rtems_bdbuf_init+0x3a0> <== NEVER TAKEN
200e56c: d0 27 60 80 st %o0, [ %i5 + 0x80 ]
*
* The memory allocate allows a
*/
if (rtems_memalign ((void **) &bdbuf_cache.buffers,
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
200e570: 92 10 00 1c mov %i4, %o1
200e574: 40 00 38 4a call 201c69c <.umul>
200e578: 90 10 00 1b mov %i3, %o0
* aligned. It is possible to free the memory allocated by rtems_memalign()
* with free(). Return 0 if allocated.
*
* The memory allocate allows a
*/
if (rtems_memalign ((void **) &bdbuf_cache.buffers,
200e57c: 92 10 20 20 mov 0x20, %o1
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
200e580: 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,
200e584: 11 00 80 85 sethi %hi(0x2021400), %o0
200e588: 40 00 07 49 call 20102ac <rtems_memalign>
200e58c: 90 12 22 64 or %o0, 0x264, %o0 ! 2021664 <bdbuf_cache+0x18>
200e590: 80 a2 20 00 cmp %o0, 0
200e594: 12 80 00 58 bne 200e6f4 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e598: 03 00 80 85 sethi %hi(0x2021400), %g1
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
200e59c: 03 00 80 85 sethi %hi(0x2021400), %g1
200e5a0: 82 10 62 4c or %g1, 0x24c, %g1 ! 202164c <bdbuf_cache>
200e5a4: f6 00 60 80 ld [ %g1 + 0x80 ], %i3
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
200e5a8: f4 00 60 14 ld [ %g1 + 0x14 ], %i2
bd->group = group;
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
200e5ac: e4 00 60 20 ld [ %g1 + 0x20 ], %l2
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
200e5b0: e0 00 60 18 ld [ %g1 + 0x18 ], %l0
b < bdbuf_cache.buffer_min_count;
200e5b4: e6 00 60 1c ld [ %g1 + 0x1c ], %l3
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
200e5b8: a8 04 bf ff add %l2, -1, %l4
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
200e5bc: ba 10 00 1a mov %i2, %i5
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
200e5c0: b0 10 00 1b mov %i3, %i0
200e5c4: b2 10 20 00 clr %i1
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200e5c8: a2 10 00 01 mov %g1, %l1
200e5cc: 10 80 00 12 b 200e614 <rtems_bdbuf_init+0x2c4>
200e5d0: aa 00 60 44 add %g1, 0x44, %l5
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dd = BDBUF_INVALID_DEV;
bd->group = group;
200e5d4: f0 27 60 28 st %i0, [ %i5 + 0x28 ]
bd->buffer = buffer;
200e5d8: e0 27 60 1c st %l0, [ %i5 + 0x1c ]
200e5dc: c2 04 60 48 ld [ %l1 + 0x48 ], %g1
the_node->next = tail;
200e5e0: ea 27 40 00 st %l5, [ %i5 ]
tail->previous = the_node;
200e5e4: fa 24 60 48 st %i5, [ %l1 + 0x48 ]
old_last->next = the_node;
200e5e8: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
200e5ec: c2 27 60 04 st %g1, [ %i5 + 4 ]
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
200e5f0: 90 10 00 19 mov %i1, %o0
200e5f4: 40 00 39 10 call 201ca34 <.urem>
200e5f8: 92 10 00 12 mov %l2, %o1
200e5fc: 80 a2 00 14 cmp %o0, %l4
200e600: 22 80 00 02 be,a 200e608 <rtems_bdbuf_init+0x2b8>
200e604: b0 06 20 14 add %i0, 0x14, %i0
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
200e608: b2 06 60 01 inc %i1
200e60c: ba 07 60 38 add %i5, 0x38, %i5
200e610: a0 04 00 1c add %l0, %i4, %l0
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
200e614: 80 a6 40 13 cmp %i1, %l3
200e618: 32 bf ff ef bne,a 200e5d4 <rtems_bdbuf_init+0x284>
200e61c: c0 27 60 14 clr [ %i5 + 0x14 ]
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
200e620: 03 00 80 85 sethi %hi(0x2021400), %g1
200e624: 82 10 62 4c or %g1, 0x24c, %g1 ! 202164c <bdbuf_cache>
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
200e628: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
200e62c: c6 00 60 7c ld [ %g1 + 0x7c ], %g3
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
200e630: 83 28 a0 03 sll %g2, 3, %g1
200e634: 89 28 a0 06 sll %g2, 6, %g4
200e638: 88 21 00 01 sub %g4, %g1, %g4
200e63c: 10 80 00 06 b 200e654 <rtems_bdbuf_init+0x304>
200e640: 82 10 20 00 clr %g1
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
200e644: c4 26 e0 08 st %g2, [ %i3 + 8 ]
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
200e648: 82 00 60 01 inc %g1
group++,
200e64c: b6 06 e0 14 add %i3, 0x14, %i3
bd += bdbuf_cache.max_bds_per_group)
200e650: b4 06 80 04 add %i2, %g4, %i2
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
200e654: 80 a0 40 03 cmp %g1, %g3
200e658: 32 bf ff fb bne,a 200e644 <rtems_bdbuf_init+0x2f4>
200e65c: f4 26 e0 10 st %i2, [ %i3 + 0x10 ]
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
200e660: 35 00 80 7a sethi %hi(0x201e800), %i2
200e664: b8 16 a3 f8 or %i2, 0x3f8, %i4 ! 201ebf8 <rtems_bdbuf_configuration>
200e668: d2 07 20 08 ld [ %i4 + 8 ], %o1
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
200e66c: 3b 00 80 85 sethi %hi(0x2021400), %i5
200e670: b6 10 20 01 mov 1, %i3
200e674: ba 17 62 4c or %i5, 0x24c, %i5
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
200e678: 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;
200e67c: f6 2f 60 04 stb %i3, [ %i5 + 4 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
200e680: 90 12 23 50 or %o0, 0x350, %o0
200e684: 15 00 80 37 sethi %hi(0x200dc00), %o2
200e688: 96 10 20 00 clr %o3
200e68c: 94 12 a1 08 or %o2, 0x108, %o2
200e690: 7f ff f9 b9 call 200cd74 <rtems_bdbuf_create_task.constprop.10>
200e694: 98 10 00 1d mov %i5, %o4
bdbuf_config.swapout_priority,
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_task,
0,
&bdbuf_cache.swapout);
if (sc != RTEMS_SUCCESSFUL)
200e698: 80 a2 20 00 cmp %o0, 0
200e69c: 12 80 00 16 bne 200e6f4 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e6a0: 03 00 80 85 sethi %hi(0x2021400), %g1
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
200e6a4: c2 06 a3 f8 ld [ %i2 + 0x3f8 ], %g1
200e6a8: 80 a0 60 00 cmp %g1, 0
200e6ac: 32 80 00 06 bne,a 200e6c4 <rtems_bdbuf_init+0x374>
200e6b0: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
&bdbuf_cache.read_ahead_task);
if (sc != RTEMS_SUCCESSFUL)
goto error;
}
rtems_bdbuf_unlock_cache ();
200e6b4: 7f ff f9 0e call 200caec <rtems_bdbuf_unlock_cache>
200e6b8: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200e6bc: 81 c7 e0 08 ret
200e6c0: 81 e8 00 00 restore
if (sc != RTEMS_SUCCESSFUL)
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
{
bdbuf_cache.read_ahead_enabled = true;
200e6c4: f6 2f 60 94 stb %i3, [ %i5 + 0x94 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
200e6c8: 11 10 94 91 sethi %hi(0x42524400), %o0
200e6cc: 15 00 80 38 sethi %hi(0x200e000), %o2
200e6d0: 90 12 20 41 or %o0, 0x41, %o0
200e6d4: 94 12 a1 80 or %o2, 0x180, %o2
200e6d8: 96 10 20 00 clr %o3
200e6dc: 7f ff f9 a6 call 200cd74 <rtems_bdbuf_create_task.constprop.10>
200e6e0: 98 07 60 84 add %i5, 0x84, %o4
bdbuf_config.read_ahead_priority,
RTEMS_BDBUF_READ_AHEAD_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_read_ahead_task,
0,
&bdbuf_cache.read_ahead_task);
if (sc != RTEMS_SUCCESSFUL)
200e6e4: 80 a2 20 00 cmp %o0, 0
200e6e8: 02 bf ff f3 be 200e6b4 <rtems_bdbuf_init+0x364> <== ALWAYS TAKEN
200e6ec: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.read_ahead_task != 0)
200e6f0: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
200e6f4: d0 00 62 d0 ld [ %g1 + 0x2d0 ], %o0 ! 20216d0 <bdbuf_cache+0x84><== NOT EXECUTED
200e6f8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200e6fc: 02 80 00 05 be 200e710 <rtems_bdbuf_init+0x3c0> <== NOT EXECUTED
200e700: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.read_ahead_task);
200e704: 7f ff e9 d2 call 2008e4c <rtems_task_delete> <== NOT EXECUTED
200e708: 01 00 00 00 nop <== NOT EXECUTED
if (bdbuf_cache.swapout != 0)
200e70c: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
200e710: d0 00 62 4c ld [ %g1 + 0x24c ], %o0 ! 202164c <bdbuf_cache><== NOT EXECUTED
200e714: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200e718: 02 80 00 04 be 200e728 <rtems_bdbuf_init+0x3d8> <== NOT EXECUTED
200e71c: 3b 00 80 85 sethi %hi(0x2021400), %i5 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
200e720: 7f ff e9 cb call 2008e4c <rtems_task_delete> <== NOT EXECUTED
200e724: 01 00 00 00 nop <== NOT EXECUTED
free (bdbuf_cache.buffers);
200e728: ba 17 62 4c or %i5, 0x24c, %i5 <== NOT EXECUTED
200e72c: 7f ff d8 3c call 200481c <free> <== NOT EXECUTED
200e730: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.groups);
200e734: 7f ff d8 3a call 200481c <free> <== NOT EXECUTED
200e738: d0 07 60 80 ld [ %i5 + 0x80 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.bds);
200e73c: 7f ff d8 38 call 200481c <free> <== NOT EXECUTED
200e740: d0 07 60 14 ld [ %i5 + 0x14 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
200e744: 7f ff e8 be call 2008a3c <rtems_semaphore_delete> <== NOT EXECUTED
200e748: d0 07 60 78 ld [ %i5 + 0x78 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
200e74c: 7f ff e8 bc call 2008a3c <rtems_semaphore_delete> <== NOT EXECUTED
200e750: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
200e754: 7f ff e8 ba call 2008a3c <rtems_semaphore_delete> <== NOT EXECUTED
200e758: d0 07 60 70 ld [ %i5 + 0x70 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
200e75c: 7f ff e8 b8 call 2008a3c <rtems_semaphore_delete> <== NOT EXECUTED
200e760: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
200e764: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
200e768: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200e76c: 02 80 00 07 be 200e788 <rtems_bdbuf_init+0x438> <== NOT EXECUTED
200e770: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
200e774: 7f ff f8 de call 200caec <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200e778: 01 00 00 00 nop <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
200e77c: 7f ff e8 b0 call 2008a3c <rtems_semaphore_delete> <== NOT EXECUTED
200e780: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
200e784: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
200e788: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
rtems_semaphore_delete (bdbuf_cache.lock);
}
bdbuf_cache.initialised = false;
200e78c: c0 28 62 e1 clrb [ %g1 + 0x2e1 ] <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
200e790: 81 c7 e0 08 ret <== NOT EXECUTED
200e794: 81 e8 00 00 restore <== NOT EXECUTED
0200ca68 <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)
{
200ca68: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_obtain (lock,
200ca6c: 92 10 20 00 clr %o1
200ca70: 90 10 00 18 mov %i0, %o0
200ca74: 7f ff f0 21 call 2008af8 <rtems_semaphore_obtain>
200ca78: 94 10 20 00 clr %o2
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
200ca7c: 80 a2 20 00 cmp %o0, 0
200ca80: 02 80 00 04 be 200ca90 <rtems_bdbuf_lock+0x28> <== ALWAYS TAKEN
200ca84: 01 00 00 00 nop
rtems_bdbuf_fatal (fatal_error_code);
200ca88: 7f ff ff f3 call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ca8c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
200ca90: 81 c7 e0 08 ret
200ca94: 81 e8 00 00 restore
0200ed24 <rtems_bdbuf_purge_dev>:
}
}
void
rtems_bdbuf_purge_dev (rtems_disk_device *dd)
{
200ed24: 9d e3 bf 10 save %sp, -240, %sp
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
200ed28: 82 07 bf 74 add %fp, -140, %g1
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ed2c: b6 07 bf 78 add %fp, -136, %i3
head->previous = NULL;
tail->previous = head;
200ed30: c2 27 bf 7c st %g1, [ %fp + -132 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ed34: f6 27 bf 74 st %i3, [ %fp + -140 ]
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
200ed38: 7f ff f7 58 call 200ca98 <rtems_bdbuf_lock_cache>
200ed3c: c0 27 bf 78 clr [ %fp + -136 ]
}
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
200ed40: 7f ff fd 5c call 200e2b0 <rtems_bdbuf_read_ahead_cancel>
200ed44: 90 10 00 18 mov %i0, %o0
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200ed48: 82 10 3f ff mov -1, %g1
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
200ed4c: 11 00 80 85 sethi %hi(0x2021400), %o0
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
200ed50: 35 00 80 32 sethi %hi(0x200c800), %i2
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
200ed54: 90 12 22 4c or %o0, 0x24c, %o0
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200ed58: c2 26 20 6c st %g1, [ %i0 + 0x6c ]
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
200ed5c: fa 02 20 3c ld [ %o0 + 0x3c ], %i5
*prev = NULL;
200ed60: c0 27 bf 80 clr [ %fp + -128 ]
static void
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
200ed64: b8 07 bf 80 add %fp, -128, %i4
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
200ed68: b4 16 a1 d8 or %i2, 0x1d8, %i2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ed6c: b2 10 20 06 mov 6, %i1
200ed70: a0 10 20 0a mov 0xa, %l0
case RTEMS_BDBUF_STATE_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
break;
case RTEMS_BDBUF_STATE_SYNC:
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
200ed74: 10 80 00 3a b 200ee5c <rtems_bdbuf_purge_dev+0x138>
200ed78: a2 02 20 6c add %o0, 0x6c, %l1
*prev = NULL;
while (cur != NULL)
{
if (cur->dd == dd)
200ed7c: 80 a0 40 18 cmp %g1, %i0
200ed80: 32 80 00 1e bne,a 200edf8 <rtems_bdbuf_purge_dev+0xd4>
200ed84: c2 07 60 08 ld [ %i5 + 8 ], %g1
{
switch (cur->state)
200ed88: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200ed8c: 80 a0 60 0a cmp %g1, 0xa
200ed90: 18 80 00 17 bgu 200edec <rtems_bdbuf_purge_dev+0xc8> <== NEVER TAKEN
200ed94: 83 28 60 02 sll %g1, 2, %g1
200ed98: c2 06 80 01 ld [ %i2 + %g1 ], %g1
200ed9c: 81 c0 40 00 jmp %g1
200eda0: 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);
200eda4: 7f ff f7 e6 call 200cd3c <rtems_bdbuf_wake>
200eda8: 90 10 00 11 mov %l1, %o0
/* Fall through */
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_group_release (cur);
200edac: 7f ff f7 25 call 200ca40 <rtems_bdbuf_group_release>
200edb0: 90 10 00 1d mov %i5, %o0
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200edb4: c2 07 60 04 ld [ %i5 + 4 ], %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200edb8: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
next->previous = previous;
200edbc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
200edc0: 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;
200edc4: c2 07 bf 7c ld [ %fp + -132 ], %g1
the_node->next = tail;
200edc8: f6 27 40 00 st %i3, [ %i5 ]
tail->previous = the_node;
200edcc: fa 27 bf 7c st %i5, [ %fp + -132 ]
old_last->next = the_node;
200edd0: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
200edd4: 10 80 00 08 b 200edf4 <rtems_bdbuf_purge_dev+0xd0>
200edd8: c2 27 60 04 st %g1, [ %i5 + 4 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200eddc: 10 80 00 06 b 200edf4 <rtems_bdbuf_purge_dev+0xd0>
200ede0: e0 27 60 20 st %l0, [ %i5 + 0x20 ]
200ede4: 10 80 00 04 b 200edf4 <rtems_bdbuf_purge_dev+0xd0>
200ede8: f2 27 60 20 st %i1, [ %i5 + 0x20 ]
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_set_state (cur, RTEMS_BDBUF_STATE_ACCESS_PURGED);
break;
default:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);
200edec: 7f ff f7 1a call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200edf0: 90 10 20 17 mov 0x17, %o0 <== NOT EXECUTED
}
}
if (cur->avl.left != NULL)
200edf4: c2 07 60 08 ld [ %i5 + 8 ], %g1
200edf8: 80 a0 60 00 cmp %g1, 0
200edfc: 22 80 00 04 be,a 200ee0c <rtems_bdbuf_purge_dev+0xe8>
200ee00: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
*prev = cur;
200ee04: 10 80 00 06 b 200ee1c <rtems_bdbuf_purge_dev+0xf8>
200ee08: fa 27 20 04 st %i5, [ %i4 + 4 ]
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
200ee0c: 80 a0 60 00 cmp %g1, 0
200ee10: 22 80 00 08 be,a 200ee30 <rtems_bdbuf_purge_dev+0x10c>
200ee14: c2 07 00 00 ld [ %i4 ], %g1
{
/* Right */
++prev;
*prev = cur;
200ee18: fa 27 20 04 st %i5, [ %i4 + 4 ]
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
200ee1c: 10 80 00 0f b 200ee58 <rtems_bdbuf_purge_dev+0x134>
200ee20: b8 07 20 04 add %i4, 4, %i4
while (*prev != NULL
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
{
/* Up */
cur = *prev;
--prev;
200ee24: b8 07 3f fc add %i4, -4, %i4
200ee28: ba 10 00 01 mov %g1, %i5
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
200ee2c: c2 07 00 00 ld [ %i4 ], %g1
200ee30: 80 a0 60 00 cmp %g1, 0
200ee34: 22 80 00 0a be,a 200ee5c <rtems_bdbuf_purge_dev+0x138>
200ee38: ba 10 00 01 mov %g1, %i5
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
200ee3c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200ee40: 80 a7 40 02 cmp %i5, %g2
200ee44: 02 bf ff f8 be 200ee24 <rtems_bdbuf_purge_dev+0x100>
200ee48: 80 a0 a0 00 cmp %g2, 0
200ee4c: 22 bf ff f7 be,a 200ee28 <rtems_bdbuf_purge_dev+0x104>
200ee50: b8 07 3f fc add %i4, -4, %i4
cur = *prev;
--prev;
}
if (*prev != NULL)
/* Right */
cur = (*prev)->avl.right;
200ee54: 82 10 00 02 mov %g2, %g1
200ee58: ba 10 00 01 mov %g1, %i5
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
200ee5c: 80 a7 60 00 cmp %i5, 0
200ee60: 32 bf ff c7 bne,a 200ed7c <rtems_bdbuf_purge_dev+0x58>
200ee64: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
}
static void
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
200ee68: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ee6c: 10 80 00 0c b 200ee9c <rtems_bdbuf_purge_dev+0x178>
200ee70: b6 10 20 01 mov 1, %i3
while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
200ee74: 80 a0 60 00 cmp %g1, 0
200ee78: 22 80 00 02 be,a 200ee80 <rtems_bdbuf_purge_dev+0x15c>
200ee7c: b8 10 20 01 mov 1, %i4
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
200ee80: 80 a0 60 00 cmp %g1, 0
200ee84: 12 80 00 06 bne 200ee9c <rtems_bdbuf_purge_dev+0x178>
200ee88: f6 27 60 20 st %i3, [ %i5 + 0x20 ]
{
rtems_bdbuf_remove_from_tree (bd);
200ee8c: 7f ff f7 d1 call 200cdd0 <rtems_bdbuf_remove_from_tree>
200ee90: 90 10 00 1d mov %i5, %o0
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
200ee94: 7f ff f8 b5 call 200d168 <rtems_bdbuf_make_free_and_add_to_lru_list>
200ee98: 90 10 00 1d mov %i5, %o0
200ee9c: 7f ff f6 da call 200ca04 <_Chain_Get_unprotected>
200eea0: 90 07 bf 74 add %fp, -140, %o0
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
rtems_chain_node *node = NULL;
while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)
200eea4: ba 92 20 00 orcc %o0, 0, %i5
200eea8: 32 bf ff f3 bne,a 200ee74 <rtems_bdbuf_purge_dev+0x150>
200eeac: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
200eeb0: 80 8f 20 ff btst 0xff, %i4
200eeb4: 02 80 00 04 be 200eec4 <rtems_bdbuf_purge_dev+0x1a0>
200eeb8: 11 00 80 85 sethi %hi(0x2021400), %o0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200eebc: 7f ff f7 a0 call 200cd3c <rtems_bdbuf_wake>
200eec0: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 20216c0 <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 ();
200eec4: 7f ff f7 0a call 200caec <rtems_bdbuf_unlock_cache>
200eec8: 01 00 00 00 nop
200eecc: 81 c7 e0 08 ret
200eed0: 81 e8 00 00 restore
0200e85c <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
200e85c: 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 ();
200e860: 7f ff f8 8e call 200ca98 <rtems_bdbuf_lock_cache>
200e864: 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)
200e868: 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;
200e86c: 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)
200e870: 80 a6 40 01 cmp %i1, %g1
200e874: 1a 80 00 71 bcc 200ea38 <rtems_bdbuf_read+0x1dc> <== NEVER TAKEN
200e878: b0 10 20 04 mov 4, %i0
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
200e87c: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
200e880: 80 a2 60 00 cmp %o1, 0
200e884: 26 80 00 04 bl,a 200e894 <rtems_bdbuf_read+0x38> <== NEVER TAKEN
200e888: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
200e88c: 10 80 00 09 b 200e8b0 <rtems_bdbuf_read+0x54>
200e890: 93 2e 40 09 sll %i1, %o1, %o1
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
200e894: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e898: 90 10 20 00 clr %o0 <== NOT EXECUTED
200e89c: 40 00 39 12 call 201cce4 <__muldi3> <== NOT EXECUTED
200e8a0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e8a4: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
200e8a8: 40 00 3b 20 call 201d528 <__udivdi3> <== NOT EXECUTED
200e8ac: 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;
200e8b0: 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);
200e8b4: 90 10 00 1d mov %i5, %o0
200e8b8: 7f ff fb 7b call 200d6a4 <rtems_bdbuf_get_buffer_for_access>
200e8bc: 92 02 40 01 add %o1, %g1, %o1
200e8c0: b8 10 00 08 mov %o0, %i4
switch (bd->state)
200e8c4: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
200e8c8: 80 a2 20 02 cmp %o0, 2
200e8cc: 02 80 00 08 be 200e8ec <rtems_bdbuf_read+0x90>
200e8d0: 80 a2 20 07 cmp %o0, 7
200e8d4: 02 80 00 0b be 200e900 <rtems_bdbuf_read+0xa4>
200e8d8: 80 a2 20 01 cmp %o0, 1
200e8dc: 12 80 00 2d bne 200e990 <rtems_bdbuf_read+0x134> <== NEVER TAKEN
200e8e0: 01 00 00 00 nop
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;
200e8e4: 10 80 00 0e b 200e91c <rtems_bdbuf_read+0xc0>
200e8e8: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
switch (bd->state)
{
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
200e8ec: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
200e8f0: 82 00 60 01 inc %g1
200e8f4: 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;
200e8f8: 10 80 00 06 b 200e910 <rtems_bdbuf_read+0xb4>
200e8fc: 82 10 20 03 mov 3, %g1
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
break;
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
200e900: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
200e904: 82 00 60 01 inc %g1
200e908: 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;
200e90c: 82 10 20 04 mov 4, %g1
200e910: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
200e914: 10 80 00 21 b 200e998 <rtems_bdbuf_read+0x13c>
200e918: b0 10 20 00 clr %i0
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
case RTEMS_BDBUF_STATE_EMPTY:
++dd->stats.read_misses;
200e91c: 82 00 60 01 inc %g1
200e920: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
static void
rtems_bdbuf_set_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
200e924: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
200e928: 80 a0 40 19 cmp %g1, %i1
200e92c: 02 80 00 09 be 200e950 <rtems_bdbuf_read+0xf4>
200e930: 90 10 00 1d mov %i5, %o0
{
rtems_bdbuf_read_ahead_cancel (dd);
200e934: 7f ff fe 5f call 200e2b0 <rtems_bdbuf_read_ahead_cancel>
200e938: 90 10 00 1d mov %i5, %o0
dd->read_ahead.trigger = block + 1;
200e93c: 82 06 60 01 add %i1, 1, %g1
200e940: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
dd->read_ahead.next = block + 2;
200e944: 82 06 60 02 add %i1, 2, %g1
200e948: 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);
200e94c: 90 10 00 1d mov %i5, %o0
200e950: 92 10 00 1c mov %i4, %o1
200e954: 7f ff fd d8 call 200e0b4 <rtems_bdbuf_execute_read_request>
200e958: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
200e95c: b0 92 20 00 orcc %o0, 0, %i0
200e960: 32 80 00 0e bne,a 200e998 <rtems_bdbuf_read+0x13c>
200e964: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e968: 82 10 20 03 mov 3, %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200e96c: c4 07 00 00 ld [ %i4 ], %g2
200e970: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
previous = the_node->previous;
200e974: c2 07 20 04 ld [ %i4 + 4 ], %g1
sc = rtems_bdbuf_execute_read_request (dd, bd, 1);
if (sc == RTEMS_SUCCESSFUL)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
rtems_chain_extract_unprotected (&bd->link);
rtems_bdbuf_group_obtain (bd);
200e978: 90 10 00 1c mov %i4, %o0
next->previous = previous;
200e97c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
200e980: 7f ff f8 2b call 200ca2c <rtems_bdbuf_group_obtain>
200e984: c4 20 40 00 st %g2, [ %g1 ]
static void
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (bdbuf_cache.read_ahead_task != 0
200e988: 10 80 00 05 b 200e99c <rtems_bdbuf_read+0x140>
200e98c: 03 00 80 85 sethi %hi(0x2021400), %g1
{
bd = NULL;
}
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
200e990: 7f ff f8 48 call 200cab0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200e994: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
static void
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (bdbuf_cache.read_ahead_task != 0
200e998: 03 00 80 85 sethi %hi(0x2021400), %g1
200e99c: d0 00 62 d0 ld [ %g1 + 0x2d0 ], %o0 ! 20216d0 <bdbuf_cache+0x84>
200e9a0: 80 a2 20 00 cmp %o0, 0
200e9a4: 02 80 00 25 be 200ea38 <rtems_bdbuf_read+0x1dc>
200e9a8: 01 00 00 00 nop
&& dd->read_ahead.trigger == block
200e9ac: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
200e9b0: 80 a0 40 19 cmp %g1, %i1
200e9b4: 12 80 00 21 bne 200ea38 <rtems_bdbuf_read+0x1dc>
200e9b8: 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);
200e9bc: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
200e9c0: 80 a0 a0 00 cmp %g2, 0
200e9c4: 12 80 00 05 bne 200e9d8 <rtems_bdbuf_read+0x17c> <== NEVER TAKEN
200e9c8: 82 10 20 00 clr %g1
200e9cc: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
200e9d0: 80 a0 00 01 cmp %g0, %g1
200e9d4: 82 60 3f ff subx %g0, -1, %g1
&& !rtems_bdbuf_is_read_ahead_active (dd))
200e9d8: 80 a0 60 00 cmp %g1, 0
200e9dc: 02 80 00 17 be 200ea38 <rtems_bdbuf_read+0x1dc> <== NEVER TAKEN
200e9e0: 03 00 80 85 sethi %hi(0x2021400), %g1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200e9e4: 82 10 62 4c or %g1, 0x24c, %g1 ! 202164c <bdbuf_cache>
{
rtems_status_code sc;
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
if (rtems_chain_is_empty (chain))
200e9e8: c4 00 60 88 ld [ %g1 + 0x88 ], %g2
200e9ec: 82 00 60 8c add %g1, 0x8c, %g1
200e9f0: 80 a0 80 01 cmp %g2, %g1
200e9f4: 12 80 00 09 bne 200ea18 <rtems_bdbuf_read+0x1bc> <== NEVER TAKEN
200e9f8: 03 00 80 85 sethi %hi(0x2021400), %g1
{
sc = rtems_event_send (bdbuf_cache.read_ahead_task,
200e9fc: 7f ff e7 12 call 2008644 <rtems_event_send>
200ea00: 92 10 20 02 mov 2, %o1
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
200ea04: 80 a2 20 00 cmp %o0, 0
200ea08: 02 80 00 04 be 200ea18 <rtems_bdbuf_read+0x1bc> <== ALWAYS TAKEN
200ea0c: 03 00 80 85 sethi %hi(0x2021400), %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
200ea10: 7f ff f8 11 call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ea14: 90 10 20 07 mov 7, %o0 <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200ea18: 82 10 62 4c or %g1, 0x24c, %g1
200ea1c: c4 00 60 90 ld [ %g1 + 0x90 ], %g2
}
rtems_chain_append_unprotected (chain, &dd->read_ahead.node);
200ea20: 86 07 60 64 add %i5, 0x64, %g3
the_node->next = tail;
200ea24: 88 00 60 8c add %g1, 0x8c, %g4
tail->previous = the_node;
200ea28: c6 20 60 90 st %g3, [ %g1 + 0x90 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200ea2c: c8 27 60 64 st %g4, [ %i5 + 0x64 ]
tail->previous = the_node;
old_last->next = the_node;
200ea30: c6 20 80 00 st %g3, [ %g2 ]
the_node->previous = old_last;
200ea34: c4 27 60 68 st %g2, [ %i5 + 0x68 ]
}
rtems_bdbuf_check_read_ahead_trigger (dd, block);
}
rtems_bdbuf_unlock_cache ();
200ea38: 7f ff f8 2d call 200caec <rtems_bdbuf_unlock_cache>
200ea3c: 01 00 00 00 nop
*bd_ptr = bd;
200ea40: f8 26 80 00 st %i4, [ %i2 ]
return sc;
}
200ea44: 81 c7 e0 08 ret
200ea48: 81 e8 00 00 restore
0200e2b0 <rtems_bdbuf_read_ahead_cancel>:
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
200e2b0: c2 02 20 64 ld [ %o0 + 0x64 ], %g1
200e2b4: 80 a0 60 00 cmp %g1, 0
200e2b8: 12 80 00 05 bne 200e2cc <rtems_bdbuf_read_ahead_cancel+0x1c><== NEVER TAKEN
200e2bc: 84 10 20 00 clr %g2
200e2c0: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
200e2c4: 80 a0 00 02 cmp %g0, %g2
200e2c8: 84 60 3f ff subx %g0, -1, %g2
}
static void
rtems_bdbuf_read_ahead_cancel (rtems_disk_device *dd)
{
if (rtems_bdbuf_is_read_ahead_active (dd))
200e2cc: 80 a0 a0 00 cmp %g2, 0
200e2d0: 12 80 00 07 bne 200e2ec <rtems_bdbuf_read_ahead_cancel+0x3c><== ALWAYS TAKEN
200e2d4: 01 00 00 00 nop
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200e2d8: c4 02 20 68 ld [ %o0 + 0x68 ], %g2 <== NOT EXECUTED
next->previous = previous;
200e2dc: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
previous->next = next;
200e2e0: 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;
200e2e4: c0 22 20 68 clr [ %o0 + 0x68 ] <== NOT EXECUTED
200e2e8: c0 22 20 64 clr [ %o0 + 0x64 ] <== NOT EXECUTED
200e2ec: 81 c3 e0 08 retl
0200e180 <rtems_bdbuf_read_ahead_task>:
return sc;
}
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
200e180: 9d e3 bf a0 save %sp, -96, %sp
200e184: 33 00 80 85 sethi %hi(0x2021400), %i1
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
200e188: 35 00 80 85 sethi %hi(0x2021400), %i2
200e18c: b2 16 62 d4 or %i1, 0x2d4, %i1
200e190: 10 80 00 41 b 200e294 <rtems_bdbuf_read_ahead_task+0x114>
200e194: 31 00 80 7a sethi %hi(0x201e800), %i0
{
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
200e198: 7f ff fa ac call 200cc48 <rtems_bdbuf_wait_for_event>
200e19c: 90 10 20 02 mov 2, %o0
rtems_bdbuf_lock_cache ();
200e1a0: 7f ff fa 3e call 200ca98 <rtems_bdbuf_lock_cache>
200e1a4: 01 00 00 00 nop
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
200e1a8: 30 80 00 34 b,a 200e278 <rtems_bdbuf_read_ahead_task+0xf8>
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
200e1ac: c4 07 7f c4 ld [ %i5 + -60 ], %g2
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
((char *) node - offsetof (rtems_disk_device, read_ahead.node));
rtems_blkdev_bnum block = dd->read_ahead.next;
rtems_blkdev_bnum media_block = 0;
200e1b0: 92 10 20 00 clr %o1
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
200e1b4: 80 a7 00 02 cmp %i4, %g2
200e1b8: 1a 80 00 11 bcc 200e1fc <rtems_bdbuf_read_ahead_task+0x7c>
200e1bc: 82 10 20 04 mov 4, %g1
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
200e1c0: d2 07 7f cc ld [ %i5 + -52 ], %o1
200e1c4: 80 a2 60 00 cmp %o1, 0
200e1c8: 16 80 00 0a bge 200e1f0 <rtems_bdbuf_read_ahead_task+0x70><== ALWAYS TAKEN
200e1cc: 93 2f 00 09 sll %i4, %o1, %o1
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
200e1d0: d2 07 7f c0 ld [ %i5 + -64 ], %o1 <== NOT EXECUTED
200e1d4: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e1d8: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
200e1dc: 40 00 3a c2 call 201cce4 <__muldi3> <== NOT EXECUTED
200e1e0: 90 10 20 00 clr %o0 <== NOT EXECUTED
200e1e4: d6 07 7f bc ld [ %i5 + -68 ], %o3 <== NOT EXECUTED
200e1e8: 40 00 3c d0 call 201d528 <__udivdi3> <== NOT EXECUTED
200e1ec: 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;
200e1f0: c2 07 7f b4 ld [ %i5 + -76 ], %g1
200e1f4: 92 02 40 01 add %o1, %g1, %o1
200e1f8: 82 10 20 00 clr %g1
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
200e1fc: c0 27 60 04 clr [ %i5 + 4 ]
rtems_status_code sc =
rtems_bdbuf_get_media_block (dd, block, &media_block);
rtems_chain_set_off_chain (&dd->read_ahead.node);
if (sc == RTEMS_SUCCESSFUL)
200e200: 80 a0 60 00 cmp %g1, 0
200e204: 12 80 00 1b bne 200e270 <rtems_bdbuf_read_ahead_task+0xf0>
200e208: c0 27 40 00 clr [ %i5 ]
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
rtems_bdbuf_lock_cache ();
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
200e20c: b6 07 7f 9c add %i5, -100, %i3
rtems_chain_set_off_chain (&dd->read_ahead.node);
if (sc == RTEMS_SUCCESSFUL)
{
rtems_bdbuf_buffer *bd =
200e210: 7f ff fd 12 call 200d658 <rtems_bdbuf_get_buffer_for_read_ahead>
200e214: 90 10 00 1b mov %i3, %o0
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
200e218: 92 92 20 00 orcc %o0, 0, %o1
200e21c: 02 80 00 17 be 200e278 <rtems_bdbuf_read_ahead_task+0xf8> <== NEVER TAKEN
200e220: c2 06 23 f8 ld [ %i0 + 0x3f8 ], %g1
{
uint32_t transfer_count = dd->block_count - block;
200e224: d4 07 7f c4 ld [ %i5 + -60 ], %o2
200e228: 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)
200e22c: 80 a2 80 01 cmp %o2, %g1
200e230: 2a 80 00 09 bcs,a 200e254 <rtems_bdbuf_read_ahead_task+0xd4>
200e234: 82 10 3f ff mov -1, %g1
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
200e238: 85 30 60 01 srl %g1, 1, %g2
dd->read_ahead.next = block + transfer_count;
200e23c: 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;
200e240: 84 00 80 1c add %g2, %i4, %g2
dd->read_ahead.next = block + transfer_count;
200e244: b8 00 40 1c add %g1, %i4, %i4
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
200e248: c4 27 60 08 st %g2, [ %i5 + 8 ]
dd->read_ahead.next = block + transfer_count;
200e24c: 10 80 00 03 b 200e258 <rtems_bdbuf_read_ahead_task+0xd8>
200e250: f8 27 60 0c st %i4, [ %i5 + 0xc ]
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200e254: c2 27 60 08 st %g1, [ %i5 + 8 ]
}
++dd->stats.read_ahead_transfers;
200e258: c2 07 7f e8 ld [ %i5 + -24 ], %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
200e25c: 90 10 00 1b mov %i3, %o0
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
200e260: 82 00 60 01 inc %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
200e264: 7f ff ff 94 call 200e0b4 <rtems_bdbuf_execute_read_request>
200e268: c2 27 7f e8 st %g1, [ %i5 + -24 ]
200e26c: 30 80 00 03 b,a 200e278 <rtems_bdbuf_read_ahead_task+0xf8>
}
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200e270: 82 10 3f ff mov -1, %g1
200e274: c2 27 60 08 st %g1, [ %i5 + 8 ]
200e278: 7f ff f9 e3 call 200ca04 <_Chain_Get_unprotected>
200e27c: 90 10 00 19 mov %i1, %o0
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
rtems_bdbuf_lock_cache ();
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
200e280: ba 92 20 00 orcc %o0, 0, %i5
200e284: 32 bf ff ca bne,a 200e1ac <rtems_bdbuf_read_ahead_task+0x2c>
200e288: f8 07 60 0c ld [ %i5 + 0xc ], %i4
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
}
rtems_bdbuf_unlock_cache ();
200e28c: 7f ff fa 18 call 200caec <rtems_bdbuf_unlock_cache>
200e290: 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)
200e294: 82 16 a2 4c or %i2, 0x24c, %g1
200e298: c2 08 60 94 ldub [ %g1 + 0x94 ], %g1
200e29c: 80 a0 60 00 cmp %g1, 0
200e2a0: 12 bf ff be bne 200e198 <rtems_bdbuf_read_ahead_task+0x18><== ALWAYS TAKEN
200e2a4: 01 00 00 00 nop
}
rtems_bdbuf_unlock_cache ();
}
rtems_task_delete (RTEMS_SELF);
200e2a8: 7f ff ea e9 call 2008e4c <rtems_task_delete> <== NOT EXECUTED
200e2ac: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
0200ea4c <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
200ea4c: 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)
200ea50: 80 a6 20 00 cmp %i0, 0
200ea54: 02 80 00 31 be 200eb18 <rtems_bdbuf_release+0xcc> <== NEVER TAKEN
200ea58: 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();
200ea5c: 7f ff f8 0f call 200ca98 <rtems_bdbuf_lock_cache>
200ea60: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200ea64: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200ea68: 80 a2 20 04 cmp %o0, 4
200ea6c: 02 80 00 22 be 200eaf4 <rtems_bdbuf_release+0xa8>
200ea70: 01 00 00 00 nop
200ea74: 18 80 00 06 bgu 200ea8c <rtems_bdbuf_release+0x40>
200ea78: 80 a2 20 06 cmp %o0, 6
200ea7c: 80 a2 20 03 cmp %o0, 3
200ea80: 12 80 00 20 bne 200eb00 <rtems_bdbuf_release+0xb4> <== NEVER TAKEN
200ea84: 01 00 00 00 nop
200ea88: 30 80 00 04 b,a 200ea98 <rtems_bdbuf_release+0x4c>
200ea8c: 18 80 00 1d bgu 200eb00 <rtems_bdbuf_release+0xb4> <== NEVER TAKEN
200ea90: 01 00 00 00 nop
200ea94: 30 80 00 15 b,a 200eae8 <rtems_bdbuf_release+0x9c>
}
static void
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
200ea98: 7f ff f7 ea call 200ca40 <rtems_bdbuf_group_release>
200ea9c: 90 10 00 18 mov %i0, %o0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200eaa0: 82 10 20 02 mov 2, %g1
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200eaa4: 11 00 80 85 sethi %hi(0x2021400), %o0
200eaa8: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
200eaac: 90 12 22 4c or %o0, 0x24c, %o0
200eab0: c2 02 20 48 ld [ %o0 + 0x48 ], %g1
the_node->next = tail;
200eab4: 84 02 20 44 add %o0, 0x44, %g2
tail->previous = the_node;
200eab8: f0 22 20 48 st %i0, [ %o0 + 0x48 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200eabc: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
200eac0: f0 20 40 00 st %i0, [ %g1 ]
the_node->previous = old_last;
200eac4: c2 26 20 04 st %g1, [ %i0 + 4 ]
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_make_cached_and_add_to_lru_list (bd);
if (bd->waiters)
200eac8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200eacc: 80 a0 60 00 cmp %g1, 0
200ead0: 22 80 00 03 be,a 200eadc <rtems_bdbuf_release+0x90>
200ead4: 90 02 20 74 add %o0, 0x74, %o0
200ead8: 90 02 20 64 add %o0, 0x64, %o0
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200eadc: 7f ff f8 98 call 200cd3c <rtems_bdbuf_wake>
200eae0: 01 00 00 00 nop
200eae4: 30 80 00 09 b,a 200eb08 <rtems_bdbuf_release+0xbc>
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
rtems_bdbuf_add_to_lru_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
200eae8: 7f ff fe 03 call 200e2f4 <rtems_bdbuf_discard_buffer_after_access>
200eaec: 90 10 00 18 mov %i0, %o0
break;
200eaf0: 30 80 00 06 b,a 200eb08 <rtems_bdbuf_release+0xbc>
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
200eaf4: 7f ff f9 a6 call 200d18c <rtems_bdbuf_add_to_modified_list_after_access>
200eaf8: 90 10 00 18 mov %i0, %o0
break;
200eafc: 30 80 00 03 b,a 200eb08 <rtems_bdbuf_release+0xbc>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);
200eb00: 7f ff f7 ec call 200cab0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200eb04: 92 10 20 0e mov 0xe, %o1 <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200eb08: 7f ff f7 f9 call 200caec <rtems_bdbuf_unlock_cache>
200eb0c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200eb10: 81 c7 e0 08 ret
200eb14: 81 e8 00 00 restore
}
200eb18: 81 c7 e0 08 ret <== NOT EXECUTED
200eb1c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
0200eb20 <rtems_bdbuf_release_modified>:
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
200eb20: 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)
200eb24: 80 a6 20 00 cmp %i0, 0
200eb28: 02 80 00 19 be 200eb8c <rtems_bdbuf_release_modified+0x6c><== NEVER TAKEN
200eb2c: 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();
200eb30: 7f ff f7 da call 200ca98 <rtems_bdbuf_lock_cache>
200eb34: 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)
200eb38: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200eb3c: 80 a2 20 03 cmp %o0, 3
200eb40: 0a 80 00 0d bcs 200eb74 <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
200eb44: 80 a2 20 05 cmp %o0, 5
200eb48: 08 80 00 05 bleu 200eb5c <rtems_bdbuf_release_modified+0x3c>
200eb4c: 80 a2 20 06 cmp %o0, 6
200eb50: 12 80 00 09 bne 200eb74 <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
200eb54: 01 00 00 00 nop
200eb58: 30 80 00 04 b,a 200eb68 <rtems_bdbuf_release_modified+0x48>
{
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);
200eb5c: 7f ff f9 8c call 200d18c <rtems_bdbuf_add_to_modified_list_after_access>
200eb60: 90 10 00 18 mov %i0, %o0
break;
200eb64: 30 80 00 06 b,a 200eb7c <rtems_bdbuf_release_modified+0x5c>
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
200eb68: 7f ff fd e3 call 200e2f4 <rtems_bdbuf_discard_buffer_after_access>
200eb6c: 90 10 00 18 mov %i0, %o0
break;
200eb70: 30 80 00 03 b,a 200eb7c <rtems_bdbuf_release_modified+0x5c>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);
200eb74: 7f ff f7 cf call 200cab0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200eb78: 92 10 20 12 mov 0x12, %o1 <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200eb7c: 7f ff f7 dc call 200caec <rtems_bdbuf_unlock_cache>
200eb80: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200eb84: 81 c7 e0 08 ret
200eb88: 81 e8 00 00 restore
}
200eb8c: 81 c7 e0 08 ret <== NOT EXECUTED
200eb90: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
0200cdd0 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
200cdd0: 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;
200cdd4: 03 00 80 85 sethi %hi(0x2021400), %g1
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
200cdd8: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
rtems_blkdev_bnum block = node->block;
200cddc: f6 06 20 18 ld [ %i0 + 0x18 ], %i3
rtems_bdbuf_buffer* p = *root;
200cde0: fa 00 62 88 ld [ %g1 + 0x288 ], %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));
200cde4: 90 07 bf 80 add %fp, -128, %o0
200cde8: 92 10 20 00 clr %o1
200cdec: 40 00 1d 8f call 2014428 <memset>
200cdf0: 94 10 20 80 mov 0x80, %o2
rtems_bdbuf_buffer* r;
rtems_bdbuf_buffer* s;
rtems_bdbuf_buffer* p1;
rtems_bdbuf_buffer* p2;
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
200cdf4: 86 07 bf 80 add %fp, -128, %g3
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
200cdf8: 84 10 20 01 mov 1, %g2
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
200cdfc: 10 80 00 15 b 200ce50 <rtems_bdbuf_remove_from_tree+0x80>
200ce00: b4 10 3f ff mov -1, %i2
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
200ce04: fa 20 c0 00 st %i5, [ %g3 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
200ce08: 80 a0 40 1c cmp %g1, %i4
200ce0c: 0a 80 00 09 bcs 200ce30 <rtems_bdbuf_remove_from_tree+0x60><== NEVER TAKEN
200ce10: 88 00 e0 04 add %g3, 4, %g4
|| ((p->dd == dd) && (p->block < block)))
200ce14: 80 a0 40 1c cmp %g1, %i4
200ce18: 32 80 00 0c bne,a 200ce48 <rtems_bdbuf_remove_from_tree+0x78><== NEVER TAKEN
200ce1c: f4 2f 60 10 stb %i2, [ %i5 + 0x10 ] <== NOT EXECUTED
200ce20: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200ce24: 80 a0 40 1b cmp %g1, %i3
200ce28: 1a 80 00 05 bcc 200ce3c <rtems_bdbuf_remove_from_tree+0x6c>
200ce2c: 01 00 00 00 nop
{
p->avl.cache = 1;
200ce30: c4 2f 60 10 stb %g2, [ %i5 + 0x10 ]
p = p->avl.right;
200ce34: 10 80 00 06 b 200ce4c <rtems_bdbuf_remove_from_tree+0x7c>
200ce38: fa 07 60 0c ld [ %i5 + 0xc ], %i5
}
else if ((p->dd != dd) || (p->block != block))
200ce3c: 02 80 00 b9 be 200d120 <rtems_bdbuf_remove_from_tree+0x350>
200ce40: 82 07 bf 80 add %fp, -128, %g1
{
p->avl.cache = -1;
200ce44: f4 2f 60 10 stb %i2, [ %i5 + 0x10 ]
p = p->avl.left;
200ce48: fa 07 60 08 ld [ %i5 + 8 ], %i5
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
200ce4c: 86 10 00 04 mov %g4, %g3
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
200ce50: 80 a7 60 00 cmp %i5, 0
200ce54: 32 bf ff ec bne,a 200ce04 <rtems_bdbuf_remove_from_tree+0x34><== ALWAYS TAKEN
200ce58: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_TREE_RM);
200ce5c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
200ce60: 7f ff ff 14 call 200cab0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200ce64: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
200ce68: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200ce6c: 80 a0 60 00 cmp %g1, 0
200ce70: 32 80 00 08 bne,a 200ce90 <rtems_bdbuf_remove_from_tree+0xc0>
200ce74: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
r = q->avl.left;
200ce78: c2 07 60 08 ld [ %i5 + 8 ], %g1
if (r != NULL)
200ce7c: 80 a0 60 00 cmp %g1, 0
200ce80: 32 80 00 27 bne,a 200cf1c <rtems_bdbuf_remove_from_tree+0x14c>
200ce84: c0 28 60 11 clrb [ %g1 + 0x11 ]
*t = q = s;
}
}
if (p != NULL)
200ce88: 10 80 00 26 b 200cf20 <rtems_bdbuf_remove_from_tree+0x150>
200ce8c: 80 a7 20 00 cmp %i4, 0
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
200ce90: 80 a0 a0 00 cmp %g2, 0
200ce94: 02 80 00 06 be 200ceac <rtems_bdbuf_remove_from_tree+0xdc>
200ce98: 84 10 00 01 mov %g1, %g2
200ce9c: b6 10 00 01 mov %g1, %i3
200cea0: 86 10 00 04 mov %g4, %g3
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
200cea4: 10 80 00 0f b 200cee0 <rtems_bdbuf_remove_from_tree+0x110>
200cea8: b2 10 3f ff mov -1, %i1
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
200ceac: c4 07 60 08 ld [ %i5 + 8 ], %g2
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
*buf_prev++ = q = r;
200ceb0: c2 21 3f fc st %g1, [ %g4 + -4 ]
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
200ceb4: c4 20 60 08 st %g2, [ %g1 + 8 ]
r->avl.bal = q->avl.bal;
200ceb8: c4 0f 60 11 ldub [ %i5 + 0x11 ], %g2
r->avl.cache = 1;
*buf_prev++ = q = r;
200cebc: 86 10 00 04 mov %g4, %g3
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
200cec0: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
r->avl.cache = 1;
200cec4: 84 10 20 01 mov 1, %g2
200cec8: 10 80 00 15 b 200cf1c <rtems_bdbuf_remove_from_tree+0x14c>
200cecc: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
200ced0: f2 28 a0 10 stb %i1, [ %g2 + 0x10 ]
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
200ced4: b6 10 00 02 mov %g2, %i3
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
200ced8: 86 00 e0 04 add %g3, 4, %g3
s = r->avl.left;
200cedc: 84 10 00 1a mov %i2, %g2
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
200cee0: f4 00 a0 08 ld [ %g2 + 8 ], %i2
200cee4: 80 a6 a0 00 cmp %i2, 0
200cee8: 32 bf ff fa bne,a 200ced0 <rtems_bdbuf_remove_from_tree+0x100>
200ceec: c4 20 c0 00 st %g2, [ %g3 ]
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
200cef0: f4 07 60 08 ld [ %i5 + 8 ], %i2
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
*t = q = s;
200cef4: c4 21 3f fc st %g2, [ %g4 + -4 ]
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
200cef8: f4 20 a0 08 st %i2, [ %g2 + 8 ]
r->avl.left = s->avl.right;
200cefc: f4 00 a0 0c ld [ %g2 + 0xc ], %i2
s->avl.right = q->avl.right;
200cf00: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
s->avl.bal = q->avl.bal;
200cf04: c2 0f 60 11 ldub [ %i5 + 0x11 ], %g1
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
200cf08: f4 26 e0 08 st %i2, [ %i3 + 8 ]
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
200cf0c: c2 28 a0 11 stb %g1, [ %g2 + 0x11 ]
s->avl.cache = 1;
200cf10: 82 10 20 01 mov 1, %g1
200cf14: c2 28 a0 10 stb %g1, [ %g2 + 0x10 ]
*t = q = s;
200cf18: 82 10 00 02 mov %g2, %g1
}
}
if (p != NULL)
200cf1c: 80 a7 20 00 cmp %i4, 0
200cf20: 02 80 00 0d be 200cf54 <rtems_bdbuf_remove_from_tree+0x184>
200cf24: 05 00 80 85 sethi %hi(0x2021400), %g2
{
if (p->avl.cache == -1)
200cf28: c4 4f 20 10 ldsb [ %i4 + 0x10 ], %g2
200cf2c: 80 a0 bf ff cmp %g2, -1
200cf30: 32 80 00 03 bne,a 200cf3c <rtems_bdbuf_remove_from_tree+0x16c>
200cf34: c2 27 20 0c st %g1, [ %i4 + 0xc ]
{
p->avl.left = q;
200cf38: c2 27 20 08 st %g1, [ %i4 + 8 ]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
200cf3c: 82 07 bf 80 add %fp, -128, %g1
200cf40: 80 a0 c0 01 cmp %g3, %g1
200cf44: 18 80 00 06 bgu 200cf5c <rtems_bdbuf_remove_from_tree+0x18c>
200cf48: ba 10 20 01 mov 1, %i5
200cf4c: 81 c7 e0 08 ret
200cf50: 81 e8 00 00 restore
p->avl.right = q;
}
}
else
{
*root = q;
200cf54: 10 bf ff fa b 200cf3c <rtems_bdbuf_remove_from_tree+0x16c>
200cf58: c2 20 a2 88 st %g1, [ %g2 + 0x288 ]
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
200cf5c: b6 10 3f ff mov -1, %i3
default:
break;
}
}
if (buf_prev > buf_stack)
200cf60: b2 10 00 01 mov %g1, %i1
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
200cf64: c2 00 ff fc ld [ %g3 + -4 ], %g1
else
{
break;
}
if (p->avl.cache == -1)
200cf68: f8 48 60 10 ldsb [ %g1 + 0x10 ], %i4
200cf6c: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
200cf70: 80 a7 3f ff cmp %i4, -1
{
/* rebalance left branch */
switch (p->avl.bal)
200cf74: 85 28 a0 18 sll %g2, 0x18, %g2
else
{
break;
}
if (p->avl.cache == -1)
200cf78: 12 80 00 2a bne 200d020 <rtems_bdbuf_remove_from_tree+0x250>
200cf7c: 85 38 a0 18 sra %g2, 0x18, %g2
{
/* rebalance left branch */
switch (p->avl.bal)
200cf80: 80 a0 a0 00 cmp %g2, 0
200cf84: 22 80 00 14 be,a 200cfd4 <rtems_bdbuf_remove_from_tree+0x204>
200cf88: fa 28 60 11 stb %i5, [ %g1 + 0x11 ]
200cf8c: 80 a0 a0 01 cmp %g2, 1
200cf90: 02 80 00 06 be 200cfa8 <rtems_bdbuf_remove_from_tree+0x1d8>
200cf94: 80 a0 bf ff cmp %g2, -1
200cf98: 12 80 00 4f bne 200d0d4 <rtems_bdbuf_remove_from_tree+0x304><== NEVER TAKEN
200cf9c: 84 10 20 01 mov 1, %g2
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
200cfa0: 10 80 00 4d b 200d0d4 <rtems_bdbuf_remove_from_tree+0x304>
200cfa4: c0 28 60 11 clrb [ %g1 + 0x11 ]
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
200cfa8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
if (p1->avl.bal >= 0) /* simple RR-turn */
200cfac: f4 48 a0 11 ldsb [ %g2 + 0x11 ], %i2
200cfb0: 80 a6 a0 00 cmp %i2, 0
200cfb4: 06 80 00 0a bl 200cfdc <rtems_bdbuf_remove_from_tree+0x20c>
200cfb8: c8 00 a0 08 ld [ %g2 + 8 ], %g4
{
p->avl.right = p1->avl.left;
200cfbc: c8 20 60 0c st %g4, [ %g1 + 0xc ]
p1->avl.left = p;
if (p1->avl.bal == 0)
200cfc0: 80 a6 a0 00 cmp %i2, 0
200cfc4: 12 80 00 2d bne 200d078 <rtems_bdbuf_remove_from_tree+0x2a8>
200cfc8: c2 20 a0 08 st %g1, [ %g2 + 8 ]
{
p1->avl.bal = -1;
200cfcc: f8 28 a0 11 stb %i4, [ %g2 + 0x11 ]
200cfd0: 82 10 00 02 mov %g2, %g1
modified = false;
200cfd4: 10 80 00 40 b 200d0d4 <rtems_bdbuf_remove_from_tree+0x304>
200cfd8: 84 10 20 00 clr %g2
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200cfdc: f4 01 20 0c ld [ %g4 + 0xc ], %i2
p2->avl.right = p1;
200cfe0: c4 21 20 0c st %g2, [ %g4 + 0xc ]
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200cfe4: f4 20 a0 08 st %i2, [ %g2 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200cfe8: f4 01 20 08 ld [ %g4 + 8 ], %i2
p2->avl.left = p;
200cfec: c2 21 20 08 st %g1, [ %g4 + 8 ]
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200cff0: f4 20 60 0c st %i2, [ %g1 + 0xc ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200cff4: f4 49 20 11 ldsb [ %g4 + 0x11 ], %i2
200cff8: 80 a6 a0 01 cmp %i2, 1
200cffc: 32 80 00 03 bne,a 200d008 <rtems_bdbuf_remove_from_tree+0x238>
200d000: c0 28 60 11 clrb [ %g1 + 0x11 ]
200d004: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
200d008: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d00c: 80 a0 7f ff cmp %g1, -1
200d010: 32 80 00 2e bne,a 200d0c8 <rtems_bdbuf_remove_from_tree+0x2f8><== ALWAYS TAKEN
200d014: c0 28 a0 11 clrb [ %g2 + 0x11 ]
200d018: 10 80 00 2c b 200d0c8 <rtems_bdbuf_remove_from_tree+0x2f8><== NOT EXECUTED
200d01c: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ] <== NOT EXECUTED
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
200d020: 80 a0 a0 00 cmp %g2, 0
200d024: 22 bf ff ec be,a 200cfd4 <rtems_bdbuf_remove_from_tree+0x204>
200d028: f6 28 60 11 stb %i3, [ %g1 + 0x11 ]
200d02c: 80 a0 a0 01 cmp %g2, 1
200d030: 02 80 00 06 be 200d048 <rtems_bdbuf_remove_from_tree+0x278>
200d034: 80 a0 bf ff cmp %g2, -1
200d038: 32 80 00 27 bne,a 200d0d4 <rtems_bdbuf_remove_from_tree+0x304><== NEVER TAKEN
200d03c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
p->avl.bal = -1;
modified = false;
break;
case -1:
p1 = p->avl.left;
200d040: 10 80 00 04 b 200d050 <rtems_bdbuf_remove_from_tree+0x280>
200d044: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
200d048: 10 80 00 22 b 200d0d0 <rtems_bdbuf_remove_from_tree+0x300>
200d04c: c0 28 60 11 clrb [ %g1 + 0x11 ]
break;
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
200d050: f8 48 a0 11 ldsb [ %g2 + 0x11 ], %i4
200d054: 80 a7 20 00 cmp %i4, 0
200d058: 14 80 00 0c bg 200d088 <rtems_bdbuf_remove_from_tree+0x2b8>
200d05c: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
{
p->avl.left = p1->avl.right;
200d060: c8 20 60 08 st %g4, [ %g1 + 8 ]
p1->avl.right = p;
if (p1->avl.bal == 0)
200d064: 80 a7 20 00 cmp %i4, 0
200d068: 12 80 00 04 bne 200d078 <rtems_bdbuf_remove_from_tree+0x2a8>
200d06c: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
{
p1->avl.bal = 1;
200d070: 10 bf ff d8 b 200cfd0 <rtems_bdbuf_remove_from_tree+0x200>
200d074: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ]
modified = false;
}
else
{
p->avl.bal = 0;
200d078: c0 28 60 11 clrb [ %g1 + 0x11 ]
p1->avl.bal = 0;
200d07c: c0 28 a0 11 clrb [ %g2 + 0x11 ]
200d080: 10 80 00 14 b 200d0d0 <rtems_bdbuf_remove_from_tree+0x300>
200d084: 82 10 00 02 mov %g2, %g1
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d088: f8 01 20 08 ld [ %g4 + 8 ], %i4
p2->avl.left = p1;
200d08c: c4 21 20 08 st %g2, [ %g4 + 8 ]
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d090: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200d094: f8 01 20 0c ld [ %g4 + 0xc ], %i4
p2->avl.right = p;
200d098: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200d09c: f8 20 60 08 st %i4, [ %g1 + 8 ]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
200d0a0: f8 49 20 11 ldsb [ %g4 + 0x11 ], %i4
200d0a4: 80 a7 3f ff cmp %i4, -1
200d0a8: 32 80 00 03 bne,a 200d0b4 <rtems_bdbuf_remove_from_tree+0x2e4>
200d0ac: c0 28 60 11 clrb [ %g1 + 0x11 ]
200d0b0: fa 28 60 11 stb %i5, [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
200d0b4: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d0b8: 80 a0 60 01 cmp %g1, 1
200d0bc: 32 80 00 03 bne,a 200d0c8 <rtems_bdbuf_remove_from_tree+0x2f8>
200d0c0: c0 28 a0 11 clrb [ %g2 + 0x11 ]
200d0c4: f6 28 a0 11 stb %i3, [ %g2 + 0x11 ]
p = p2;
p2->avl.bal = 0;
200d0c8: c0 29 20 11 clrb [ %g4 + 0x11 ]
200d0cc: 82 10 00 04 mov %g4, %g1
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
200d0d0: 84 10 20 01 mov 1, %g2
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
200d0d4: 88 00 ff fc add %g3, -4, %g4
default:
break;
}
}
if (buf_prev > buf_stack)
200d0d8: 80 a1 00 19 cmp %g4, %i1
200d0dc: 28 80 00 09 bleu,a 200d100 <rtems_bdbuf_remove_from_tree+0x330>
200d0e0: 05 00 80 85 sethi %hi(0x2021400), %g2
{
q = *(buf_prev - 1);
200d0e4: c8 00 ff f8 ld [ %g3 + -8 ], %g4
if (q->avl.cache == -1)
200d0e8: f8 49 20 10 ldsb [ %g4 + 0x10 ], %i4
200d0ec: 80 a7 3f ff cmp %i4, -1
200d0f0: 32 80 00 07 bne,a 200d10c <rtems_bdbuf_remove_from_tree+0x33c>
200d0f4: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
q->avl.left = p;
200d0f8: 10 80 00 05 b 200d10c <rtems_bdbuf_remove_from_tree+0x33c>
200d0fc: c2 21 20 08 st %g1, [ %g4 + 8 ]
q->avl.right = p;
}
}
else
{
*root = p;
200d100: c2 20 a2 88 st %g1, [ %g2 + 0x288 ]
200d104: 81 c7 e0 08 ret
200d108: 81 e8 00 00 restore
*root = q;
}
modified = true;
while (modified)
200d10c: 80 88 a0 ff btst 0xff, %g2
200d110: 12 bf ff 95 bne 200cf64 <rtems_bdbuf_remove_from_tree+0x194>
200d114: 86 00 ff fc add %g3, -4, %g3
200d118: 81 c7 e0 08 ret
200d11c: 81 e8 00 00 restore
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
200d120: 80 a0 c0 01 cmp %g3, %g1
200d124: 08 bf ff 51 bleu 200ce68 <rtems_bdbuf_remove_from_tree+0x98>
200d128: b8 10 20 00 clr %i4
{
p = *(buf_prev - 1);
200d12c: 10 bf ff 4f b 200ce68 <rtems_bdbuf_remove_from_tree+0x98>
200d130: f8 01 3f f8 ld [ %g4 + -8 ], %i4
0200d268 <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)
{
200d268: 9d e3 bf a0 save %sp, -96, %sp
switch (bd->state)
200d26c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200d270: 80 a2 20 00 cmp %o0, 0
200d274: 22 80 00 0b be,a 200d2a0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
200d278: c4 06 00 00 ld [ %i0 ], %g2
200d27c: 80 a2 20 02 cmp %o0, 2
200d280: 12 80 00 06 bne 200d298 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30><== NEVER TAKEN
200d284: 01 00 00 00 nop
{
case RTEMS_BDBUF_STATE_FREE:
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
200d288: 7f ff fe d2 call 200cdd0 <rtems_bdbuf_remove_from_tree>
200d28c: 90 10 00 18 mov %i0, %o0
break;
200d290: 10 80 00 04 b 200d2a0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
200d294: c4 06 00 00 ld [ %i0 ], %g2
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_10);
200d298: 7f ff fe 06 call 200cab0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200d29c: 92 10 20 16 mov 0x16, %o1 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200d2a0: c2 06 20 04 ld [ %i0 + 4 ], %g1
next->previous = previous;
200d2a4: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
200d2a8: c4 20 40 00 st %g2, [ %g1 ]
200d2ac: 81 c7 e0 08 ret
200d2b0: 81 e8 00 00 restore
0200cb68 <rtems_bdbuf_restore_preemption>:
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
200cb68: 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);
200cb6c: 13 00 00 3f sethi %hi(0xfc00), %o1
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
200cb70: 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);
200cb74: 90 10 00 18 mov %i0, %o0
200cb78: 92 12 63 ff or %o1, 0x3ff, %o1
200cb7c: 40 00 11 60 call 20110fc <rtems_task_mode>
200cb80: 94 07 a0 44 add %fp, 0x44, %o2
if (sc != RTEMS_SUCCESSFUL)
200cb84: 80 a2 20 00 cmp %o0, 0
200cb88: 02 80 00 04 be 200cb98 <rtems_bdbuf_restore_preemption+0x30><== ALWAYS TAKEN
200cb8c: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_RST);
200cb90: 7f ff ff b1 call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200cb94: 90 10 20 06 mov 6, %o0 ! 6 <PROM_START+0x6> <== NOT EXECUTED
200cb98: 81 c7 e0 08 ret
200cb9c: 81 e8 00 00 restore
0200eed4 <rtems_bdbuf_set_block_size>:
rtems_status_code
rtems_bdbuf_set_block_size (rtems_disk_device *dd,
uint32_t block_size,
bool sync)
{
200eed4: 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)
200eed8: 80 a6 a0 00 cmp %i2, 0
200eedc: 02 80 00 04 be 200eeec <rtems_bdbuf_set_block_size+0x18>
200eee0: ba 10 00 18 mov %i0, %i5
rtems_bdbuf_syncdev (dd);
200eee4: 7f ff ff 79 call 200ecc8 <rtems_bdbuf_syncdev>
200eee8: 90 10 00 18 mov %i0, %o0
rtems_bdbuf_lock_cache ();
200eeec: 7f ff f6 eb call 200ca98 <rtems_bdbuf_lock_cache>
200eef0: b0 10 20 0a mov 0xa, %i0
if (block_size > 0)
200eef4: 80 a6 60 00 cmp %i1, 0
200eef8: 02 80 00 30 be 200efb8 <rtems_bdbuf_set_block_size+0xe4>
200eefc: 03 00 80 7a sethi %hi(0x201e800), %g1
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
200ef00: 82 10 63 f8 or %g1, 0x3f8, %g1 ! 201ebf8 <rtems_bdbuf_configuration>
200ef04: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
200ef08: 80 a6 40 02 cmp %i1, %g2
200ef0c: 18 80 00 2b bgu 200efb8 <rtems_bdbuf_set_block_size+0xe4> <== NEVER TAKEN
200ef10: 01 00 00 00 nop
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
200ef14: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
200ef18: 40 00 36 1b call 201c784 <.udiv>
200ef1c: 90 06 7f ff add %i1, -1, %o0
for (bds_per_size = 1;
200ef20: 92 10 20 01 mov 1, %o1
200ef24: 90 02 20 01 inc %o0
200ef28: 80 a2 40 08 cmp %o1, %o0
200ef2c: 2a bf ff ff bcs,a 200ef28 <rtems_bdbuf_set_block_size+0x54>
200ef30: 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;
200ef34: 03 00 80 85 sethi %hi(0x2021400), %g1
200ef38: d0 00 62 6c ld [ %g1 + 0x26c ], %o0 ! 202166c <bdbuf_cache+0x20>
200ef3c: 40 00 36 12 call 201c784 <.udiv>
200ef40: b0 10 20 0a mov 0xa, %i0
if (block_size > 0)
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (block_size);
if (bds_per_group != 0)
200ef44: 80 a2 20 00 cmp %o0, 0
200ef48: 02 80 00 1c be 200efb8 <rtems_bdbuf_set_block_size+0xe4> <== NEVER TAKEN
200ef4c: 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;
200ef50: f0 07 60 20 ld [ %i5 + 0x20 ], %i0
200ef54: 90 10 00 19 mov %i1, %o0
200ef58: 40 00 36 0b call 201c784 <.udiv>
200ef5c: 92 10 00 18 mov %i0, %o1
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (block_size);
if (bds_per_group != 0)
{
int block_to_media_block_shift = 0;
200ef60: b8 10 20 00 clr %i4
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
200ef64: b6 10 00 08 mov %o0, %i3
200ef68: 84 10 20 01 mov 1, %g2
uint32_t one = 1;
while ((one << block_to_media_block_shift) < media_blocks_per_block)
200ef6c: 83 28 80 1c sll %g2, %i4, %g1
200ef70: 80 a0 40 1b cmp %g1, %i3
200ef74: 2a bf ff fe bcs,a 200ef6c <rtems_bdbuf_set_block_size+0x98>
200ef78: b8 07 20 01 inc %i4
{
++block_to_media_block_shift;
}
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
200ef7c: b1 2e 00 1c sll %i0, %i4, %i0
200ef80: 80 a6 00 19 cmp %i0, %i1
200ef84: 32 80 00 02 bne,a 200ef8c <rtems_bdbuf_set_block_size+0xb8><== NEVER TAKEN
200ef88: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
block_to_media_block_shift = -1;
dd->block_size = block_size;
dd->block_count = dd->size / media_blocks_per_block;
200ef8c: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
200ef90: 92 10 00 1b mov %i3, %o1
200ef94: 40 00 35 fc call 201c784 <.udiv>
200ef98: f2 27 60 24 st %i1, [ %i5 + 0x24 ]
rtems_status_code
rtems_bdbuf_set_block_size (rtems_disk_device *dd,
uint32_t block_size,
bool sync)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
200ef9c: b0 10 20 00 clr %i0
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;
200efa0: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
dd->media_blocks_per_block = media_blocks_per_block;
200efa4: f6 27 60 2c st %i3, [ %i5 + 0x2c ]
dd->block_to_media_block_shift = block_to_media_block_shift;
200efa8: f8 27 60 30 st %i4, [ %i5 + 0x30 ]
dd->bds_per_group = bds_per_group;
200efac: f4 27 60 34 st %i2, [ %i5 + 0x34 ]
rtems_bdbuf_purge_dev (dd);
200efb0: 7f ff ff 5d call 200ed24 <rtems_bdbuf_purge_dev>
200efb4: 90 10 00 1d mov %i5, %o0
else
{
sc = RTEMS_INVALID_NUMBER;
}
rtems_bdbuf_unlock_cache ();
200efb8: 7f ff f6 cd call 200caec <rtems_bdbuf_unlock_cache>
200efbc: 01 00 00 00 nop
return sc;
}
200efc0: 81 c7 e0 08 ret
200efc4: 81 e8 00 00 restore
0200d87c <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
200d87c: 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;
200d880: 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 );
200d884: b2 06 60 04 add %i1, 4, %i1
if (!rtems_chain_is_empty (chain))
200d888: 80 a0 40 19 cmp %g1, %i1
200d88c: 02 80 00 4e be 200d9c4 <rtems_bdbuf_swapout_modified_processing+0x148>
200d890: 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))
200d894: 02 80 00 05 be 200d8a8 <rtems_bdbuf_swapout_modified_processing+0x2c>
200d898: 84 10 20 00 clr %g2
200d89c: c4 06 00 00 ld [ %i0 ], %g2
200d8a0: 80 a0 00 02 cmp %g0, %g2
200d8a4: 84 60 3f ff subx %g0, -1, %g2
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
200d8a8: 07 00 80 85 sethi %hi(0x2021400), %g3
200d8ac: de 00 e2 c0 ld [ %g3 + 0x2c0 ], %o7 ! 20216c0 <bdbuf_cache+0x74>
* or someone waits for a buffer written force all the timers to 0.
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dd_ptr == bd->dd))
200d8b0: 9a 08 a0 ff and %g2, 0xff, %o5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d8b4: 98 10 20 09 mov 9, %o4
* or someone waits for a buffer written force all the timers to 0.
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dd_ptr == bd->dd))
200d8b8: 80 a3 60 00 cmp %o5, 0
200d8bc: 32 80 00 0d bne,a 200d8f0 <rtems_bdbuf_swapout_modified_processing+0x74>
200d8c0: c0 20 60 2c clr [ %g1 + 0x2c ]
200d8c4: 80 a6 e0 00 cmp %i3, 0
200d8c8: 02 80 00 07 be 200d8e4 <rtems_bdbuf_swapout_modified_processing+0x68>
200d8cc: 80 a3 e0 00 cmp %o7, 0
200d8d0: c6 06 00 00 ld [ %i0 ], %g3
200d8d4: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
200d8d8: 80 a0 c0 02 cmp %g3, %g2
200d8dc: 02 80 00 04 be 200d8ec <rtems_bdbuf_swapout_modified_processing+0x70>
200d8e0: 80 a3 e0 00 cmp %o7, 0
|| rtems_bdbuf_has_buffer_waiters ())
200d8e4: 22 80 00 04 be,a 200d8f4 <rtems_bdbuf_swapout_modified_processing+0x78>
200d8e8: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
bd->hold_timer = 0;
200d8ec: c0 20 60 2c clr [ %g1 + 0x2c ]
if (bd->hold_timer)
200d8f0: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
200d8f4: 80 a0 a0 00 cmp %g2, 0
200d8f8: 22 80 00 10 be,a 200d938 <rtems_bdbuf_swapout_modified_processing+0xbc>
200d8fc: c4 06 00 00 ld [ %i0 ], %g2
{
if (update_timers)
200d900: 80 a7 20 00 cmp %i4, 0
200d904: 22 80 00 08 be,a 200d924 <rtems_bdbuf_swapout_modified_processing+0xa8>
200d908: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
{
if (bd->hold_timer > timer_delta)
200d90c: 80 a0 80 1d cmp %g2, %i5
200d910: 28 80 00 04 bleu,a 200d920 <rtems_bdbuf_swapout_modified_processing+0xa4>
200d914: c0 20 60 2c clr [ %g1 + 0x2c ]
bd->hold_timer -= timer_delta;
200d918: 84 20 80 1d sub %g2, %i5, %g2
200d91c: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
else
bd->hold_timer = 0;
}
if (bd->hold_timer)
200d920: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
200d924: 80 a0 a0 00 cmp %g2, 0
200d928: 22 80 00 04 be,a 200d938 <rtems_bdbuf_swapout_modified_processing+0xbc>
200d92c: c4 06 00 00 ld [ %i0 ], %g2
{
node = node->next;
continue;
200d930: 10 80 00 22 b 200d9b8 <rtems_bdbuf_swapout_modified_processing+0x13c>
200d934: c2 00 40 00 ld [ %g1 ], %g1
/*
* This assumes we can set it to BDBUF_INVALID_DEV which is just an
* assumption. Cannot use the transfer list being empty the sync dev
* calls sets the dev to use.
*/
if (*dd_ptr == BDBUF_INVALID_DEV)
200d938: 80 a0 a0 00 cmp %g2, 0
200d93c: 32 80 00 05 bne,a 200d950 <rtems_bdbuf_swapout_modified_processing+0xd4>
200d940: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
*dd_ptr = bd->dd;
200d944: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
200d948: c4 26 00 00 st %g2, [ %i0 ]
if (bd->dd == *dd_ptr)
200d94c: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
200d950: c4 06 00 00 ld [ %i0 ], %g2
200d954: 80 a0 c0 02 cmp %g3, %g2
200d958: 12 80 00 17 bne 200d9b4 <rtems_bdbuf_swapout_modified_processing+0x138><== NEVER TAKEN
200d95c: c6 00 40 00 ld [ %g1 ], %g3
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200d960: c4 00 60 04 ld [ %g1 + 4 ], %g2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d964: d8 20 60 20 st %o4, [ %g1 + 0x20 ]
next->previous = previous;
200d968: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
200d96c: c6 20 80 00 st %g3, [ %g2 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
200d970: 10 80 00 0c b 200d9a0 <rtems_bdbuf_swapout_modified_processing+0x124>
200d974: c4 06 a0 08 ld [ %i2 + 8 ], %g2
while (node && !rtems_chain_is_head (transfer, tnode))
{
rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
if (bd->block > tbd->block)
200d978: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
200d97c: 80 a2 c0 04 cmp %o3, %g4
200d980: 28 80 00 08 bleu,a 200d9a0 <rtems_bdbuf_swapout_modified_processing+0x124>
200d984: c4 00 a0 04 ld [ %g2 + 4 ], %g2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200d988: c8 00 80 00 ld [ %g2 ], %g4
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200d98c: c4 20 60 04 st %g2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200d990: c2 20 80 00 st %g1, [ %g2 ]
the_node->next = before_node;
200d994: c8 20 40 00 st %g4, [ %g1 ]
before_node->previous = the_node;
200d998: 10 80 00 07 b 200d9b4 <rtems_bdbuf_swapout_modified_processing+0x138>
200d99c: c2 21 20 04 st %g1, [ %g4 + 4 ]
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
200d9a0: 80 a0 80 1a cmp %g2, %i2
200d9a4: 32 bf ff f5 bne,a 200d978 <rtems_bdbuf_swapout_modified_processing+0xfc>
200d9a8: d6 00 60 18 ld [ %g1 + 0x18 ], %o3
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200d9ac: 10 80 00 08 b 200d9cc <rtems_bdbuf_swapout_modified_processing+0x150>
200d9b0: c4 06 80 00 ld [ %i2 ], %g2
node = next_node;
}
else
{
node = node->next;
200d9b4: 82 10 00 03 mov %g3, %g1
if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
while (!rtems_chain_is_tail (chain, node))
200d9b8: 80 a0 40 19 cmp %g1, %i1
200d9bc: 12 bf ff c0 bne 200d8bc <rtems_bdbuf_swapout_modified_processing+0x40>
200d9c0: 80 a3 60 00 cmp %o5, 0
200d9c4: 81 c7 e0 08 ret
200d9c8: 81 e8 00 00 restore
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200d9cc: f4 20 60 04 st %i2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200d9d0: c2 26 80 00 st %g1, [ %i2 ]
the_node->next = before_node;
200d9d4: c4 20 40 00 st %g2, [ %g1 ]
before_node->previous = the_node;
200d9d8: 10 bf ff f7 b 200d9b4 <rtems_bdbuf_swapout_modified_processing+0x138>
200d9dc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
0200dd08 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
200dd08: 9d e3 bf 80 save %sp, -128, %sp
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;
200dd0c: 33 00 80 7a sethi %hi(0x201e800), %i1
200dd10: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 201ebf8 <rtems_bdbuf_configuration>
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200dd14: 7f ff fb de call 200cc8c <rtems_bdbuf_swapout_writereq_alloc>
200dd18: f6 06 60 0c ld [ %i1 + 0xc ], %i3
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200dd1c: 82 07 bf ec add %fp, -20, %g1
200dd20: c2 27 bf e8 st %g1, [ %fp + -24 ]
head->previous = NULL;
tail->previous = head;
200dd24: 82 07 bf e8 add %fp, -24, %g1
200dd28: c2 27 bf f0 st %g1, [ %fp + -16 ]
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
200dd2c: 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 ();
200dd30: d0 27 bf fc st %o0, [ %fp + -4 ]
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
200dd34: 91 2e e0 07 sll %i3, 7, %o0
200dd38: 90 22 00 01 sub %o0, %g1, %o0
200dd3c: 03 00 80 7a sethi %hi(0x201e800), %g1
200dd40: d2 00 63 bc ld [ %g1 + 0x3bc ], %o1 ! 201ebbc <Configuration+0xc>
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
200dd44: c0 27 bf ec clr [ %fp + -20 ]
const uint32_t period_in_msecs = bdbuf_config.swapout_period;
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&transfer.bds);
transfer.dd = BDBUF_INVALID_DEV;
200dd48: c0 27 bf f4 clr [ %fp + -12 ]
transfer.syncing = false;
200dd4c: c0 2f bf f8 clrb [ %fp + -8 ]
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
200dd50: 90 02 00 1b add %o0, %i3, %o0
200dd54: 40 00 3a 8c call 201c784 <.udiv>
200dd58: 91 2a 20 03 sll %o0, 3, %o0
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200dd5c: 35 00 80 85 sethi %hi(0x2021400), %i2
200dd60: a0 10 00 08 mov %o0, %l0
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
200dd64: 7f ff fb 4d call 200ca98 <rtems_bdbuf_lock_cache>
200dd68: b4 16 a2 4c or %i2, 0x24c, %i2
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200dd6c: 27 10 91 1b sethi %hi(0x42446c00), %l3
200dd70: 29 00 80 38 sethi %hi(0x200e000), %l4
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
200dd74: b8 10 20 00 clr %i4
200dd78: f0 06 60 14 ld [ %i1 + 0x14 ], %i0
the_node->next = tail;
200dd7c: a2 06 a0 0c add %i2, 0xc, %l1
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;
200dd80: a4 10 20 01 mov 1, %l2
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200dd84: a6 14 e3 00 or %l3, 0x300, %l3
200dd88: 10 80 00 23 b 200de14 <rtems_bdbuf_swapout_task+0x10c>
200dd8c: a8 15 20 2c or %l4, 0x2c, %l4
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
200dd90: 7f ff db e4 call 2004d20 <malloc> <== NOT EXECUTED
200dd94: 90 10 20 28 mov 0x28, %o0 <== NOT EXECUTED
if (!worker)
200dd98: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
200dd9c: 32 80 00 04 bne,a 200ddac <rtems_bdbuf_swapout_task+0xa4><== NOT EXECUTED
200dda0: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
200dda4: 10 80 00 1a b 200de0c <rtems_bdbuf_swapout_task+0x104> <== NOT EXECUTED
200dda8: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
200ddac: e2 27 40 00 st %l1, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
old_last->next = the_node;
200ddb0: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
the_node->previous = old_last;
200ddb4: 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;
200ddb8: fa 26 a0 10 st %i5, [ %i2 + 0x10 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200ddbc: 7f ff fb b4 call 200cc8c <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
200ddc0: e4 2f 60 0c stb %l2, [ %i5 + 0xc ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200ddc4: d2 06 60 18 ld [ %i1 + 0x18 ], %o1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
200ddc8: 82 07 60 10 add %i5, 0x10, %g1 <== NOT EXECUTED
200ddcc: 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 ();
200ddd0: d0 27 60 24 st %o0, [ %i5 + 0x24 ] <== NOT EXECUTED
head->next = tail;
200ddd4: c4 27 60 10 st %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
head->previous = NULL;
200ddd8: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED
tail->previous = head;
200dddc: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
200dde0: c0 27 60 1c clr [ %i5 + 0x1c ] <== NOT EXECUTED
* @param arg A pointer to the global cache data. Use the global variable and
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
200dde4: 90 07 20 61 add %i4, 0x61, %o0 <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200dde8: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
200ddec: 90 12 00 13 or %o0, %l3, %o0 <== NOT EXECUTED
200ddf0: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
200ddf4: 7f ff fb e0 call 200cd74 <rtems_bdbuf_create_task.constprop.10><== NOT EXECUTED
200ddf8: 98 07 60 08 add %i5, 8, %o4 <== NOT EXECUTED
bdbuf_config.swapout_worker_priority,
RTEMS_BDBUF_SWAPOUT_WORKER_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
200ddfc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200de00: 22 80 00 05 be,a 200de14 <rtems_bdbuf_swapout_task+0x10c><== NOT EXECUTED
200de04: b8 07 20 01 inc %i4 <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
200de08: 90 10 20 0d mov 0xd, %o0 <== NOT EXECUTED
200de0c: 7f ff fb 12 call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200de10: 01 00 00 00 nop <== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
200de14: 80 a7 00 18 cmp %i4, %i0
200de18: 0a bf ff de bcs 200dd90 <rtems_bdbuf_swapout_task+0x88> <== NEVER TAKEN
200de1c: 01 00 00 00 nop
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
}
rtems_bdbuf_unlock_cache ();
200de20: 7f ff fb 33 call 200caec <rtems_bdbuf_unlock_cache>
200de24: 39 00 80 85 sethi %hi(0x2021400), %i4
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
200de28: b8 17 22 4c or %i4, 0x24c, %i4 ! 202164c <bdbuf_cache>
200de2c: a2 07 20 08 add %i4, 8, %l1
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200de30: a4 07 20 58 add %i4, 0x58, %l2
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200de34: 10 80 00 5a b 200df9c <rtems_bdbuf_swapout_task+0x294>
200de38: a6 07 20 4c add %i4, 0x4c, %l3
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
200de3c: 7f ff fb 17 call 200ca98 <rtems_bdbuf_lock_cache>
200de40: 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)
200de44: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
200de48: 80 a0 60 00 cmp %g1, 0
200de4c: 02 80 00 04 be 200de5c <rtems_bdbuf_swapout_task+0x154>
200de50: b4 10 20 00 clr %i2
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
200de54: 10 80 00 08 b 200de74 <rtems_bdbuf_swapout_task+0x16c>
200de58: ba 07 bf e8 add %fp, -24, %i5
200de5c: 7f ff fa ea call 200ca04 <_Chain_Get_unprotected>
200de60: 90 10 00 11 mov %l1, %o0
worker = NULL;
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get_unprotected (&bdbuf_cache.swapout_workers);
if (worker)
200de64: b4 92 20 00 orcc %o0, 0, %i2
200de68: 22 bf ff fb be,a 200de54 <rtems_bdbuf_swapout_task+0x14c><== ALWAYS TAKEN
200de6c: b4 10 20 00 clr %i2
transfer = &worker->transfer;
200de70: ba 06 a0 10 add %i2, 0x10, %i5 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
200de74: 82 07 60 04 add %i5, 4, %g1
head->next = tail;
200de78: c2 27 40 00 st %g1, [ %i5 ]
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
200de7c: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
head->previous = NULL;
200de80: c0 27 60 04 clr [ %i5 + 4 ]
tail->previous = head;
200de84: fa 27 60 08 st %i5, [ %i5 + 8 ]
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
200de88: c0 27 60 0c clr [ %i5 + 0xc ]
/*
* When the sync is for a device limit the sync to that device. If the sync
* is for a buffer handle process the devices in the order on the sync
* list. This means the dev is BDBUF_INVALID_DEV.
*/
if (bdbuf_cache.sync_active)
200de8c: 80 88 60 ff btst 0xff, %g1
200de90: 02 80 00 04 be 200dea0 <rtems_bdbuf_swapout_task+0x198>
200de94: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
transfer->dd = bdbuf_cache.sync_device;
200de98: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
200de9c: c2 27 60 0c st %g1, [ %i5 + 0xc ]
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200dea0: b0 07 60 0c add %i5, 0xc, %i0
200dea4: 92 10 00 12 mov %l2, %o1
200dea8: 90 10 00 18 mov %i0, %o0
200deac: 94 10 00 1d mov %i5, %o2
200deb0: 96 10 20 01 mov 1, %o3
200deb4: 98 10 20 00 clr %o4
200deb8: 7f ff fe 71 call 200d87c <rtems_bdbuf_swapout_modified_processing>
200debc: 9a 10 00 1b mov %i3, %o5
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200dec0: d6 0f 20 30 ldub [ %i4 + 0x30 ], %o3
200dec4: 90 10 00 18 mov %i0, %o0
200dec8: 92 10 00 13 mov %l3, %o1
200decc: 94 10 00 1d mov %i5, %o2
200ded0: 98 0e 60 01 and %i1, 1, %o4
200ded4: 7f ff fe 6a call 200d87c <rtems_bdbuf_swapout_modified_processing>
200ded8: 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 ();
200dedc: 7f ff fb 04 call 200caec <rtems_bdbuf_unlock_cache>
200dee0: 01 00 00 00 nop
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
200dee4: c4 07 40 00 ld [ %i5 ], %g2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200dee8: 82 07 60 04 add %i5, 4, %g1
200deec: 80 a0 80 01 cmp %g2, %g1
200def0: 02 80 00 10 be 200df30 <rtems_bdbuf_swapout_task+0x228>
200def4: 80 a6 a0 00 cmp %i2, 0
{
if (worker)
200def8: 02 80 00 0a be 200df20 <rtems_bdbuf_swapout_task+0x218> <== ALWAYS TAKEN
200defc: 01 00 00 00 nop
{
rtems_status_code sc = rtems_event_send (worker->id,
200df00: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
200df04: 7f ff e9 d0 call 2008644 <rtems_event_send> <== NOT EXECUTED
200df08: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
200df0c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200df10: 02 80 00 09 be 200df34 <rtems_bdbuf_swapout_task+0x22c> <== NOT EXECUTED
200df14: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);
200df18: 10 bf ff bd b 200de0c <rtems_bdbuf_swapout_task+0x104> <== NOT EXECUTED
200df1c: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
}
else
{
rtems_bdbuf_swapout_write (transfer);
200df20: 7f ff ff 22 call 200dba8 <rtems_bdbuf_swapout_write>
200df24: 90 10 00 1d mov %i5, %o0
}
transfered_buffers = true;
200df28: 10 80 00 03 b 200df34 <rtems_bdbuf_swapout_task+0x22c>
200df2c: 82 10 20 01 mov 1, %g1
200df30: 82 10 20 00 clr %g1
}
if (bdbuf_cache.sync_active && !transfered_buffers)
200df34: c4 0f 20 30 ldub [ %i4 + 0x30 ], %g2
200df38: b2 10 20 00 clr %i1
200df3c: 80 a0 a0 00 cmp %g2, 0
200df40: 02 80 00 13 be 200df8c <rtems_bdbuf_swapout_task+0x284>
200df44: 82 08 60 ff and %g1, 0xff, %g1
200df48: 80 a0 60 00 cmp %g1, 0
200df4c: 12 bf ff bc bne 200de3c <rtems_bdbuf_swapout_task+0x134>
200df50: 01 00 00 00 nop
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
200df54: 7f ff fa d1 call 200ca98 <rtems_bdbuf_lock_cache>
200df58: 01 00 00 00 nop
sync_requester = bdbuf_cache.sync_requester;
200df5c: fa 07 20 34 ld [ %i4 + 0x34 ], %i5
bdbuf_cache.sync_active = false;
200df60: c0 2f 20 30 clrb [ %i4 + 0x30 ]
bdbuf_cache.sync_requester = 0;
rtems_bdbuf_unlock_cache ();
200df64: 7f ff fa e2 call 200caec <rtems_bdbuf_unlock_cache>
200df68: c0 27 20 34 clr [ %i4 + 0x34 ]
if (sync_requester)
200df6c: 80 a7 60 00 cmp %i5, 0
200df70: 22 80 00 23 be,a 200dffc <rtems_bdbuf_swapout_task+0x2f4><== NEVER TAKEN
200df74: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
200df78: 90 10 00 1d mov %i5, %o0
200df7c: 7f ff eb 55 call 2008cd0 <rtems_event_system_send>
200df80: 13 20 00 00 sethi %hi(0x80000000), %o1
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
200df84: 10 80 00 1e b 200dffc <rtems_bdbuf_swapout_task+0x2f4>
200df88: 90 10 20 04 mov 4, %o0
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
200df8c: 80 a0 60 00 cmp %g1, 0
200df90: 02 80 00 1b be 200dffc <rtems_bdbuf_swapout_task+0x2f4>
200df94: 90 10 20 04 mov 4, %o0
200df98: 30 bf ff a9 b,a 200de3c <rtems_bdbuf_swapout_task+0x134>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
200df9c: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
200dfa0: 80 a0 60 00 cmp %g1, 0
200dfa4: 12 bf ff a6 bne 200de3c <rtems_bdbuf_swapout_task+0x134> <== ALWAYS TAKEN
200dfa8: b2 10 20 01 mov 1, %i1
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
200dfac: 7f ff fa bb call 200ca98 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200dfb0: 01 00 00 00 nop <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200dfb4: 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))
200dfb8: 10 80 00 06 b 200dfd0 <rtems_bdbuf_swapout_task+0x2c8> <== NOT EXECUTED
200dfbc: b8 07 20 0c add %i4, 0xc, %i4 <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
200dfc0: c0 2f 60 0c clrb [ %i5 + 0xc ] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
200dfc4: 7f ff e9 a0 call 2008644 <rtems_event_send> <== NOT EXECUTED
200dfc8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200dfcc: 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))
200dfd0: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
200dfd4: 32 bf ff fb bne,a 200dfc0 <rtems_bdbuf_swapout_task+0x2b8><== NOT EXECUTED
200dfd8: 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 ();
200dfdc: 7f ff fa c4 call 200caec <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200dfe0: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
200dfe4: 7f ff da 0e call 200481c <free> <== NOT EXECUTED
200dfe8: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
200dfec: 7f ff eb 98 call 2008e4c <rtems_task_delete> <== NOT EXECUTED
200dff0: 90 10 20 00 clr %o0 <== NOT EXECUTED
200dff4: 81 c7 e0 08 ret <== NOT EXECUTED
200dff8: 81 e8 00 00 restore <== NOT EXECUTED
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
200dffc: 92 10 20 00 clr %o1
200e000: 94 10 00 10 mov %l0, %o2
200e004: 7f ff e9 2e call 20084bc <rtems_event_receive>
200e008: 96 07 bf e4 add %fp, -28, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
200e00c: 80 a2 20 06 cmp %o0, 6
200e010: 22 bf ff e4 be,a 200dfa0 <rtems_bdbuf_swapout_task+0x298>
200e014: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
200e018: 80 a2 20 00 cmp %o0, 0
200e01c: 22 bf ff e1 be,a 200dfa0 <rtems_bdbuf_swapout_task+0x298><== ALWAYS TAKEN
200e020: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
200e024: 10 bf ff 7a b 200de0c <rtems_bdbuf_swapout_task+0x104> <== NOT EXECUTED
200e028: 90 10 20 18 mov 0x18, %o0 <== NOT EXECUTED
0200e02c <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)
{
200e02c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200e030: 3b 00 80 85 sethi %hi(0x2021400), %i5 <== NOT EXECUTED
while (worker->enabled)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
rtems_bdbuf_swapout_write (&worker->transfer);
200e034: b8 06 20 10 add %i0, 0x10, %i4 <== NOT EXECUTED
200e038: ba 17 62 4c or %i5, 0x24c, %i5 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
200e03c: b6 06 20 14 add %i0, 0x14, %i3 <== NOT EXECUTED
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
200e040: 10 80 00 12 b 200e088 <rtems_bdbuf_swapout_worker_task+0x5c><== NOT EXECUTED
200e044: b4 07 60 0c add %i5, 0xc, %i2 <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
200e048: 7f ff fb 00 call 200cc48 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
200e04c: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
200e050: 7f ff fe d6 call 200dba8 <rtems_bdbuf_swapout_write> <== NOT EXECUTED
200e054: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
200e058: 7f ff fa 90 call 200ca98 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200e05c: 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;
200e060: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e064: f6 26 20 10 st %i3, [ %i0 + 0x10 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
200e068: c0 26 20 1c clr [ %i0 + 0x1c ] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200e06c: f4 26 00 00 st %i2, [ %i0 ] <== NOT EXECUTED
tail->previous = the_node;
200e070: f0 27 60 10 st %i0, [ %i5 + 0x10 ] <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
200e074: c0 26 20 14 clr [ %i0 + 0x14 ] <== NOT EXECUTED
tail->previous = head;
200e078: f8 26 20 18 st %i4, [ %i0 + 0x18 ] <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
old_last->next = the_node;
200e07c: f0 20 40 00 st %i0, [ %g1 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
200e080: 7f ff fa 9b call 200caec <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200e084: c2 26 20 04 st %g1, [ %i0 + 4 ] <== NOT EXECUTED
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
200e088: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
200e08c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200e090: 12 bf ff ee bne 200e048 <rtems_bdbuf_swapout_worker_task+0x1c><== NOT EXECUTED
200e094: 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);
200e098: 7f ff d9 e1 call 200481c <free> <== NOT EXECUTED
200e09c: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 <== NOT EXECUTED
free (worker);
200e0a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e0a4: 7f ff d9 de call 200481c <free> <== NOT EXECUTED
200e0a8: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
200e0ac: 7f ff eb 68 call 2008e4c <rtems_task_delete> <== NOT EXECUTED
200e0b0: 81 e8 00 00 restore <== NOT EXECUTED
0200dba8 <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
200dba8: 9d e3 bf a0 save %sp, -96, %sp
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dd->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
200dbac: 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 );
200dbb0: b6 06 20 04 add %i0, 4, %i3
200dbb4: 80 a0 40 1b cmp %g1, %i3
200dbb8: 02 80 00 52 be 200dd00 <rtems_bdbuf_swapout_write+0x158> <== NEVER TAKEN
200dbbc: 84 10 20 0c mov 0xc, %g2
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
200dbc0: fa 06 20 0c ld [ %i0 + 0xc ], %i5
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
200dbc4: c2 07 60 08 ld [ %i5 + 8 ], %g1
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
200dbc8: f4 07 60 2c ld [ %i5 + 0x2c ], %i2
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
200dbcc: f2 00 60 0c ld [ %g1 + 0xc ], %i1
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
200dbd0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
200dbd4: b2 0e 60 01 and %i1, 1, %i1
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
200dbd8: c4 20 60 0c st %g2, [ %g1 + 0xc ]
transfer->write_req->bufnum = 0;
200dbdc: c0 20 60 10 clr [ %g1 + 0x10 ]
{
/*
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
200dbe0: b8 10 20 00 clr %i4
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
200dbe4: a0 10 20 0c mov 0xc, %l0
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
200dbe8: 10 80 00 35 b 200dcbc <rtems_bdbuf_swapout_write+0x114>
200dbec: 23 00 80 7a sethi %hi(0x201e800), %l1
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
200dbf0: 02 80 00 12 be 200dc38 <rtems_bdbuf_swapout_write+0x90>
200dbf4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200dbf8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200dbfc: 80 a0 a0 00 cmp %g2, 0
200dc00: 22 80 00 0f be,a 200dc3c <rtems_bdbuf_swapout_write+0x94>
200dc04: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
200dc08: c6 02 20 18 ld [ %o0 + 0x18 ], %g3
bd->block != last_block + media_blocks_per_block)
200dc0c: 84 07 00 1a add %i4, %i2, %g2
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
200dc10: 80 a0 c0 02 cmp %g3, %g2
200dc14: 22 80 00 0a be,a 200dc3c <rtems_bdbuf_swapout_write+0x94>
200dc18: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200dc1c: c2 06 00 00 ld [ %i0 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200dc20: f0 22 20 04 st %i0, [ %o0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200dc24: d0 26 00 00 st %o0, [ %i0 ]
the_node->next = before_node;
200dc28: c2 22 00 00 st %g1, [ %o0 ]
before_node->previous = the_node;
200dc2c: d0 20 60 04 st %o0, [ %g1 + 4 ]
bd->block != last_block + media_blocks_per_block)
{
rtems_chain_prepend_unprotected (&transfer->bds, &bd->link);
write = true;
200dc30: 10 80 00 10 b 200dc70 <rtems_bdbuf_swapout_write+0xc8>
200dc34: 82 10 20 01 mov 1, %g1
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200dc38: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
200dc3c: f8 02 20 18 ld [ %o0 + 0x18 ], %i4
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200dc40: 87 29 20 04 sll %g4, 4, %g3
transfer->write_req->bufnum++;
200dc44: 88 01 20 01 inc %g4
200dc48: c8 20 60 10 st %g4, [ %g1 + 0x10 ]
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200dc4c: 86 00 e0 18 add %g3, 0x18, %g3
200dc50: 84 00 40 03 add %g1, %g3, %g2
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
200dc54: f8 20 40 03 st %i4, [ %g1 + %g3 ]
buf->length = dd->block_size;
200dc58: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
200dc5c: d0 20 a0 0c st %o0, [ %g2 + 0xc ]
buf->block = bd->block;
buf->length = dd->block_size;
200dc60: c2 20 a0 04 st %g1, [ %g2 + 4 ]
buf->buffer = bd->buffer;
200dc64: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
200dc68: c2 20 a0 08 st %g1, [ %g2 + 8 ]
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
200dc6c: 82 10 20 00 clr %g1
/*
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
200dc70: c4 06 00 00 ld [ %i0 ], %g2
200dc74: 80 a0 80 1b cmp %g2, %i3
200dc78: 02 80 00 0b be 200dca4 <rtems_bdbuf_swapout_write+0xfc>
200dc7c: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
200dc80: 84 14 63 f8 or %l1, 0x3f8, %g2
/*
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
200dc84: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
200dc88: c4 00 a0 04 ld [ %g2 + 4 ], %g2
200dc8c: 80 a0 c0 02 cmp %g3, %g2
200dc90: 1a 80 00 06 bcc 200dca8 <rtems_bdbuf_swapout_write+0x100>
200dc94: 90 10 00 1d mov %i5, %o0
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
200dc98: 80 88 60 ff btst 0xff, %g1
200dc9c: 02 80 00 08 be 200dcbc <rtems_bdbuf_swapout_write+0x114>
200dca0: 01 00 00 00 nop
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
200dca4: 90 10 00 1d mov %i5, %o0
200dca8: 7f ff ff 54 call 200d9f8 <rtems_bdbuf_execute_transfer_request>
200dcac: 94 10 20 00 clr %o2
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
200dcb0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200dcb4: e0 20 60 0c st %l0, [ %g1 + 0xc ]
transfer->write_req->bufnum = 0;
200dcb8: c0 20 60 10 clr [ %g1 + 0x10 ]
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get_unprotected(
rtems_chain_control *the_chain
)
{
return _Chain_Get_unprotected( the_chain );
200dcbc: 7f ff fb 52 call 200ca04 <_Chain_Get_unprotected>
200dcc0: 90 10 00 18 mov %i0, %o0
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
200dcc4: 80 a2 20 00 cmp %o0, 0
200dcc8: 12 bf ff ca bne 200dbf0 <rtems_bdbuf_swapout_write+0x48>
200dccc: 80 a6 60 00 cmp %i1, 0
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
200dcd0: c2 0e 20 10 ldub [ %i0 + 0x10 ], %g1
200dcd4: 80 a0 60 00 cmp %g1, 0
200dcd8: 02 80 00 0a be 200dd00 <rtems_bdbuf_swapout_write+0x158>
200dcdc: 01 00 00 00 nop
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
200dce0: d0 07 60 08 ld [ %i5 + 8 ], %o0
200dce4: 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 &&
200dce8: 80 88 60 02 btst 2, %g1
200dcec: 02 80 00 05 be 200dd00 <rtems_bdbuf_swapout_write+0x158> <== ALWAYS TAKEN
200dcf0: 92 10 20 02 mov 2, %o1
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
200dcf4: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
200dcf8: 9f c0 40 00 call %g1 <== NOT EXECUTED
200dcfc: 94 10 20 00 clr %o2 <== NOT EXECUTED
200dd00: 81 c7 e0 08 ret
200dd04: 81 e8 00 00 restore
0200cc8c <rtems_bdbuf_swapout_writereq_alloc>:
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
200cc8c: 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)));
200cc90: 03 00 80 7a sethi %hi(0x201e800), %g1
200cc94: d0 00 63 fc ld [ %g1 + 0x3fc ], %o0 ! 201ebfc <rtems_bdbuf_configuration+0x4>
200cc98: 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 =
200cc9c: 7f ff e0 21 call 2004d20 <malloc>
200cca0: 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)
200cca4: b0 92 20 00 orcc %o0, 0, %i0
200cca8: 12 80 00 04 bne 200ccb8 <rtems_bdbuf_swapout_writereq_alloc+0x2c><== ALWAYS TAKEN
200ccac: 82 10 20 01 mov 1, %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);
200ccb0: 7f ff ff 69 call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ccb4: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
200ccb8: c2 26 00 00 st %g1, [ %i0 ]
write_req->done = rtems_bdbuf_transfer_done;
200ccbc: 03 00 80 36 sethi %hi(0x200d800), %g1
200ccc0: 82 10 61 e0 or %g1, 0x1e0, %g1 ! 200d9e0 <rtems_bdbuf_transfer_done>
write_req->io_task = rtems_task_self ();
200ccc4: 40 00 11 6c call 2011274 <rtems_task_self>
200ccc8: c2 26 20 04 st %g1, [ %i0 + 4 ]
200cccc: d0 26 20 14 st %o0, [ %i0 + 0x14 ]
return write_req;
}
200ccd0: 81 c7 e0 08 ret
200ccd4: 81 e8 00 00 restore
0200eb94 <rtems_bdbuf_sync>:
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
200eb94: 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)
200eb98: 80 a6 20 00 cmp %i0, 0
200eb9c: 02 80 00 49 be 200ecc0 <rtems_bdbuf_sync+0x12c> <== NEVER TAKEN
200eba0: 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();
200eba4: 7f ff f7 bd call 200ca98 <rtems_bdbuf_lock_cache>
200eba8: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200ebac: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200ebb0: 80 a2 20 03 cmp %o0, 3
200ebb4: 0a 80 00 3d bcs 200eca8 <rtems_bdbuf_sync+0x114> <== NEVER TAKEN
200ebb8: 92 10 20 11 mov 0x11, %o1
200ebbc: 80 a2 20 05 cmp %o0, 5
200ebc0: 08 80 00 06 bleu 200ebd8 <rtems_bdbuf_sync+0x44>
200ebc4: 82 10 20 08 mov 8, %g1
200ebc8: 80 a2 20 06 cmp %o0, 6
200ebcc: 12 80 00 37 bne 200eca8 <rtems_bdbuf_sync+0x114> <== NEVER TAKEN
200ebd0: 01 00 00 00 nop
200ebd4: 30 80 00 32 b,a 200ec9c <rtems_bdbuf_sync+0x108>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200ebd8: 11 00 80 85 sethi %hi(0x2021400), %o0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ebdc: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
200ebe0: 90 12 22 4c or %o0, 0x24c, %o0
200ebe4: c2 02 20 60 ld [ %o0 + 0x60 ], %g1
the_node->next = tail;
200ebe8: 84 02 20 5c add %o0, 0x5c, %g2
tail->previous = the_node;
200ebec: f0 22 20 60 st %i0, [ %o0 + 0x60 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200ebf0: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
200ebf4: f0 20 40 00 st %i0, [ %g1 ]
the_node->previous = old_last;
200ebf8: c2 26 20 04 st %g1, [ %i0 + 4 ]
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
200ebfc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200ec00: 80 a0 60 00 cmp %g1, 0
200ec04: 02 80 00 04 be 200ec14 <rtems_bdbuf_sync+0x80>
200ec08: 01 00 00 00 nop
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
200ec0c: 7f ff f8 4c call 200cd3c <rtems_bdbuf_wake>
200ec10: 90 02 20 64 add %o0, 0x64, %o0
rtems_bdbuf_wake_swapper ();
200ec14: 7f ff f7 bc call 200cb04 <rtems_bdbuf_wake_swapper>
200ec18: 3b 00 80 85 sethi %hi(0x2021400), %i5
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
return;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
200ec1c: ba 17 62 b8 or %i5, 0x2b8, %i5 ! 20216b8 <bdbuf_cache+0x6c>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200ec20: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200ec24: 80 a2 20 01 cmp %o0, 1
200ec28: 0a 80 00 20 bcs 200eca8 <rtems_bdbuf_sync+0x114> <== NEVER TAKEN
200ec2c: 92 10 20 15 mov 0x15, %o1
200ec30: 80 a2 20 07 cmp %o0, 7
200ec34: 28 80 00 0a bleu,a 200ec5c <rtems_bdbuf_sync+0xc8>
200ec38: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200ec3c: 80 a2 20 0a cmp %o0, 0xa
200ec40: 18 80 00 1a bgu 200eca8 <rtems_bdbuf_sync+0x114> <== NEVER TAKEN
200ec44: 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);
200ec48: 90 10 00 18 mov %i0, %o0
200ec4c: 7f ff f7 f2 call 200cc14 <rtems_bdbuf_wait>
200ec50: 92 10 00 1d mov %i5, %o1
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200ec54: 10 bf ff f4 b 200ec24 <rtems_bdbuf_sync+0x90>
200ec58: 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
200ec5c: 80 a0 60 00 cmp %g1, 0
200ec60: 12 80 00 14 bne 200ecb0 <rtems_bdbuf_sync+0x11c>
200ec64: 82 02 3f ff add %o0, -1, %g1
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
200ec68: 80 a0 60 01 cmp %g1, 1
200ec6c: 18 80 00 11 bgu 200ecb0 <rtems_bdbuf_sync+0x11c> <== NEVER TAKEN
200ec70: 80 a2 20 01 cmp %o0, 1
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
200ec74: 32 80 00 07 bne,a 200ec90 <rtems_bdbuf_sync+0xfc>
200ec78: 11 00 80 85 sethi %hi(0x2021400), %o0
{
rtems_bdbuf_remove_from_tree (bd);
200ec7c: 7f ff f8 55 call 200cdd0 <rtems_bdbuf_remove_from_tree>
200ec80: 90 10 00 18 mov %i0, %o0
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
200ec84: 7f ff f9 39 call 200d168 <rtems_bdbuf_make_free_and_add_to_lru_list>
200ec88: 90 10 00 18 mov %i0, %o0
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200ec8c: 11 00 80 85 sethi %hi(0x2021400), %o0
200ec90: 7f ff f8 2b call 200cd3c <rtems_bdbuf_wake>
200ec94: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 20216c0 <bdbuf_cache+0x74>
200ec98: 30 80 00 06 b,a 200ecb0 <rtems_bdbuf_sync+0x11c>
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);
200ec9c: 7f ff fd 96 call 200e2f4 <rtems_bdbuf_discard_buffer_after_access>
200eca0: 90 10 00 18 mov %i0, %o0
break;
200eca4: 30 80 00 03 b,a 200ecb0 <rtems_bdbuf_sync+0x11c>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);
200eca8: 7f ff f7 82 call 200cab0 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
200ecac: 01 00 00 00 nop <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200ecb0: 7f ff f7 8f call 200caec <rtems_bdbuf_unlock_cache>
200ecb4: b0 10 20 00 clr %i0 ! 0 <PROM_START>
return RTEMS_SUCCESSFUL;
200ecb8: 81 c7 e0 08 ret
200ecbc: 81 e8 00 00 restore
}
200ecc0: 81 c7 e0 08 ret <== NOT EXECUTED
200ecc4: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
0200cac4 <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)
{
200cac4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_release (lock);
200cac8: 7f ff f0 55 call 2008c1c <rtems_semaphore_release>
200cacc: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL)
200cad0: 80 a2 20 00 cmp %o0, 0
200cad4: 02 80 00 04 be 200cae4 <rtems_bdbuf_unlock+0x20> <== ALWAYS TAKEN
200cad8: 01 00 00 00 nop
rtems_bdbuf_fatal (fatal_error_code);
200cadc: 7f ff ff de call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200cae0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
200cae4: 81 c7 e0 08 ret
200cae8: 81 e8 00 00 restore
0200cc48 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
200cc48: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
200cc4c: 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;
200cc50: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_event_receive (event,
200cc54: 90 10 00 18 mov %i0, %o0
200cc58: 94 10 20 00 clr %o2
200cc5c: 7f ff ee 18 call 20084bc <rtems_event_receive>
200cc60: 96 07 bf fc add %fp, -4, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
200cc64: 80 a2 20 00 cmp %o0, 0
200cc68: 12 80 00 05 bne 200cc7c <rtems_bdbuf_wait_for_event+0x34> <== NEVER TAKEN
200cc6c: c2 07 bf fc ld [ %fp + -4 ], %g1
200cc70: 80 a0 40 18 cmp %g1, %i0
200cc74: 02 80 00 04 be 200cc84 <rtems_bdbuf_wait_for_event+0x3c> <== ALWAYS TAKEN
200cc78: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
200cc7c: 7f ff ff 76 call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200cc80: 90 10 20 1c mov 0x1c, %o0 ! 1c <PROM_START+0x1c> <== NOT EXECUTED
200cc84: 81 c7 e0 08 ret
200cc88: 81 e8 00 00 restore
0200d134 <rtems_bdbuf_wait_for_transient_event>:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
}
static void
rtems_bdbuf_wait_for_transient_event (void)
{
200d134: 9d e3 bf 98 save %sp, -104, %sp
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
200d138: 11 20 00 00 sethi %hi(0x80000000), %o0
200d13c: 92 10 20 00 clr %o1
200d140: 94 10 20 00 clr %o2
200d144: 40 00 0f cc call 2011074 <rtems_event_system_receive>
200d148: 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)
200d14c: 80 a2 20 00 cmp %o0, 0
200d150: 02 80 00 04 be 200d160 <rtems_bdbuf_wait_for_transient_event+0x2c><== ALWAYS TAKEN
200d154: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);
200d158: 7f ff fe 3f call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d15c: 90 10 20 1d mov 0x1d, %o0 ! 1d <PROM_START+0x1d> <== NOT EXECUTED
200d160: 81 c7 e0 08 ret
200d164: 81 e8 00 00 restore
0200cd3c <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)
{
200cd3c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
200cd40: c2 06 00 00 ld [ %i0 ], %g1
200cd44: 80 a0 60 00 cmp %g1, 0
200cd48: 02 80 00 09 be 200cd6c <rtems_bdbuf_wake+0x30>
200cd4c: 01 00 00 00 nop
{
sc = rtems_semaphore_flush (waiters->sema);
200cd50: 40 00 10 9f call 2010fcc <rtems_semaphore_flush>
200cd54: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
200cd58: 80 a2 20 00 cmp %o0, 0
200cd5c: 02 80 00 04 be 200cd6c <rtems_bdbuf_wake+0x30> <== ALWAYS TAKEN
200cd60: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAKE);
200cd64: 7f ff ff 3c call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200cd68: 90 10 20 04 mov 4, %o0 ! 4 <PROM_START+0x4> <== NOT EXECUTED
200cd6c: 81 c7 e0 08 ret
200cd70: 81 e8 00 00 restore
0200cb04 <rtems_bdbuf_wake_swapper>:
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
200cb04: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
200cb08: 03 00 80 85 sethi %hi(0x2021400), %g1
200cb0c: d0 00 62 4c ld [ %g1 + 0x24c ], %o0 ! 202164c <bdbuf_cache>
200cb10: 7f ff ee cd call 2008644 <rtems_event_send>
200cb14: 92 10 20 04 mov 4, %o1
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
200cb18: 80 a2 20 00 cmp %o0, 0
200cb1c: 02 80 00 04 be 200cb2c <rtems_bdbuf_wake_swapper+0x28> <== ALWAYS TAKEN
200cb20: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);
200cb24: 7f ff ff cc call 200ca54 <rtems_bdbuf_fatal> <== NOT EXECUTED
200cb28: 90 10 20 0b mov 0xb, %o0 ! b <PROM_START+0xb> <== NOT EXECUTED
200cb2c: 81 c7 e0 08 ret
200cb30: 81 e8 00 00 restore
02002e04 <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
2002e04: 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;
2002e08: 80 a6 60 00 cmp %i1, 0
2002e0c: 02 80 00 08 be 2002e2c <rtems_bdpart_create+0x28> <== NEVER TAKEN
2002e10: 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
2002e14: c2 06 40 00 ld [ %i1 ], %g1
2002e18: 80 a0 60 00 cmp %g1, 0
2002e1c: 12 80 00 05 bne 2002e30 <rtems_bdpart_create+0x2c> <== NEVER TAKEN
2002e20: a0 10 20 00 clr %l0
&& format->mbr.dos_compatibility;
2002e24: 10 80 00 03 b 2002e30 <rtems_bdpart_create+0x2c>
2002e28: e0 0e 60 08 ldub [ %i1 + 8 ], %l0
2002e2c: a0 10 20 00 clr %l0 <== NOT EXECUTED
const unsigned *dist,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
2002e30: a0 0c 20 01 and %l0, 1, %l0
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
2002e34: c0 27 bf fc clr [ %fp + -4 ]
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
2002e38: 82 0c 20 ff and %l0, 0xff, %g1
2002e3c: 80 a0 00 01 cmp %g0, %g1
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
2002e40: b0 10 20 00 clr %i0
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
2002e44: ba 40 3f ff addx %g0, -1, %i5
rtems_blkdev_bnum overhead = 0;
rtems_blkdev_bnum free_space = 0;
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
2002e48: 80 a7 20 00 cmp %i4, 0
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
2002e4c: ba 0f 7f c2 and %i5, -62, %i5
rtems_blkdev_bnum overhead = 0;
rtems_blkdev_bnum free_space = 0;
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
2002e50: 02 80 00 70 be 2003010 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2002e54: ba 07 60 3f add %i5, 0x3f, %i5
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
2002e58: 80 a6 a0 00 cmp %i2, 0
2002e5c: 02 80 00 6d be 2003010 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2002e60: b0 10 20 09 mov 9, %i0
2002e64: 80 a6 60 00 cmp %i1, 0
2002e68: 02 80 00 6a be 2003010 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2002e6c: 80 a6 e0 00 cmp %i3, 0
2002e70: 02 80 00 68 be 2003010 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2002e74: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end);
2002e78: 94 10 20 00 clr %o2
2002e7c: 40 00 01 2a call 2003324 <rtems_bdpart_get_disk_data>
2002e80: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL) {
2002e84: b0 92 20 00 orcc %o0, 0, %i0
2002e88: 12 80 00 62 bne 2003010 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2002e8c: 82 10 20 00 clr %g1
2002e90: 84 10 20 00 clr %g2
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
2002e94: 87 28 60 02 sll %g1, 2, %g3
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
2002e98: c6 06 c0 03 ld [ %i3 + %g3 ], %g3
2002e9c: a8 00 c0 02 add %g3, %g2, %l4
if (dist_sum < prev_sum) {
2002ea0: 80 a5 00 02 cmp %l4, %g2
2002ea4: 1a 80 00 04 bcc 2002eb4 <rtems_bdpart_create+0xb0> <== ALWAYS TAKEN
2002ea8: 80 a0 e0 00 cmp %g3, 0
return RTEMS_INVALID_NUMBER;
2002eac: 81 c7 e0 08 ret <== NOT EXECUTED
2002eb0: 91 e8 20 0a restore %g0, 0xa, %o0 <== NOT EXECUTED
}
if (dist [i] == 0) {
2002eb4: 02 bf ff fe be 2002eac <rtems_bdpart_create+0xa8> <== NEVER TAKEN
2002eb8: 82 00 60 01 inc %g1
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
2002ebc: 80 a0 40 1c cmp %g1, %i4
2002ec0: 12 bf ff f5 bne 2002e94 <rtems_bdpart_create+0x90>
2002ec4: 84 10 00 14 mov %l4, %g2
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
2002ec8: c2 06 40 00 ld [ %i1 ], %g1
2002ecc: 80 a0 60 00 cmp %g1, 0
2002ed0: 12 80 00 52 bne 2003018 <rtems_bdpart_create+0x214> <== NEVER TAKEN
2002ed4: 80 8c 20 ff btst 0xff, %l0
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
2002ed8: 02 80 00 09 be 2002efc <rtems_bdpart_create+0xf8> <== NEVER TAKEN
2002edc: 80 a7 20 04 cmp %i4, 4
disk_end -= (disk_end % record_space);
2002ee0: f2 07 bf fc ld [ %fp + -4 ], %i1
2002ee4: 92 10 00 1d mov %i5, %o1
2002ee8: 40 00 7b 46 call 2021c00 <.urem>
2002eec: 90 10 00 19 mov %i1, %o0
2002ef0: 90 26 40 08 sub %i1, %o0, %o0
2002ef4: d0 27 bf fc st %o0, [ %fp + -4 ]
/*
* In case we need an extended partition and logical partitions we have to
* account for the space of each EBR.
*/
if (count > 4) {
2002ef8: 80 a7 20 04 cmp %i4, 4
2002efc: 08 80 00 06 bleu 2002f14 <rtems_bdpart_create+0x110> <== NEVER TAKEN
2002f00: b2 10 00 1d mov %i5, %i1
overhead += (count - 3) * record_space;
2002f04: 90 10 00 1d mov %i5, %o0
2002f08: 40 00 7a 58 call 2021868 <.umul>
2002f0c: 92 07 3f fd add %i4, -3, %o1
2002f10: b2 02 00 1d add %o0, %i5, %i1
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
2002f14: 80 8c 20 ff btst 0xff, %l0
2002f18: 02 80 00 07 be 2002f34 <rtems_bdpart_create+0x130> <== NEVER TAKEN
2002f1c: e6 07 bf fc ld [ %fp + -4 ], %l3
overhead += (count - 1) * record_space;
2002f20: 90 10 00 1d mov %i5, %o0
2002f24: 40 00 7a 51 call 2021868 <.umul>
2002f28: 92 07 3f ff add %i4, -1, %o1
2002f2c: b2 06 40 08 add %i1, %o0, %i1
}
/* Check disk space */
if ((overhead + count) > disk_end) {
2002f30: e6 07 bf fc ld [ %fp + -4 ], %l3
2002f34: 82 06 40 1c add %i1, %i4, %g1
2002f38: 80 a0 40 13 cmp %g1, %l3
2002f3c: 38 80 00 35 bgu,a 2003010 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2002f40: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
/* Begin of first primary partition */
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
2002f44: aa 24 c0 19 sub %l3, %i1, %l5
2002f48: a2 10 00 1a mov %i2, %l1
if ((overhead + count) > disk_end) {
return RTEMS_IO_ERROR;
}
/* Begin of first primary partition */
pos = record_space;
2002f4c: a0 10 00 1d mov %i5, %l0
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
2002f50: b2 10 20 00 clr %i1
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
2002f54: 83 2e 60 02 sll %i1, 2, %g1
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
2002f58: e4 06 c0 01 ld [ %i3 + %g1 ], %l2
2002f5c: 92 10 00 15 mov %l5, %o1
2002f60: 40 00 7a 42 call 2021868 <.umul>
2002f64: 90 10 00 12 mov %l2, %o0
if (s < free_space || s < dist [i]) {
2002f68: 80 a2 00 15 cmp %o0, %l5
2002f6c: 0a bf ff d0 bcs 2002eac <rtems_bdpart_create+0xa8> <== NEVER TAKEN
2002f70: 80 a2 00 12 cmp %o0, %l2
2002f74: 0a bf ff ce bcs 2002eac <rtems_bdpart_create+0xa8> <== NEVER TAKEN
2002f78: 01 00 00 00 nop
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
2002f7c: 40 00 7a 75 call 2021950 <.udiv>
2002f80: 92 10 00 14 mov %l4, %o1
/* Ensure that the partition is not empty */
if (s == 0) {
2002f84: a4 92 20 00 orcc %o0, 0, %l2
2002f88: 22 80 00 02 be,a 2002f90 <rtems_bdpart_create+0x18c> <== NEVER TAKEN
2002f8c: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
2002f90: 90 10 00 12 mov %l2, %o0
2002f94: 40 00 7b 1b call 2021c00 <.urem>
2002f98: 92 10 00 1d mov %i5, %o1
2002f9c: a4 04 80 1d add %l2, %i5, %l2
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
2002fa0: 82 10 20 01 mov 1, %g1
2002fa4: 80 a6 60 02 cmp %i1, 2
2002fa8: 18 80 00 03 bgu 2002fb4 <rtems_bdpart_create+0x1b0>
2002fac: 90 24 80 08 sub %l2, %o0, %o0
2002fb0: 82 10 20 00 clr %g1
2002fb4: 80 88 60 ff btst 0xff, %g1
2002fb8: 22 80 00 0a be,a 2002fe0 <rtems_bdpart_create+0x1dc>
2002fbc: e0 24 40 00 st %l0, [ %l1 ]
2002fc0: 80 a7 20 04 cmp %i4, 4
2002fc4: 18 80 00 03 bgu 2002fd0 <rtems_bdpart_create+0x1cc> <== ALWAYS TAKEN
2002fc8: 82 10 20 01 mov 1, %g1
2002fcc: 82 10 20 00 clr %g1 <== NOT EXECUTED
2002fd0: 80 88 60 ff btst 0xff, %g1
2002fd4: 32 80 00 02 bne,a 2002fdc <rtems_bdpart_create+0x1d8> <== ALWAYS TAKEN
2002fd8: a0 04 00 1d add %l0, %i5, %l0
pos += record_space;
}
/* Partition begin and end */
p->begin = pos;
2002fdc: e0 24 40 00 st %l0, [ %l1 ]
pos += s;
2002fe0: a0 04 00 08 add %l0, %o0, %l0
p->end = pos;
2002fe4: e0 24 60 04 st %l0, [ %l1 + 4 ]
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
2002fe8: b2 06 60 01 inc %i1
2002fec: 80 a6 40 1c cmp %i1, %i4
2002ff0: 12 bf ff d9 bne 2002f54 <rtems_bdpart_create+0x150>
2002ff4: a2 04 60 30 add %l1, 0x30, %l1
pos += s;
p->end = pos;
}
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
2002ff8: b2 06 7f ff add %i1, -1, %i1
2002ffc: 83 2e 60 04 sll %i1, 4, %g1
2003000: b3 2e 60 06 sll %i1, 6, %i1
2003004: b2 26 40 01 sub %i1, %g1, %i1
2003008: b4 06 80 19 add %i2, %i1, %i2
200300c: e6 26 a0 04 st %l3, [ %i2 + 4 ]
2003010: 81 c7 e0 08 ret
2003014: 81 e8 00 00 restore
2003018: b0 10 20 18 mov 0x18, %i0 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
200301c: 81 c7 e0 08 ret <== NOT EXECUTED
2003020: 81 e8 00 00 restore <== NOT EXECUTED
02003024 <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
2003024: 9d e3 bf 60 save %sp, -160, %sp
size_t i = 0;
printf(
2003028: 11 00 80 90 sethi %hi(0x2024000), %o0
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
200302c: 35 00 80 90 sethi %hi(0x2024000), %i2
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
size_t i = 0;
printf(
2003030: 90 12 21 90 or %o0, 0x190, %o0
2003034: 40 00 4a 55 call 2015988 <puts>
2003038: 27 00 80 90 sethi %hi(0x2024000), %l3
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
200303c: 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";
2003040: 37 00 80 90 sethi %hi(0x2024000), %i3
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
2003044: b4 16 a2 d0 or %i2, 0x2d0, %i2
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
2003048: 21 00 80 90 sethi %hi(0x2024000), %l0
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
200304c: 23 00 80 90 sethi %hi(0x2024000), %l1
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
2003050: 25 00 80 90 sethi %hi(0x2024000), %l2
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2003054: 10 80 00 39 b 2003138 <rtems_bdpart_dump+0x114>
2003058: a6 14 e2 d8 or %l3, 0x2d8, %l3
const rtems_bdpart_partition *p = pt + i;
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
200305c: b8 06 20 08 add %i0, 8, %i4
2003060: 92 07 bf c7 add %fp, -57, %o1
2003064: 40 00 00 a4 call 20032f4 <rtems_bdpart_to_mbr_partition_type>
2003068: 90 10 00 1c mov %i4, %o0
200306c: 80 8a 20 ff btst 0xff, %o0
2003070: 22 80 00 27 be,a 200310c <rtems_bdpart_dump+0xe8> <== NEVER TAKEN
2003074: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
switch (type_mbr) {
2003078: d6 0f bf c7 ldub [ %fp + -57 ], %o3
200307c: 82 0a e0 ff and %o3, 0xff, %g1
2003080: 80 a0 60 0b cmp %g1, 0xb
2003084: 22 80 00 27 be,a 2003120 <rtems_bdpart_dump+0xfc> <== ALWAYS TAKEN
2003088: 96 16 e1 78 or %i3, 0x178, %o3
200308c: 18 80 00 09 bgu 20030b0 <rtems_bdpart_dump+0x8c> <== NOT EXECUTED
2003090: 80 a0 60 0e cmp %g1, 0xe <== NOT EXECUTED
2003094: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
2003098: 02 80 00 0e be 20030d0 <rtems_bdpart_dump+0xac> <== NOT EXECUTED
200309c: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
20030a0: 12 80 00 15 bne 20030f4 <rtems_bdpart_dump+0xd0> <== NOT EXECUTED
20030a4: 90 07 bf c8 add %fp, -56, %o0 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
20030a8: 10 80 00 1d b 200311c <rtems_bdpart_dump+0xf8> <== NOT EXECUTED
20030ac: 17 00 80 90 sethi %hi(0x2024000), %o3 <== NOT EXECUTED
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
20030b0: 02 80 00 0b be 20030dc <rtems_bdpart_dump+0xb8> <== NOT EXECUTED
20030b4: 80 a0 60 da cmp %g1, 0xda <== NOT EXECUTED
20030b8: 02 80 00 0d be 20030ec <rtems_bdpart_dump+0xc8> <== NOT EXECUTED
20030bc: 80 a0 60 0c cmp %g1, 0xc <== NOT EXECUTED
20030c0: 12 80 00 0d bne 20030f4 <rtems_bdpart_dump+0xd0> <== NOT EXECUTED
20030c4: 90 07 bf c8 add %fp, -56, %o0 <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
20030c8: 10 80 00 07 b 20030e4 <rtems_bdpart_dump+0xc0> <== NOT EXECUTED
20030cc: 96 14 a1 68 or %l2, 0x168, %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";
20030d0: 17 00 80 90 sethi %hi(0x2024000), %o3 <== NOT EXECUTED
20030d4: 10 80 00 13 b 2003120 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
20030d8: 96 12 e1 58 or %o3, 0x158, %o3 ! 2024158 <Configuration_Initial_Extensions+0x4d8><== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
break;
20030dc: 10 80 00 11 b 2003120 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
20030e0: 96 14 21 80 or %l0, 0x180, %o3 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
20030e4: 10 80 00 10 b 2003124 <rtems_bdpart_dump+0x100> <== NOT EXECUTED
20030e8: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
20030ec: 10 80 00 0d b 2003120 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
20030f0: 96 14 61 60 or %l1, 0x160, %o3 <== NOT EXECUTED
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
20030f4: 92 10 20 34 mov 0x34, %o1 <== NOT EXECUTED
20030f8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
20030fc: 40 00 4a dc call 2015c6c <snprintf> <== NOT EXECUTED
2003100: 96 0a e0 ff and %o3, 0xff, %o3 <== NOT EXECUTED
type = type_buffer;
break;
}
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
2003104: 10 80 00 07 b 2003120 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
2003108: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
static void rtems_bdpart_type_to_string(
const uuid_t type,
char str [37]
)
{
uuid_unparse_lower( type, str);
200310c: 40 00 2b 47 call 200de28 <uuid_unparse_lower> <== NOT EXECUTED
2003110: 92 07 bf c8 add %fp, -56, %o1 <== NOT EXECUTED
type = type_buffer;
break;
}
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
2003114: 10 80 00 03 b 2003120 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
2003118: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
switch (type_mbr) {
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
200311c: 96 12 e1 50 or %o3, 0x150, %o3 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
2003120: d2 06 00 00 ld [ %i0 ], %o1
2003124: d4 06 20 04 ld [ %i0 + 4 ], %o2
2003128: 90 10 00 13 mov %l3, %o0
200312c: 40 00 49 e1 call 20158b0 <printf>
2003130: ba 07 60 01 inc %i5
2003134: b0 06 20 30 add %i0, 0x30, %i0
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2003138: 80 a7 40 19 cmp %i5, %i1
200313c: 32 bf ff c8 bne,a 200305c <rtems_bdpart_dump+0x38>
2003140: c0 2f bf c7 clrb [ %fp + -57 ]
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
2003144: 11 00 80 90 sethi %hi(0x2024000), %o0
2003148: 40 00 4a 10 call 2015988 <puts>
200314c: 90 12 22 80 or %o0, 0x280, %o0 ! 2024280 <Configuration_Initial_Extensions+0x600>
2003150: 81 c7 e0 08 ret
2003154: 81 e8 00 00 restore
02003324 <rtems_bdpart_get_disk_data>:
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
2003324: 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);
2003328: 92 10 20 02 mov 2, %o1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rv = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
200332c: 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);
2003330: 40 00 0d 12 call 2006778 <open>
2003334: 90 10 00 18 mov %i0, %o0
if (fd < 0) {
2003338: ba 92 20 00 orcc %o0, 0, %i5
200333c: 36 80 00 04 bge,a 200334c <rtems_bdpart_get_disk_data+0x28><== ALWAYS TAKEN
2003340: 13 10 01 10 sethi %hi(0x40044000), %o1
sc = RTEMS_INVALID_NAME;
2003344: 10 80 00 12 b 200338c <rtems_bdpart_get_disk_data+0x68> <== NOT EXECUTED
2003348: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
200334c: 94 07 bf fc add %fp, -4, %o2
2003350: 40 00 09 cb call 2005a7c <ioctl>
2003354: 92 12 62 09 or %o1, 0x209, %o1
goto error;
}
/* Get disk handle */
rv = rtems_disk_fd_get_disk_device( fd, &dd);
if (rv != 0) {
2003358: 80 a2 20 00 cmp %o0, 0
200335c: 32 80 00 0c bne,a 200338c <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
2003360: 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;
2003364: c2 07 bf fc ld [ %fp + -4 ], %g1
*disk_end = dd->size;
2003368: c4 18 60 18 ldd [ %g1 + 0x18 ], %g2
200336c: c6 26 c0 00 st %g3, [ %i3 ]
block_size = dd->block_size;
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
2003370: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
2003374: 80 a0 61 ff cmp %g1, 0x1ff
2003378: 08 80 00 05 bleu 200338c <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
200337c: b0 10 20 1b mov 0x1b, %i0
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
2003380: 80 a0 00 02 cmp %g0, %g2
2003384: b0 60 20 00 subx %g0, 0, %i0
2003388: b0 0e 20 1b and %i0, 0x1b, %i0
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
200338c: 80 a6 20 00 cmp %i0, 0
2003390: 12 80 00 0a bne 20033b8 <rtems_bdpart_get_disk_data+0x94> <== NEVER TAKEN
2003394: 80 a6 60 00 cmp %i1, 0
2003398: 02 80 00 08 be 20033b8 <rtems_bdpart_get_disk_data+0x94>
200339c: 80 a6 a0 00 cmp %i2, 0
20033a0: 02 80 00 06 be 20033b8 <rtems_bdpart_get_disk_data+0x94> <== NEVER TAKEN
20033a4: c2 07 bf fc ld [ %fp + -4 ], %g1
*fd_ptr = fd;
20033a8: fa 26 40 00 st %i5, [ %i1 ]
*dd_ptr = dd;
20033ac: c2 26 80 00 st %g1, [ %i2 ]
20033b0: 81 c7 e0 08 ret
20033b4: 81 e8 00 00 restore
} else {
close( fd);
20033b8: 40 00 08 77 call 2005594 <close>
20033bc: 90 10 00 1d mov %i5, %o0
}
return sc;
}
20033c0: 81 c7 e0 08 ret
20033c4: 81 e8 00 00 restore
0202152c <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
202152c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
2021530: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
2021534: 40 00 75 5f call 203eab0 <strrchr> <== NOT EXECUTED
2021538: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
202153c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
char *logical_disk_name = NULL;
char *logical_disk_marker = NULL;
char *mount_point = NULL;
char *mount_marker = NULL;
size_t disk_file_name_size = 0;
size_t disk_name_size = strlen( disk_name);
2021540: 40 00 71 39 call 203da24 <strlen> <== NOT EXECUTED
2021544: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2021548: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
202154c: 40 00 71 36 call 203da24 <strlen> <== NOT EXECUTED
2021550: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
2021554: b8 10 20 1a mov 0x1a, %i4 <== NOT EXECUTED
char *logical_disk_marker = NULL;
char *mount_point = NULL;
char *mount_marker = NULL;
size_t disk_file_name_size = 0;
size_t disk_name_size = strlen( disk_name);
size_t mount_base_size = strlen( mount_base);
2021558: 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);
202155c: 7f ff 88 4c call 200368c <malloc> <== NOT EXECUTED
2021560: 90 04 20 04 add %l0, 4, %o0 <== NOT EXECUTED
if (logical_disk_name == NULL) {
2021564: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021568: 02 80 00 4d be 202169c <rtems_bdpart_mount+0x170> <== NOT EXECUTED
202156c: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
2021570: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2021574: 40 00 71 e8 call 203dd14 <strncpy> <== NOT EXECUTED
2021578: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
202157c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2021580: 22 80 00 06 be,a 2021598 <rtems_bdpart_mount+0x6c> <== NOT EXECUTED
2021584: a4 10 00 10 mov %l0, %l2 <== NOT EXECUTED
disk_file_name += 1;
2021588: b0 07 60 01 add %i5, 1, %i0 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
202158c: 40 00 71 26 call 203da24 <strlen> <== NOT EXECUTED
2021590: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2021594: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
2021598: a6 04 80 11 add %l2, %l1, %l3 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
202159c: b8 10 20 1a mov 0x1a, %i4 <== NOT EXECUTED
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
20215a0: 7f ff 88 3b call 200368c <malloc> <== NOT EXECUTED
20215a4: 90 04 e0 05 add %l3, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
20215a8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20215ac: 02 80 00 38 be 202168c <rtems_bdpart_mount+0x160> <== NOT EXECUTED
20215b0: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
20215b4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20215b8: 40 00 71 d7 call 203dd14 <strncpy> <== NOT EXECUTED
20215bc: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
20215c0: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20215c4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
20215c8: c2 2f 40 11 stb %g1, [ %i5 + %l1 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20215cc: 90 04 60 01 add %l1, 1, %o0 <== NOT EXECUTED
20215d0: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
20215d4: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20215d8: a6 04 e0 01 inc %l3 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20215dc: 37 00 81 68 sethi %hi(0x205a000), %i3 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20215e0: 40 00 71 cd call 203dd14 <strncpy> <== NOT EXECUTED
20215e4: 31 00 81 61 sethi %hi(0x2058400), %i0 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
20215e8: a0 06 40 10 add %i1, %l0, %l0 <== NOT EXECUTED
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20215ec: a6 07 40 13 add %i5, %l3, %l3 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
20215f0: b8 10 20 00 clr %i4 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20215f4: b6 16 e0 c0 or %i3, 0xc0, %i3 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
20215f8: 10 80 00 1d b 202166c <rtems_bdpart_mount+0x140> <== NOT EXECUTED
20215fc: b0 16 21 28 or %i0, 0x128, %i0 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
2021600: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2021604: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021608: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
202160c: 40 00 6d 68 call 203cbac <snprintf> <== NOT EXECUTED
2021610: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
2021614: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
2021618: 14 80 00 1a bg 2021680 <rtems_bdpart_mount+0x154> <== NOT EXECUTED
202161c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
2021620: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
2021624: 40 00 71 bc call 203dd14 <strncpy> <== NOT EXECUTED
2021628: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
202162c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021630: 40 00 0e 78 call 2025010 <rtems_mkdir> <== NOT EXECUTED
2021634: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED
if (rv != 0) {
2021638: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
202163c: 12 80 00 13 bne 2021688 <rtems_bdpart_mount+0x15c> <== NOT EXECUTED
2021640: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
2021644: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2021648: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
202164c: 96 10 20 00 clr %o3 <== NOT EXECUTED
2021650: 7f ff 88 96 call 20038a8 <mount> <== NOT EXECUTED
2021654: 98 10 20 00 clr %o4 <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
2021658: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
202165c: 02 80 00 05 be 2021670 <rtems_bdpart_mount+0x144> <== NOT EXECUTED
2021660: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
rmdir( mount_point);
2021664: 40 00 0e 43 call 2024f70 <rmdir> <== NOT EXECUTED
2021668: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
202166c: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
2021670: 32 bf ff e4 bne,a 2021600 <rtems_bdpart_mount+0xd4> <== NOT EXECUTED
2021674: b8 07 20 01 inc %i4 <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
2021678: 10 80 00 05 b 202168c <rtems_bdpart_mount+0x160> <== NOT EXECUTED
202167c: b8 10 20 00 clr %i4 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
esc = RTEMS_INVALID_NAME;
2021680: 10 80 00 03 b 202168c <rtems_bdpart_mount+0x160> <== NOT EXECUTED
2021684: b8 10 20 03 mov 3, %i4 <== NOT EXECUTED
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv != 0) {
esc = RTEMS_IO_ERROR;
2021688: b8 10 20 1b mov 0x1b, %i4 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
202168c: 7f ff 87 2c call 200333c <free> <== NOT EXECUTED
2021690: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
free( mount_point);
2021694: 7f ff 87 2a call 200333c <free> <== NOT EXECUTED
2021698: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return esc;
}
202169c: 81 c7 e0 08 ret <== NOT EXECUTED
20216a0: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
02003804 <rtems_bdpart_new_record>:
static rtems_status_code rtems_bdpart_new_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
2003804: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
2003808: d0 06 80 00 ld [ %i2 ], %o0
200380c: 80 a2 20 00 cmp %o0, 0
2003810: 12 80 00 0b bne 200383c <rtems_bdpart_new_record+0x38>
2003814: 01 00 00 00 nop
return sc;
}
}
/* Read the new record block (this accounts for disk block sizes > 512) */
sc = rtems_bdbuf_read( dd, index, block);
2003818: 90 10 00 18 mov %i0, %o0
200381c: 92 10 00 19 mov %i1, %o1
2003820: 40 00 31 47 call 200fd3c <rtems_bdbuf_read>
2003824: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003828: ba 92 20 00 orcc %o0, 0, %i5
200382c: 22 80 00 0b be,a 2003858 <rtems_bdpart_new_record+0x54> <== ALWAYS TAKEN
2003830: c2 06 80 00 ld [ %i2 ], %g1
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
2003834: 81 c7 e0 08 ret <== NOT EXECUTED
2003838: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
sc = rtems_bdbuf_sync( *block);
200383c: 40 00 32 0e call 2010074 <rtems_bdbuf_sync>
2003840: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003844: ba 92 20 00 orcc %o0, 0, %i5
2003848: 02 bf ff f5 be 200381c <rtems_bdpart_new_record+0x18> <== ALWAYS TAKEN
200384c: 90 10 00 18 mov %i0, %o0
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
2003850: 81 c7 e0 08 ret <== NOT EXECUTED
2003854: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
2003858: 80 a0 60 00 cmp %g1, 0
200385c: 02 80 00 0e be 2003894 <rtems_bdpart_new_record+0x90> <== NEVER TAKEN
2003860: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
}
/* Clear record */
memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);
2003864: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2003868: 40 00 47 bf call 2015764 <memset>
200386c: 94 10 22 00 mov 0x200, %o2
/* Write signature */
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =
2003870: c2 06 80 00 ld [ %i2 ], %g1
2003874: 84 10 20 55 mov 0x55, %g2
2003878: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
200387c: c4 28 61 fe stb %g2, [ %g1 + 0x1fe ]
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
2003880: c2 06 80 00 ld [ %i2 ], %g1
2003884: 84 10 3f aa mov -86, %g2
2003888: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
200388c: 10 80 00 03 b 2003898 <rtems_bdpart_new_record+0x94>
2003890: c4 28 61 ff stb %g2, [ %g1 + 0x1ff ]
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
return RTEMS_INVALID_ADDRESS;
2003894: 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;
}
2003898: b0 10 00 1d mov %i5, %i0
200389c: 81 c7 e0 08 ret
20038a0: 81 e8 00 00 restore
020033c8 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
20033c8: 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;
20033cc: 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;
20033d0: c0 27 bf e8 clr [ %fp + -24 ]
rtems_bdpart_partition *p = pt - 1;
20033d4: c2 27 bf ec st %g1, [ %fp + -20 ]
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
20033d8: 80 a6 e0 00 cmp %i3, 0
20033dc: 02 80 00 07 be 20033f8 <rtems_bdpart_read+0x30> <== NEVER TAKEN
20033e0: 90 10 00 18 mov %i0, %o0
20033e4: c2 06 c0 00 ld [ %i3 ], %g1
20033e8: 85 28 60 04 sll %g1, 4, %g2
20033ec: b9 28 60 06 sll %g1, 6, %i4
20033f0: 10 80 00 03 b 20033fc <rtems_bdpart_read+0x34>
20033f4: b8 27 00 02 sub %i4, %g2, %i4
20033f8: b8 10 20 00 clr %i4 <== NOT EXECUTED
rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
20033fc: 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 */
2003400: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
2003404: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
2003408: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
200340c: c0 27 bf fc clr [ %fp + -4 ]
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
2003410: 80 a6 a0 00 cmp %i2, 0
2003414: 02 80 00 89 be 2003638 <rtems_bdpart_read+0x270> <== NEVER TAKEN
2003418: b0 10 20 09 mov 9, %i0
200341c: 80 a6 60 00 cmp %i1, 0
2003420: 02 80 00 86 be 2003638 <rtems_bdpart_read+0x270> <== NEVER TAKEN
2003424: 80 a6 e0 00 cmp %i3, 0
2003428: 02 80 00 84 be 2003638 <rtems_bdpart_read+0x270> <== NEVER TAKEN
200342c: 92 07 bf f8 add %fp, -8, %o1
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
2003430: c0 26 c0 00 clr [ %i3 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2003434: 94 07 bf fc add %fp, -4, %o2
2003438: 7f ff ff bb call 2003324 <rtems_bdpart_get_disk_data>
200343c: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
2003440: b0 92 20 00 orcc %o0, 0, %i0
2003444: 12 80 00 7d bne 2003638 <rtems_bdpart_read+0x270> <== NEVER TAKEN
2003448: d0 07 bf fc ld [ %fp + -4 ], %o0
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( dd, 0, &block);
200344c: 92 10 20 00 clr %o1
2003450: 7f ff ff 4d call 2003184 <rtems_bdpart_read_record>
2003454: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003458: b0 92 20 00 orcc %o0, 0, %i0
200345c: 12 80 00 6c bne 200360c <rtems_bdpart_read+0x244> <== NEVER TAKEN
2003460: d0 07 bf f8 ld [ %fp + -8 ], %o0
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
2003464: c2 07 bf e8 ld [ %fp + -24 ], %g1
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
2003468: b8 06 80 1c add %i2, %i4, %i4
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
200346c: e4 00 60 1c ld [ %g1 + 0x1c ], %l2
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
2003470: a2 07 bf ec add %fp, -20, %l1
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
2003474: ba 04 a1 be add %l2, 0x1be, %i5
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
2003478: a0 07 bf f0 add %fp, -16, %l0
200347c: 90 10 00 1d mov %i5, %o0
2003480: 92 10 00 11 mov %l1, %o1
2003484: 94 10 00 1c mov %i4, %o2
2003488: 7f ff ff 70 call 2003248 <rtems_bdpart_read_mbr_partition>
200348c: 96 10 00 10 mov %l0, %o3
if (sc != RTEMS_SUCCESSFUL) {
2003490: b0 92 20 00 orcc %o0, 0, %i0
2003494: 32 80 00 5e bne,a 200360c <rtems_bdpart_read+0x244> <== NEVER TAKEN
2003498: 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) {
200349c: c2 07 bf ec ld [ %fp + -20 ], %g1
20034a0: c2 08 60 08 ldub [ %g1 + 8 ], %g1
20034a4: 80 a0 60 ee cmp %g1, 0xee
20034a8: 02 80 00 58 be 2003608 <rtems_bdpart_read+0x240> <== NEVER TAKEN
20034ac: 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
20034b0: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
20034b4: c0 26 40 00 clr [ %i1 ]
format->mbr.disk_id = rtems_uint32_from_little_endian(
20034b8: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
20034bc: a4 04 a1 ee add %l2, 0x1ee, %l2
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
20034c0: 7f ff ff 26 call 2003158 <rtems_uint32_from_little_endian>
20034c4: 90 02 21 b8 add %o0, 0x1b8, %o0
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
20034c8: 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(
20034cc: d0 26 60 04 st %o0, [ %i1 + 4 ]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
20034d0: c2 2e 60 08 stb %g1, [ %i1 + 8 ]
/* Iterate through the rest of the primary partition table */
for (i = 1; i < 4; ++i) {
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
20034d4: ba 07 60 10 add %i5, 0x10, %i5
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
20034d8: 92 10 00 11 mov %l1, %o1
20034dc: 90 10 00 1d mov %i5, %o0
20034e0: 94 10 00 1c mov %i4, %o2
20034e4: 7f ff ff 59 call 2003248 <rtems_bdpart_read_mbr_partition>
20034e8: 96 10 00 10 mov %l0, %o3
if (sc != RTEMS_SUCCESSFUL) {
20034ec: 80 a2 20 00 cmp %o0, 0
20034f0: 12 80 00 45 bne 2003604 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
20034f4: 80 a7 40 12 cmp %i5, %l2
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
/* Iterate through the rest of the primary partition table */
for (i = 1; i < 4; ++i) {
20034f8: 32 bf ff f8 bne,a 20034d8 <rtems_bdpart_read+0x110>
20034fc: ba 07 60 10 add %i5, 0x10, %i5
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
2003500: 10 80 00 2e b 20035b8 <rtems_bdpart_read+0x1f0>
2003504: fa 07 bf f0 ld [ %fp + -16 ], %i5
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( dd, ebr, &block);
2003508: 92 10 00 1d mov %i5, %o1
200350c: 7f ff ff 1e call 2003184 <rtems_bdpart_read_record>
2003510: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003514: 80 a2 20 00 cmp %o0, 0
2003518: 12 80 00 3b bne 2003604 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
200351c: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
2003520: 92 10 00 11 mov %l1, %o1
2003524: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2003528: 94 10 00 1c mov %i4, %o2
200352c: 90 02 21 be add %o0, 0x1be, %o0
2003530: 7f ff ff 46 call 2003248 <rtems_bdpart_read_mbr_partition>
2003534: 96 10 20 00 clr %o3
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
2003538: 80 a2 20 00 cmp %o0, 0
200353c: 12 80 00 32 bne 2003604 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
2003540: c2 07 bf ec ld [ %fp + -20 ], %g1
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
2003544: c6 00 40 00 ld [ %g1 ], %g3
2003548: 84 07 40 03 add %i5, %g3, %g2
if (tmp > p->begin) {
200354c: 80 a0 80 03 cmp %g2, %g3
2003550: 38 80 00 04 bgu,a 2003560 <rtems_bdpart_read+0x198> <== ALWAYS TAKEN
2003554: c4 20 40 00 st %g2, [ %g1 ]
p->begin = tmp;
} else {
esc = RTEMS_IO_ERROR;
2003558: 10 80 00 2c b 2003608 <rtems_bdpart_read+0x240> <== NOT EXECUTED
200355c: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
2003560: c4 00 60 04 ld [ %g1 + 4 ], %g2
2003564: ba 07 40 02 add %i5, %g2, %i5
if (tmp > p->end) {
2003568: 80 a7 40 02 cmp %i5, %g2
200356c: 08 80 00 27 bleu 2003608 <rtems_bdpart_read+0x240> <== NEVER TAKEN
2003570: b0 10 20 1b mov 0x1b, %i0
p->end = tmp;
2003574: fa 20 60 04 st %i5, [ %g1 + 4 ]
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
2003578: c2 07 bf e8 ld [ %fp + -24 ], %g1
200357c: f2 00 60 1c ld [ %g1 + 0x1c ], %i1
== RTEMS_BDPART_MBR_SIGNATURE_1;
}
static rtems_blkdev_bnum rtems_bdpart_next_ebr( const uint8_t *data)
{
rtems_blkdev_bnum begin =
2003580: 7f ff fe f6 call 2003158 <rtems_uint32_from_little_endian>
2003584: 90 06 61 d6 add %i1, 0x1d6, %o0
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EXTENDED) {
2003588: c2 0e 61 d2 ldub [ %i1 + 0x1d2 ], %g1
200358c: 80 a0 60 05 cmp %g1, 5
2003590: 12 80 00 0e bne 20035c8 <rtems_bdpart_read+0x200>
2003594: c2 07 bf ec ld [ %fp + -20 ], %g1
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
);
if (ebr != 0) {
2003598: 80 a2 20 00 cmp %o0, 0
200359c: 02 80 00 0a be 20035c4 <rtems_bdpart_read+0x1fc> <== NEVER TAKEN
20035a0: c2 07 bf f0 ld [ %fp + -16 ], %g1
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
20035a4: 82 02 00 01 add %o0, %g1, %g1
if (tmp > ebr) {
20035a8: 80 a0 40 08 cmp %g1, %o0
20035ac: 08 80 00 17 bleu 2003608 <rtems_bdpart_read+0x240> <== NEVER TAKEN
20035b0: b0 10 20 1b mov 0x1b, %i0
20035b4: ba 10 00 01 mov %g1, %i5
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
20035b8: 80 a7 60 00 cmp %i5, 0
20035bc: 12 bf ff d3 bne 2003508 <rtems_bdpart_read+0x140> <== ALWAYS TAKEN
20035c0: d0 07 bf fc ld [ %fp + -4 ], %o0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
20035c4: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED
rtems_bdpart_partition *pt,
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
20035c8: b0 10 20 00 clr %i0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
20035cc: b4 20 40 1a sub %g1, %i2, %i2
20035d0: b5 3e a0 04 sra %i2, 4, %i2
20035d4: 83 2e a0 02 sll %i2, 2, %g1
20035d8: 82 00 40 1a add %g1, %i2, %g1
20035dc: 85 28 60 04 sll %g1, 4, %g2
20035e0: 82 00 40 02 add %g1, %g2, %g1
20035e4: 85 28 60 08 sll %g1, 8, %g2
20035e8: 82 00 40 02 add %g1, %g2, %g1
20035ec: 85 28 60 10 sll %g1, 0x10, %g2
20035f0: 82 00 40 02 add %g1, %g2, %g1
20035f4: 82 20 00 01 neg %g1
20035f8: 82 00 60 01 inc %g1
20035fc: 10 80 00 03 b 2003608 <rtems_bdpart_read+0x240>
2003600: c2 26 c0 00 st %g1, [ %i3 ]
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
2003604: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
/* Return partition count */
*count = (size_t) (p - pt + 1);
cleanup:
if (fd >= 0) {
2003608: d0 07 bf f8 ld [ %fp + -8 ], %o0
200360c: 80 a2 20 00 cmp %o0, 0
2003610: 26 80 00 05 bl,a 2003624 <rtems_bdpart_read+0x25c> <== NEVER TAKEN
2003614: d0 07 bf e8 ld [ %fp + -24 ], %o0 <== NOT EXECUTED
close( fd);
2003618: 40 00 07 df call 2005594 <close>
200361c: 01 00 00 00 nop
}
if (block != NULL) {
2003620: d0 07 bf e8 ld [ %fp + -24 ], %o0
2003624: 80 a2 20 00 cmp %o0, 0
2003628: 02 80 00 06 be 2003640 <rtems_bdpart_read+0x278> <== NEVER TAKEN
200362c: 01 00 00 00 nop
rtems_bdbuf_release( block);
2003630: 40 00 32 3f call 200ff2c <rtems_bdbuf_release>
2003634: 01 00 00 00 nop
2003638: 81 c7 e0 08 ret
200363c: 81 e8 00 00 restore
}
return esc;
}
2003640: 81 c7 e0 08 ret <== NOT EXECUTED
2003644: 81 e8 00 00 restore <== NOT EXECUTED
02003248 <rtems_bdpart_read_mbr_partition>:
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
2003248: 9d e3 bf a0 save %sp, -96, %sp
rtems_blkdev_bnum begin =
200324c: 7f ff ff c3 call 2003158 <rtems_uint32_from_little_endian>
2003250: 90 06 20 08 add %i0, 8, %o0
2003254: ba 10 00 08 mov %o0, %i5
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
2003258: 7f ff ff c0 call 2003158 <rtems_uint32_from_little_endian>
200325c: 90 06 20 0c add %i0, 0xc, %o0
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EMPTY) {
2003260: f8 0e 20 04 ldub [ %i0 + 4 ], %i4
2003264: 80 a7 20 00 cmp %i4, 0
2003268: 02 80 00 21 be 20032ec <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
200326c: 82 10 20 00 clr %g1
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
2003270: c4 06 40 00 ld [ %i1 ], %g2
2003274: 80 a0 80 1a cmp %g2, %i2
2003278: 02 80 00 1d be 20032ec <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
200327c: 82 10 20 05 mov 5, %g1
{
rtems_blkdev_bnum begin =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
2003280: b4 02 00 1d add %o0, %i5, %i2
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
2003284: 80 a7 40 1a cmp %i5, %i2
2003288: 1a 80 00 19 bcc 20032ec <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
200328c: 82 10 20 1b mov 0x1b, %g1
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
2003290: 80 a7 20 05 cmp %i4, 5
2003294: 32 80 00 07 bne,a 20032b0 <rtems_bdpart_read_mbr_partition+0x68>
2003298: 90 00 a0 30 add %g2, 0x30, %o0
if (ep_begin != NULL) {
200329c: 80 a6 e0 00 cmp %i3, 0
20032a0: 32 80 00 12 bne,a 20032e8 <rtems_bdpart_read_mbr_partition+0xa0><== ALWAYS TAKEN
20032a4: fa 26 c0 00 st %i5, [ %i3 ]
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
20032a8: 10 80 00 11 b 20032ec <rtems_bdpart_read_mbr_partition+0xa4><== NOT EXECUTED
20032ac: 82 10 20 00 clr %g1 <== NOT EXECUTED
} else {
/* Increment partition index */
++(*p);
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
20032b0: 92 10 20 00 clr %o1
20032b4: 94 10 20 30 mov 0x30, %o2
20032b8: 40 00 49 2b call 2015764 <memset>
20032bc: d0 26 40 00 st %o0, [ %i1 ]
/* Set values */
(*p)->begin = begin;
20032c0: d2 06 40 00 ld [ %i1 ], %o1
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
20032c4: 90 10 00 1c mov %i4, %o0
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
/* Set values */
(*p)->begin = begin;
20032c8: fa 22 40 00 st %i5, [ %o1 ]
(*p)->end = end;
20032cc: f4 22 60 04 st %i2, [ %o1 + 4 ]
rtems_bdpart_to_partition_type( type, (*p)->type);
20032d0: 7f ff ff d6 call 2003228 <rtems_bdpart_to_partition_type>
20032d4: 92 02 60 08 add %o1, 8, %o1
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
20032d8: c2 06 40 00 ld [ %i1 ], %g1
20032dc: c4 0e 00 00 ldub [ %i0 ], %g2
20032e0: c0 20 60 28 clr [ %g1 + 0x28 ]
20032e4: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
20032e8: 82 10 20 00 clr %g1
rtems_bdpart_to_partition_type( type, (*p)->type);
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
}
return RTEMS_SUCCESSFUL;
}
20032ec: 81 c7 e0 08 ret
20032f0: 91 e8 00 01 restore %g0, %g1, %o0
02003184 <rtems_bdpart_read_record>:
static rtems_status_code rtems_bdpart_read_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
2003184: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
2003188: d0 06 80 00 ld [ %i2 ], %o0
200318c: 80 a2 20 00 cmp %o0, 0
2003190: 12 80 00 0b bne 20031bc <rtems_bdpart_read_record+0x38>
2003194: 01 00 00 00 nop
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( dd, index, block);
2003198: 90 10 00 18 mov %i0, %o0
200319c: 92 10 00 19 mov %i1, %o1
20031a0: 40 00 32 e7 call 200fd3c <rtems_bdbuf_read>
20031a4: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
20031a8: 80 a2 20 00 cmp %o0, 0
20031ac: 22 80 00 0b be,a 20031d8 <rtems_bdpart_read_record+0x54> <== ALWAYS TAKEN
20031b0: c2 06 80 00 ld [ %i2 ], %g1
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
20031b4: 81 c7 e0 08 ret <== NOT EXECUTED
20031b8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
sc = rtems_bdbuf_release( *block);
20031bc: 40 00 33 5c call 200ff2c <rtems_bdbuf_release>
20031c0: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
20031c4: 80 a2 20 00 cmp %o0, 0
20031c8: 22 bf ff f5 be,a 200319c <rtems_bdpart_read_record+0x18> <== ALWAYS TAKEN
20031cc: 90 10 00 18 mov %i0, %o0
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
20031d0: 81 c7 e0 08 ret <== NOT EXECUTED
20031d4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
20031d8: 80 a0 60 00 cmp %g1, 0
20031dc: 22 80 00 10 be,a 200321c <rtems_bdpart_read_record+0x98> <== NEVER TAKEN
20031e0: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
20031e4: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
static bool rtems_bdpart_is_valid_record( const uint8_t *data)
{
return data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0]
== RTEMS_BDPART_MBR_SIGNATURE_0
&& data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1]
20031e8: c6 08 a1 fe ldub [ %g2 + 0x1fe ], %g3
20031ec: 80 a0 e0 55 cmp %g3, 0x55
20031f0: 12 80 00 06 bne 2003208 <rtems_bdpart_read_record+0x84> <== NEVER TAKEN
20031f4: 82 10 20 00 clr %g1
20031f8: c2 08 a1 ff ldub [ %g2 + 0x1ff ], %g1
20031fc: 82 18 60 aa xor %g1, 0xaa, %g1
2003200: 80 a0 00 01 cmp %g0, %g1
2003204: 82 60 3f ff subx %g0, -1, %g1
if ( *block == NULL ) {
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
2003208: 80 a0 60 00 cmp %g1, 0
200320c: 22 80 00 04 be,a 200321c <rtems_bdpart_read_record+0x98> <== NEVER TAKEN
2003210: 90 10 20 1b mov 0x1b, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
2003214: 81 c7 e0 08 ret
2003218: 91 e8 00 08 restore %g0, %o0, %o0
200321c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
2003220: 81 c7 e0 08 ret <== NOT EXECUTED
2003224: 81 e8 00 00 restore <== NOT EXECUTED
02003648 <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
2003648: 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);
200364c: 90 10 00 18 mov %i0, %o0
2003650: 40 00 4c 24 call 20166e0 <strlen>
2003654: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
int fd = -1;
2003658: 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
)
{
200365c: 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);
2003660: a0 10 00 08 mov %o0, %l0
size_t i = 0;
int fd = -1;
2003664: 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);
2003668: 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;
200366c: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2003670: 92 07 bf f8 add %fp, -8, %o1
2003674: 94 07 bf fc add %fp, -4, %o2
2003678: 7f ff ff 2b call 2003324 <rtems_bdpart_get_disk_data>
200367c: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
2003680: b0 92 20 00 orcc %o0, 0, %i0
2003684: 12 80 00 31 bne 2003748 <rtems_bdpart_register+0x100> <== NEVER TAKEN
2003688: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
200368c: 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;
2003690: e2 00 40 00 ld [ %g1 ], %l1
2003694: 40 00 07 c0 call 2005594 <close>
2003698: f6 00 60 04 ld [ %g1 + 4 ], %i3
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
200369c: 90 04 20 04 add %l0, 4, %o0
20036a0: 40 00 0a 0b call 2005ecc <malloc>
20036a4: b0 10 20 1a mov 0x1a, %i0
if (logical_disk_name == NULL) {
20036a8: 80 a2 20 00 cmp %o0, 0
20036ac: 02 80 00 27 be 2003748 <rtems_bdpart_register+0x100> <== NEVER TAKEN
20036b0: b8 10 00 08 mov %o0, %i4
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
20036b4: 92 10 00 1d mov %i5, %o1
20036b8: 94 10 00 10 mov %l0, %o2
20036bc: 40 00 4c 91 call 2016900 <strncpy>
20036c0: 25 00 80 90 sethi %hi(0x2024000), %l2
logical_disk_marker = logical_disk_name + disk_name_size;
20036c4: a0 07 00 10 add %i4, %l0, %l0
#include <string.h>
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_register(
20036c8: b4 06 80 1b add %i2, %i3, %i2
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
20036cc: ba 10 00 1b mov %i3, %i5
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
20036d0: 10 80 00 16 b 2003728 <rtems_bdpart_register+0xe0>
20036d4: a4 14 a3 00 or %l2, 0x300, %l2
/* Create a new device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Set partition number for logical disk name */
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20036d8: 90 10 00 10 mov %l0, %o0
20036dc: 92 10 20 04 mov 4, %o1
20036e0: 94 10 00 12 mov %l2, %o2
20036e4: 40 00 49 62 call 2015c6c <snprintf>
20036e8: 96 27 40 1b sub %i5, %i3, %o3
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
20036ec: 80 a2 20 03 cmp %o0, 3
20036f0: 14 80 00 13 bg 200373c <rtems_bdpart_register+0xf4> <== NEVER TAKEN
20036f4: 90 10 00 11 mov %l1, %o0
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
20036f8: da 06 60 04 ld [ %i1 + 4 ], %o5
logical_disk,
disk,
p->begin,
p->end - p->begin,
20036fc: d8 06 40 00 ld [ %i1 ], %o4
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2003700: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
2003704: 92 10 00 1d mov %i5, %o1
2003708: 94 10 00 11 mov %l1, %o2
200370c: 96 10 00 1b mov %i3, %o3
2003710: 9a 23 40 0c sub %o5, %o4, %o5
2003714: 40 00 03 1e call 200438c <rtems_disk_create_log>
2003718: b2 06 60 30 add %i1, 0x30, %i1
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
200371c: 80 a2 20 00 cmp %o0, 0
2003720: 12 80 00 08 bne 2003740 <rtems_bdpart_register+0xf8> <== NEVER TAKEN
2003724: b0 10 00 08 mov %o0, %i0
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
2003728: 80 a7 40 1a cmp %i5, %i2
200372c: 32 bf ff eb bne,a 20036d8 <rtems_bdpart_register+0x90>
2003730: ba 07 60 01 inc %i5
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2003734: 10 80 00 03 b 2003740 <rtems_bdpart_register+0xf8>
2003738: b0 10 20 00 clr %i0
200373c: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
2003740: 40 00 08 52 call 2005888 <free>
2003744: 90 10 00 1c mov %i4, %o0
return esc;
}
2003748: 81 c7 e0 08 ret
200374c: 81 e8 00 00 restore
02003750 <rtems_bdpart_register_from_disk>:
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
2003750: 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;
2003754: 82 10 20 10 mov 0x10, %g1
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
2003758: 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;
200375c: c2 27 bc e8 st %g1, [ %fp + -792 ]
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
2003760: 92 07 bc ec add %fp, -788, %o1
2003764: 94 07 bd 00 add %fp, -768, %o2
2003768: 7f ff ff 18 call 20033c8 <rtems_bdpart_read>
200376c: 96 07 bc e8 add %fp, -792, %o3
if (sc != RTEMS_SUCCESSFUL) {
2003770: 80 a2 20 00 cmp %o0, 0
2003774: 12 80 00 05 bne 2003788 <rtems_bdpart_register_from_disk+0x38><== NEVER TAKEN
2003778: d4 07 bc e8 ld [ %fp + -792 ], %o2
return sc;
}
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
200377c: 90 10 00 18 mov %i0, %o0
2003780: 7f ff ff b2 call 2003648 <rtems_bdpart_register>
2003784: 92 07 bd 00 add %fp, -768, %o1
}
2003788: 81 c7 e0 08 ret
200378c: 91 e8 00 08 restore %g0, %o0, %o0
020216a4 <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
20216a4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
20216a8: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
20216ac: 40 00 75 01 call 203eab0 <strrchr> <== NOT EXECUTED
20216b0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20216b4: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
char *mount_point = NULL;
char *mount_marker = NULL;
size_t disk_file_name_size = 0;
size_t disk_name_size = strlen( disk_name);
20216b8: 40 00 70 db call 203da24 <strlen> <== NOT EXECUTED
20216bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20216c0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
20216c4: 40 00 70 d8 call 203da24 <strlen> <== NOT EXECUTED
20216c8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
20216cc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
20216d0: 02 80 00 07 be 20216ec <rtems_bdpart_unmount+0x48> <== NOT EXECUTED
20216d4: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
disk_file_name += 1;
20216d8: b2 06 60 01 inc %i1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
20216dc: 40 00 70 d2 call 203da24 <strlen> <== NOT EXECUTED
20216e0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
20216e4: 10 80 00 03 b 20216f0 <rtems_bdpart_unmount+0x4c> <== NOT EXECUTED
20216e8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
} else {
disk_file_name = disk_name;
20216ec: b2 10 00 18 mov %i0, %i1 <== NOT EXECUTED
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
20216f0: a2 04 00 1c add %l0, %i4, %l1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
20216f4: 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);
20216f8: 7f ff 87 e5 call 200368c <malloc> <== NOT EXECUTED
20216fc: 90 04 60 05 add %l1, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
2021700: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021704: 02 80 00 28 be 20217a4 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
2021708: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
202170c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2021710: 40 00 71 81 call 203dd14 <strncpy> <== NOT EXECUTED
2021714: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
2021718: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
202171c: 90 07 20 01 add %i4, 1, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
2021720: c2 2f 40 1c stb %g1, [ %i5 + %i4 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2021724: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED
2021728: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
202172c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
2021730: a2 04 60 01 inc %l1 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2021734: 40 00 71 78 call 203dd14 <strncpy> <== NOT EXECUTED
2021738: 37 00 81 68 sethi %hi(0x205a000), %i3 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
202173c: a2 07 40 11 add %i5, %l1, %l1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
2021740: b8 10 20 00 clr %i4 <== NOT EXECUTED
2021744: 10 80 00 14 b 2021794 <rtems_bdpart_unmount+0xf0> <== NOT EXECUTED
2021748: b6 16 e0 c0 or %i3, 0xc0, %i3 <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
202174c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2021750: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021754: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2021758: 40 00 6d 15 call 203cbac <snprintf> <== NOT EXECUTED
202175c: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
2021760: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
2021764: 14 80 00 10 bg 20217a4 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
2021768: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
202176c: 40 00 0f a9 call 2025610 <unmount> <== NOT EXECUTED
2021770: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv == 0) {
2021774: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021778: 12 80 00 08 bne 2021798 <rtems_bdpart_unmount+0xf4> <== NOT EXECUTED
202177c: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
2021780: 40 00 0d fc call 2024f70 <rmdir> <== NOT EXECUTED
2021784: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
2021788: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
202178c: 12 80 00 06 bne 20217a4 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
2021790: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
2021794: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
2021798: 32 bf ff ed bne,a 202174c <rtems_bdpart_unmount+0xa8> <== NOT EXECUTED
202179c: b8 07 20 01 inc %i4 <== NOT EXECUTED
20217a0: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
20217a4: 7f ff 86 e6 call 200333c <free> <== NOT EXECUTED
20217a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return esc;
}
20217ac: 81 c7 e0 08 ret <== NOT EXECUTED
20217b0: 81 e8 00 00 restore <== NOT EXECUTED
02003790 <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
2003790: 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;
2003794: 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);
2003798: 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;
200379c: c0 27 bf f4 clr [ %fp + -12 ]
dev_t disk = 0;
dev_t logical_disk = 0;
size_t i = 0;
int fd = -1;
20037a0: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
20037a4: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
20037a8: 92 07 bf f8 add %fp, -8, %o1
20037ac: 94 07 bf fc add %fp, -4, %o2
20037b0: 7f ff fe dd call 2003324 <rtems_bdpart_get_disk_data>
20037b4: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
20037b8: b0 92 20 00 orcc %o0, 0, %i0
20037bc: 12 80 00 10 bne 20037fc <rtems_bdpart_unregister+0x6c> <== NEVER TAKEN
20037c0: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
20037c4: d0 07 bf f8 ld [ %fp + -8 ], %o0
20037c8: 40 00 07 73 call 2005594 <close>
20037cc: 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) {
20037d0: 10 80 00 08 b 20037f0 <rtems_bdpart_unregister+0x60>
20037d4: b4 06 80 1d add %i2, %i5, %i2
/* Get the device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Delete logical disk */
sc = rtems_disk_delete( logical_disk);
20037d8: 90 10 00 1c mov %i4, %o0
20037dc: 40 00 02 84 call 20041ec <rtems_disk_delete>
20037e0: 92 10 00 1d mov %i5, %o1
if (sc != RTEMS_SUCCESSFUL) {
20037e4: 80 a2 20 00 cmp %o0, 0
20037e8: 32 80 00 05 bne,a 20037fc <rtems_bdpart_unregister+0x6c> <== NEVER TAKEN
20037ec: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
20037f0: 80 a7 40 1a cmp %i5, %i2
20037f4: 12 bf ff f9 bne 20037d8 <rtems_bdpart_unregister+0x48>
20037f8: ba 07 60 01 inc %i5
20037fc: 81 c7 e0 08 ret
2003800: 81 e8 00 00 restore
020038e8 <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
20038e8: 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;
20038ec: 80 a6 60 00 cmp %i1, 0
20038f0: 02 80 00 08 be 2003910 <rtems_bdpart_write+0x28> <== NEVER TAKEN
20038f4: 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
20038f8: c4 06 40 00 ld [ %i1 ], %g2
20038fc: 80 a0 a0 00 cmp %g2, 0
2003900: 12 80 00 05 bne 2003914 <rtems_bdpart_write+0x2c> <== NEVER TAKEN
2003904: 82 10 20 00 clr %g1
&& format->mbr.dos_compatibility;
2003908: 10 80 00 03 b 2003914 <rtems_bdpart_write+0x2c>
200390c: c2 0e 60 08 ldub [ %i1 + 8 ], %g1
2003910: 82 10 20 00 clr %g1 <== NOT EXECUTED
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
2003914: a2 08 60 01 and %g1, 1, %l1
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
2003918: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
200391c: ba 0c 60 ff and %l1, 0xff, %i5
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
int fd = -1;
2003920: 82 10 3f ff mov -1, %g1
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
2003924: 80 a0 00 1d cmp %g0, %i5
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
2003928: c0 27 bf f4 clr [ %fp + -12 ]
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
int fd = -1;
200392c: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
2003930: c0 27 bf fc clr [ %fp + -4 ]
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
2003934: b8 40 3f ff addx %g0, -1, %i4
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
2003938: b0 10 20 00 clr %i0
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
200393c: b8 0f 3f c2 and %i4, -62, %i4
uint8_t *data = NULL;
int fd = -1;
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
2003940: 80 a6 e0 00 cmp %i3, 0
2003944: 02 80 00 cd be 2003c78 <rtems_bdpart_write+0x390> <== NEVER TAKEN
2003948: b8 07 20 3f add %i4, 0x3f, %i4
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
200394c: 80 a6 a0 00 cmp %i2, 0
2003950: 02 80 00 ca be 2003c78 <rtems_bdpart_write+0x390> <== NEVER TAKEN
2003954: b0 10 20 09 mov 9, %i0
2003958: 80 a6 60 00 cmp %i1, 0
200395c: 02 80 00 c7 be 2003c78 <rtems_bdpart_write+0x390> <== NEVER TAKEN
2003960: 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);
2003964: 94 07 bf fc add %fp, -4, %o2
2003968: 7f ff fe 6f call 2003324 <rtems_bdpart_get_disk_data>
200396c: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
2003970: b0 92 20 00 orcc %o0, 0, %i0
2003974: 12 80 00 c1 bne 2003c78 <rtems_bdpart_write+0x390> <== NEVER TAKEN
2003978: 80 a7 60 00 cmp %i5, 0
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
200397c: 02 80 00 09 be 20039a0 <rtems_bdpart_write+0xb8> <== NEVER TAKEN
2003980: c8 07 bf f4 ld [ %fp + -12 ], %g4
disk_end -= (disk_end % record_space);
2003984: fa 07 bf f4 ld [ %fp + -12 ], %i5
2003988: 92 10 00 1c mov %i4, %o1
200398c: 40 00 78 9d call 2021c00 <.urem>
2003990: 90 10 00 1d mov %i5, %o0
2003994: 90 27 40 08 sub %i5, %o0, %o0
2003998: d0 27 bf f4 st %o0, [ %fp + -12 ]
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Check that begin and end are proper within the disk */
if (p->begin >= disk_end || p->end > disk_end) {
200399c: c8 07 bf f4 ld [ %fp + -12 ], %g4
20039a0: a0 10 00 1a mov %i2, %l0
20039a4: 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) {
20039a8: 84 10 20 00 clr %g2
const rtems_bdpart_partition *p = pt + i;
/* Check that begin and end are proper within the disk */
if (p->begin >= disk_end || p->end > disk_end) {
20039ac: c6 00 40 00 ld [ %g1 ], %g3
20039b0: 80 a0 c0 04 cmp %g3, %g4
20039b4: 3a 80 00 a5 bcc,a 2003c48 <rtems_bdpart_write+0x360> <== NEVER TAKEN
20039b8: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
20039bc: fa 00 60 04 ld [ %g1 + 4 ], %i5
20039c0: 80 a7 40 04 cmp %i5, %g4
20039c4: 18 80 00 9e bgu 2003c3c <rtems_bdpart_write+0x354> <== NEVER TAKEN
20039c8: 80 a0 c0 1d cmp %g3, %i5
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
20039cc: 1a 80 00 9c bcc 2003c3c <rtems_bdpart_write+0x354> <== NEVER TAKEN
20039d0: 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) {
20039d4: 02 80 00 06 be 20039ec <rtems_bdpart_write+0x104>
20039d8: 84 00 a0 01 inc %g2
20039dc: fa 00 7f d4 ld [ %g1 + -44 ], %i5
20039e0: 80 a7 40 03 cmp %i5, %g3
20039e4: 38 80 00 99 bgu,a 2003c48 <rtems_bdpart_write+0x360> <== NEVER TAKEN
20039e8: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
}
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
20039ec: 80 a0 80 1b cmp %g2, %i3
20039f0: 12 bf ff ef bne 20039ac <rtems_bdpart_write+0xc4>
20039f4: 82 00 60 30 add %g1, 0x30, %g1
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
20039f8: c2 06 40 00 ld [ %i1 ], %g1
20039fc: 80 a0 60 00 cmp %g1, 0
2003a00: 12 80 00 92 bne 2003c48 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2003a04: 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;
2003a08: 80 a6 e0 04 cmp %i3, 4
2003a0c: 08 80 00 03 bleu 2003a18 <rtems_bdpart_write+0x130> <== NEVER TAKEN
2003a10: ba 10 00 1b mov %i3, %i5
2003a14: ba 10 20 03 mov 3, %i5
/*
* Check that the first primary partition starts at head one and sector one
* under the virtual one head and 63 sectors geometry if necessary.
*/
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
2003a18: 80 8c 60 ff btst 0xff, %l1
2003a1c: 32 80 00 09 bne,a 2003a40 <rtems_bdpart_write+0x158> <== ALWAYS TAKEN
2003a20: c2 06 80 00 ld [ %i2 ], %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003a24: 83 2f 60 04 sll %i5, 4, %g1 <== NOT EXECUTED
2003a28: a5 2f 60 06 sll %i5, 6, %l2
2003a2c: 84 10 00 1d mov %i5, %g2
2003a30: a4 24 80 01 sub %l2, %g1, %l2
2003a34: 82 10 20 00 clr %g1
2003a38: 10 80 00 0e b 2003a70 <rtems_bdpart_write+0x188>
2003a3c: a2 06 80 12 add %i2, %l2, %l1
/*
* Check that the first primary partition starts at head one and sector one
* under the virtual one head and 63 sectors geometry if necessary.
*/
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
2003a40: 80 a0 60 3f cmp %g1, 0x3f
2003a44: 12 80 00 81 bne 2003c48 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2003a48: b0 10 20 0a mov 0xa, %i0
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003a4c: 10 bf ff f7 b 2003a28 <rtems_bdpart_write+0x140>
2003a50: 83 2f 60 04 sll %i5, 4, %g1
* The space for the EBR and maybe some space which is needed for DOS
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
if ((pt [i].begin - pt [i - 1].end) < record_space) {
2003a54: c8 04 40 01 ld [ %l1 + %g1 ], %g4
2003a58: c6 00 ff d4 ld [ %g3 + -44 ], %g3
2003a5c: 86 21 00 03 sub %g4, %g3, %g3
2003a60: 80 a0 c0 1c cmp %g3, %i4
2003a64: 0a 80 00 76 bcs 2003c3c <rtems_bdpart_write+0x354> <== NEVER TAKEN
2003a68: 82 00 60 30 add %g1, 0x30, %g1
* Each logical partition is described via one EBR preceding the partition.
* The space for the EBR and maybe some space which is needed for DOS
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
2003a6c: 84 00 a0 01 inc %g2
2003a70: 80 a0 80 1b cmp %g2, %i3
2003a74: 0a bf ff f8 bcs 2003a54 <rtems_bdpart_write+0x16c>
2003a78: 86 04 40 01 add %l1, %g1, %g3
2003a7c: b0 10 00 1a mov %i2, %i0
2003a80: a6 10 20 00 clr %l3
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
uint8_t type = 0;
2003a84: 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)) {
2003a88: 90 06 20 08 add %i0, 8, %o0
2003a8c: 7f ff fe 1a call 20032f4 <rtems_bdpart_to_mbr_partition_type>
2003a90: 92 07 bf ef add %fp, -17, %o1
2003a94: 80 8a 20 ff btst 0xff, %o0
2003a98: 22 80 00 6c be,a 2003c48 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2003a9c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2003aa0: b0 06 20 30 add %i0, 0x30, %i0
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
2003aa4: c2 06 3f f8 ld [ %i0 + -8 ], %g1
2003aa8: 80 a0 60 00 cmp %g1, 0
2003aac: 32 80 00 67 bne,a 2003c48 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2003ab0: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2003ab4: c2 06 3f fc ld [ %i0 + -4 ], %g1
2003ab8: 80 a0 60 ff cmp %g1, 0xff
2003abc: 18 80 00 07 bgu 2003ad8 <rtems_bdpart_write+0x1f0> <== NEVER TAKEN
2003ac0: a6 04 e0 01 inc %l3
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
2003ac4: 80 a4 c0 1b cmp %l3, %i3
2003ac8: 32 bf ff f0 bne,a 2003a88 <rtems_bdpart_write+0x1a0>
2003acc: c0 2f bf ef clrb [ %fp + -17 ]
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( dd, 0, &block);
2003ad0: 10 80 00 04 b 2003ae0 <rtems_bdpart_write+0x1f8>
2003ad4: d0 07 bf fc ld [ %fp + -4 ], %o0
2003ad8: 10 80 00 5c b 2003c48 <rtems_bdpart_write+0x360> <== NOT EXECUTED
2003adc: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2003ae0: 92 10 20 00 clr %o1
2003ae4: 7f ff ff 48 call 2003804 <rtems_bdpart_new_record>
2003ae8: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003aec: b0 92 20 00 orcc %o0, 0, %i0
2003af0: 12 80 00 57 bne 2003c4c <rtems_bdpart_write+0x364> <== NEVER TAKEN
2003af4: 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
2003af8: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
2003afc: c4 06 60 04 ld [ %i1 + 4 ], %g2
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
2003b00: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
2003b04: 82 10 20 00 clr %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003b08: 86 01 00 01 add %g4, %g1, %g3
data [i] = (uint8_t) value;
2003b0c: c4 28 e1 b8 stb %g2, [ %g3 + 0x1b8 ]
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2003b10: 82 00 60 01 inc %g1
2003b14: 80 a0 60 04 cmp %g1, 4
2003b18: 12 bf ff fc bne 2003b08 <rtems_bdpart_write+0x220>
2003b1c: 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;
2003b20: c2 07 bf f0 ld [ %fp + -16 ], %g1
for (i = 0; i < ppc; ++i) {
2003b24: b2 10 20 00 clr %i1
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
2003b28: e6 00 60 1c ld [ %g1 + 0x1c ], %l3
2003b2c: a6 04 e1 be add %l3, 0x1be, %l3
for (i = 0; i < ppc; ++i) {
2003b30: 10 80 00 0b b 2003b5c <rtems_bdpart_write+0x274>
2003b34: b0 10 00 13 mov %l3, %i0
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
2003b38: d4 04 20 04 ld [ %l0 + 4 ], %o2
2003b3c: d6 0c 20 08 ldub [ %l0 + 8 ], %o3
2003b40: d8 0c 20 2f ldub [ %l0 + 0x2f ], %o4
2003b44: 90 10 00 18 mov %i0, %o0
2003b48: 94 22 80 09 sub %o2, %o1, %o2
2003b4c: 7f ff ff 56 call 20038a4 <rtems_bdpart_write_mbr_partition>
2003b50: b0 06 20 10 add %i0, 0x10, %i0
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
2003b54: b2 06 60 01 inc %i1
2003b58: a0 04 20 30 add %l0, 0x30, %l0
2003b5c: 80 a6 40 1d cmp %i1, %i5
2003b60: 32 bf ff f6 bne,a 2003b38 <rtems_bdpart_write+0x250>
2003b64: d2 04 00 00 ld [ %l0 ], %o1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003b68: 91 2f 60 04 sll %i5, 4, %o0
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2003b6c: b0 10 20 00 clr %i0
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
2003b70: 80 a7 40 1b cmp %i5, %i3
2003b74: 02 80 00 35 be 2003c48 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2003b78: 90 04 c0 08 add %l3, %o0, %o0
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
2003b7c: e0 06 80 12 ld [ %i2 + %l2 ], %l0
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2003b80: d4 07 bf f4 ld [ %fp + -12 ], %o2
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
2003b84: a0 24 00 1c sub %l0, %i4, %l0
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2003b88: 96 10 20 05 mov 5, %o3
2003b8c: 92 10 00 10 mov %l0, %o1
2003b90: 94 22 80 10 sub %o2, %l0, %o2
2003b94: 98 10 20 00 clr %o4
2003b98: 7f ff ff 43 call 20038a4 <rtems_bdpart_write_mbr_partition>
2003b9c: b4 10 00 11 mov %l1, %i2
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2003ba0: 10 80 00 22 b 2003c28 <rtems_bdpart_write+0x340>
2003ba4: b2 10 00 1d mov %i5, %i1
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
2003ba8: 28 80 00 0e bleu,a 2003be0 <rtems_bdpart_write+0x2f8>
2003bac: d2 06 80 00 ld [ %i2 ], %o1
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
2003bb0: 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;
2003bb4: c2 06 80 00 ld [ %i2 ], %g1
rtems_bdpart_write_mbr_partition(
2003bb8: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
2003bbc: d4 07 bf f4 ld [ %fp + -12 ], %o2
for (i = ppc; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
2003bc0: 82 20 40 1c sub %g1, %i4, %g1
rtems_bdpart_write_mbr_partition(
2003bc4: 90 02 21 ce add %o0, 0x1ce, %o0
2003bc8: 92 20 40 10 sub %g1, %l0, %o1
2003bcc: 94 22 80 01 sub %o2, %g1, %o2
2003bd0: 96 10 20 05 mov 5, %o3
2003bd4: 7f ff ff 34 call 20038a4 <rtems_bdpart_write_mbr_partition>
2003bd8: 98 10 20 00 clr %o4
0
);
}
/* New EBR */
ebr = p->begin - record_space;
2003bdc: d2 06 80 00 ld [ %i2 ], %o1
sc = rtems_bdpart_new_record( dd, ebr, &block);
2003be0: d0 07 bf fc ld [ %fp + -4 ], %o0
2003be4: 92 22 40 1c sub %o1, %i4, %o1
2003be8: 7f ff ff 07 call 2003804 <rtems_bdpart_new_record>
2003bec: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003bf0: 80 a2 20 00 cmp %o0, 0
2003bf4: 12 80 00 14 bne 2003c44 <rtems_bdpart_write+0x35c> <== NEVER TAKEN
2003bf8: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
2003bfc: d4 06 a0 04 ld [ %i2 + 4 ], %o2
2003c00: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2003c04: d6 0e a0 08 ldub [ %i2 + 8 ], %o3
2003c08: c2 06 80 00 ld [ %i2 ], %g1
2003c0c: d8 0e a0 2f ldub [ %i2 + 0x2f ], %o4
2003c10: 90 02 21 be add %o0, 0x1be, %o0
2003c14: 92 10 00 1c mov %i4, %o1
2003c18: 94 22 80 01 sub %o2, %g1, %o2
2003c1c: 7f ff ff 22 call 20038a4 <rtems_bdpart_write_mbr_partition>
2003c20: b2 06 60 01 inc %i1
2003c24: b4 06 a0 30 add %i2, 0x30, %i2
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2003c28: 80 a6 40 1b cmp %i1, %i3
2003c2c: 0a bf ff df bcs 2003ba8 <rtems_bdpart_write+0x2c0>
2003c30: 80 a6 40 1d cmp %i1, %i5
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2003c34: 10 80 00 05 b 2003c48 <rtems_bdpart_write+0x360>
2003c38: b0 10 20 00 clr %i0
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
if ((pt [i].begin - pt [i - 1].end) < record_space) {
esc = RTEMS_INVALID_NUMBER;
2003c3c: 10 80 00 03 b 2003c48 <rtems_bdpart_write+0x360> <== NOT EXECUTED
2003c40: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
}
/* New EBR */
ebr = p->begin - record_space;
sc = rtems_bdpart_new_record( dd, ebr, &block);
if (sc != RTEMS_SUCCESSFUL) {
2003c44: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
2003c48: d0 07 bf f8 ld [ %fp + -8 ], %o0
2003c4c: 80 a2 20 00 cmp %o0, 0
2003c50: 26 80 00 05 bl,a 2003c64 <rtems_bdpart_write+0x37c> <== NEVER TAKEN
2003c54: d0 07 bf f0 ld [ %fp + -16 ], %o0 <== NOT EXECUTED
close( fd);
2003c58: 40 00 06 4f call 2005594 <close>
2003c5c: 01 00 00 00 nop
}
if (block != NULL) {
2003c60: d0 07 bf f0 ld [ %fp + -16 ], %o0
2003c64: 80 a2 20 00 cmp %o0, 0
2003c68: 02 80 00 06 be 2003c80 <rtems_bdpart_write+0x398> <== NEVER TAKEN
2003c6c: 01 00 00 00 nop
rtems_bdbuf_sync( block);
2003c70: 40 00 31 01 call 2010074 <rtems_bdbuf_sync>
2003c74: 01 00 00 00 nop
2003c78: 81 c7 e0 08 ret
2003c7c: 81 e8 00 00 restore
}
return esc;
}
2003c80: 81 c7 e0 08 ret <== NOT EXECUTED
2003c84: 81 e8 00 00 restore <== NOT EXECUTED
02003988 <rtems_blkdev_create_partition>:
const char *partition,
const char *parent_block_device,
rtems_blkdev_bnum media_block_begin,
rtems_blkdev_bnum media_block_count
)
{
2003988: 9d e3 bf 50 save %sp, -176, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(parent_block_device, O_RDWR);
200398c: 92 10 20 02 mov 2, %o1
2003990: 90 10 00 19 mov %i1, %o0
2003994: 40 00 09 da call 20060fc <open>
2003998: ba 10 20 04 mov 4, %i5
if (fd >= 0) {
200399c: 80 a2 20 00 cmp %o0, 0
20039a0: 06 80 00 33 bl 2003a6c <rtems_blkdev_create_partition+0xe4>
20039a4: b2 10 00 08 mov %o0, %i1
int rv;
struct stat st;
rv = fstat(fd, &st);
20039a8: 40 00 06 43 call 20052b4 <fstat>
20039ac: 92 07 bf b8 add %fp, -72, %o1
if (rv == 0 && S_ISBLK(st.st_mode)) {
20039b0: 80 a2 20 00 cmp %o0, 0
20039b4: 12 80 00 2c bne 2003a64 <rtems_blkdev_create_partition+0xdc><== NEVER TAKEN
20039b8: ba 10 20 15 mov 0x15, %i5
20039bc: e0 07 bf c4 ld [ %fp + -60 ], %l0
20039c0: 03 00 00 3c sethi %hi(0xf000), %g1
20039c4: a0 0c 00 01 and %l0, %g1, %l0
20039c8: 03 00 00 18 sethi %hi(0x6000), %g1
20039cc: 80 a4 00 01 cmp %l0, %g1
20039d0: 12 80 00 25 bne 2003a64 <rtems_blkdev_create_partition+0xdc>
20039d4: 90 10 00 19 mov %i1, %o0
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
20039d8: 13 10 01 10 sethi %hi(0x40044000), %o1
20039dc: 94 07 bf b4 add %fp, -76, %o2
20039e0: 92 12 62 09 or %o1, 0x209, %o1
20039e4: 40 00 06 87 call 2005400 <ioctl>
20039e8: ba 10 20 18 mov 0x18, %i5
rtems_disk_device *phys_dd;
rv = rtems_disk_fd_get_disk_device(fd, &phys_dd);
if (rv == 0) {
20039ec: 80 a2 20 00 cmp %o0, 0
20039f0: 12 80 00 1d bne 2003a64 <rtems_blkdev_create_partition+0xdc>
20039f4: 01 00 00 00 nop
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
20039f8: 40 00 07 96 call 2005850 <malloc>
20039fc: 90 10 20 80 mov 0x80, %o0 ! 80 <PROM_START+0x80>
if (ctx != NULL) {
2003a00: b8 92 20 00 orcc %o0, 0, %i4
2003a04: 02 80 00 17 be 2003a60 <rtems_blkdev_create_partition+0xd8>
2003a08: d2 07 bf b4 ld [ %fp + -76 ], %o1
sc = rtems_disk_init_log(
2003a0c: 94 10 00 1a mov %i2, %o2
2003a10: 40 00 00 90 call 2003c50 <rtems_disk_init_log>
2003a14: 96 10 00 1b mov %i3, %o3
phys_dd,
media_block_begin,
media_block_count
);
if (sc == RTEMS_SUCCESSFUL) {
2003a18: ba 92 20 00 orcc %o0, 0, %i5
2003a1c: 12 80 00 0e bne 2003a54 <rtems_blkdev_create_partition+0xcc>
2003a20: 90 10 00 18 mov %i0, %o0
ctx->fd = fd;
2003a24: f2 27 20 78 st %i1, [ %i4 + 0x78 ]
rv = IMFS_make_generic_node(
2003a28: 92 14 21 ff or %l0, 0x1ff, %o1
2003a2c: 15 00 80 7d sethi %hi(0x201f400), %o2
2003a30: 96 10 00 1c mov %i4, %o3
2003a34: 40 00 03 90 call 2004874 <IMFS_make_generic_node>
2003a38: 94 12 a3 30 or %o2, 0x330, %o2
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
2003a3c: 80 a2 20 00 cmp %o0, 0
2003a40: 02 80 00 0b be 2003a6c <rtems_blkdev_create_partition+0xe4>
2003a44: 90 10 00 1c mov %i4, %o0
free(ctx);
2003a48: 40 00 05 f1 call 200520c <free>
2003a4c: ba 10 20 0d mov 0xd, %i5
2003a50: 30 80 00 05 b,a 2003a64 <rtems_blkdev_create_partition+0xdc>
sc = RTEMS_UNSATISFIED;
}
} else {
free(ctx);
2003a54: 40 00 05 ee call 200520c <free>
2003a58: 90 10 00 1c mov %i4, %o0
2003a5c: 30 80 00 02 b,a 2003a64 <rtems_blkdev_create_partition+0xdc>
2003a60: ba 10 20 1a mov 0x1a, %i5
} else {
sc = RTEMS_INVALID_NODE;
}
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
2003a64: 40 00 05 2d call 2004f18 <close>
2003a68: 90 10 00 19 mov %i1, %o0
} else {
sc = RTEMS_INVALID_ID;
}
return sc;
}
2003a6c: 81 c7 e0 08 ret
2003a70: 91 e8 00 1d restore %g0, %i5, %o0
0200f388 <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)
{
200f388: 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;
200f38c: c2 06 80 00 ld [ %i2 ], %g1
if (args->command != RTEMS_BLKIO_REQUEST)
200f390: 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;
200f394: d0 00 60 30 ld [ %g1 + 0x30 ], %o0
if (args->command != RTEMS_BLKIO_REQUEST)
200f398: 03 30 06 10 sethi %hi(0xc0184000), %g1
200f39c: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
200f3a0: 80 a2 40 01 cmp %o1, %g1
200f3a4: 02 80 00 07 be 200f3c0 <rtems_blkdev_generic_ioctl+0x38> <== NEVER TAKEN
200f3a8: 82 10 3f ff mov -1, %g1
{
args->ioctl_return = dd->ioctl(dd,
200f3ac: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
200f3b0: 9f c0 40 00 call %g1
200f3b4: d4 06 a0 08 ld [ %i2 + 8 ], %o2
200f3b8: 10 80 00 03 b 200f3c4 <rtems_blkdev_generic_ioctl+0x3c>
200f3bc: d0 26 a0 0c st %o0, [ %i2 + 0xc ]
{
/*
* It is not allowed to directly access the driver circumventing the
* cache.
*/
args->ioctl_return = -1;
200f3c0: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
200f3c4: 81 c7 e0 08 ret
200f3c8: 91 e8 20 00 restore %g0, 0, %o0
0200f168 <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)
{
200f168: 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;
200f16c: 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);
200f170: 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;
200f174: 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);
200f178: 90 10 00 1c mov %i4, %o0
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
200f17c: e0 04 a0 24 ld [ %l2 + 0x24 ], %l0
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
200f180: 94 10 20 00 clr %o2
200f184: 96 10 00 10 mov %l0, %o3
200f188: 40 00 37 09 call 201cdac <__divdi3>
200f18c: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f190: 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);
200f194: a6 10 00 09 mov %o1, %l3
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f198: 94 10 20 00 clr %o2
200f19c: 92 10 00 1d mov %i5, %o1
200f1a0: 96 10 00 10 mov %l0, %o3
200f1a4: 40 00 37 ed call 201d158 <__moddi3>
200f1a8: f2 06 a0 10 ld [ %i2 + 0x10 ], %i1
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
200f1ac: f6 06 a0 14 ld [ %i2 + 0x14 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f1b0: a2 10 00 09 mov %o1, %l1
args->bytes_moved = 0;
200f1b4: c0 26 a0 1c clr [ %i2 + 0x1c ]
while (count > 0)
200f1b8: 10 80 00 1c b 200f228 <rtems_blkdev_generic_read+0xc0>
200f1bc: b8 10 20 00 clr %i4
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
200f1c0: 90 10 00 12 mov %l2, %o0
200f1c4: 7f ff fd a6 call 200e85c <rtems_bdbuf_read>
200f1c8: 94 07 bf fc add %fp, -4, %o2
if (rc != RTEMS_SUCCESSFUL)
200f1cc: 80 a2 20 00 cmp %o0, 0
200f1d0: 12 80 00 1a bne 200f238 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
200f1d4: ba 24 00 11 sub %l0, %l1, %i5
200f1d8: 80 a7 40 1b cmp %i5, %i3
200f1dc: 38 80 00 02 bgu,a 200f1e4 <rtems_blkdev_generic_read+0x7c><== NEVER TAKEN
200f1e0: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
200f1e4: c2 07 bf fc ld [ %fp + -4 ], %g1
200f1e8: 94 10 00 1d mov %i5, %o2
200f1ec: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
200f1f0: 90 10 00 19 mov %i1, %o0
200f1f4: 40 00 14 50 call 2014334 <memcpy>
200f1f8: 92 02 40 11 add %o1, %l1, %o1
rc = rtems_bdbuf_release(diskbuf);
200f1fc: d0 07 bf fc ld [ %fp + -4 ], %o0
200f200: 7f ff fe 13 call 200ea4c <rtems_bdbuf_release>
200f204: b8 07 20 01 inc %i4
args->bytes_moved += copy;
200f208: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
if (rc != RTEMS_SUCCESSFUL)
200f20c: 80 a2 20 00 cmp %o0, 0
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
200f210: 82 00 40 1d add %g1, %i5, %g1
if (rc != RTEMS_SUCCESSFUL)
200f214: 12 80 00 09 bne 200f238 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
200f218: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
break;
count -= copy;
200f21c: b6 26 c0 1d sub %i3, %i5, %i3
buf += copy;
200f220: b2 06 40 1d add %i1, %i5, %i1
blkofs = 0;
200f224: a2 10 20 00 clr %l1
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
while (count > 0)
200f228: 80 a6 e0 00 cmp %i3, 0
200f22c: 12 bf ff e5 bne 200f1c0 <rtems_blkdev_generic_read+0x58>
200f230: 92 07 00 13 add %i4, %l3, %o1
200f234: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
200f238: 81 c7 e0 08 ret
200f23c: 91 e8 00 08 restore %g0, %o0, %o0
0200f240 <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)
{
200f240: 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;
200f244: 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);
200f248: 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;
200f24c: 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);
200f250: 90 10 00 1c mov %i4, %o0
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
200f254: f2 04 60 24 ld [ %l1 + 0x24 ], %i1
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
200f258: 94 10 20 00 clr %o2
200f25c: 96 10 00 19 mov %i1, %o3
200f260: 40 00 36 d3 call 201cdac <__divdi3>
200f264: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f268: 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);
200f26c: a4 10 00 09 mov %o1, %l2
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f270: 94 10 20 00 clr %o2
200f274: 92 10 00 1d mov %i5, %o1
200f278: 96 10 00 19 mov %i1, %o3
200f27c: 40 00 37 b7 call 201d158 <__moddi3>
200f280: e0 06 a0 10 ld [ %i2 + 0x10 ], %l0
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
200f284: f6 06 a0 14 ld [ %i2 + 0x14 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f288: b8 10 00 09 mov %o1, %i4
args->bytes_moved = 0;
200f28c: c0 26 a0 1c clr [ %i2 + 0x1c ]
while (count > 0)
200f290: 10 80 00 26 b 200f328 <rtems_blkdev_generic_write+0xe8>
200f294: b0 10 20 00 clr %i0
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dd, block, &diskbuf);
200f298: 90 10 00 11 mov %l1, %o0
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
200f29c: 80 a6 c0 19 cmp %i3, %i1
200f2a0: 0a 80 00 09 bcs 200f2c4 <rtems_blkdev_generic_write+0x84> <== NEVER TAKEN
200f2a4: 94 07 bf fc add %fp, -4, %o2
200f2a8: 80 a7 20 00 cmp %i4, 0
200f2ac: 12 80 00 06 bne 200f2c4 <rtems_blkdev_generic_write+0x84> <== NEVER TAKEN
200f2b0: 01 00 00 00 nop
rc = rtems_bdbuf_get(dd, block, &diskbuf);
200f2b4: 7f ff fd 39 call 200e798 <rtems_bdbuf_get>
200f2b8: 01 00 00 00 nop
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
200f2bc: 10 80 00 05 b 200f2d0 <rtems_blkdev_generic_write+0x90>
200f2c0: 80 a2 20 00 cmp %o0, 0
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dd, block, &diskbuf);
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
200f2c4: 7f ff fd 66 call 200e85c <rtems_bdbuf_read> <== NOT EXECUTED
200f2c8: 01 00 00 00 nop <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
200f2cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200f2d0: 12 80 00 1a bne 200f338 <rtems_blkdev_generic_write+0xf8> <== NEVER TAKEN
200f2d4: ba 26 40 1c sub %i1, %i4, %i5
200f2d8: 80 a7 40 1b cmp %i5, %i3
200f2dc: 38 80 00 02 bgu,a 200f2e4 <rtems_blkdev_generic_write+0xa4><== NEVER TAKEN
200f2e0: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
200f2e4: c2 07 bf fc ld [ %fp + -4 ], %g1
200f2e8: 92 10 00 10 mov %l0, %o1
200f2ec: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
200f2f0: 94 10 00 1d mov %i5, %o2
200f2f4: 40 00 14 10 call 2014334 <memcpy>
200f2f8: 90 02 00 1c add %o0, %i4, %o0
args->bytes_moved += copy;
200f2fc: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
rc = rtems_bdbuf_release_modified(diskbuf);
200f300: 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;
200f304: 82 00 40 1d add %g1, %i5, %g1
200f308: b0 06 20 01 inc %i0
rc = rtems_bdbuf_release_modified(diskbuf);
200f30c: 7f ff fe 05 call 200eb20 <rtems_bdbuf_release_modified>
200f310: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
if (rc != RTEMS_SUCCESSFUL)
200f314: 80 a2 20 00 cmp %o0, 0
200f318: 12 80 00 08 bne 200f338 <rtems_blkdev_generic_write+0xf8> <== NEVER TAKEN
200f31c: b6 26 c0 1d sub %i3, %i5, %i3
break;
count -= copy;
buf += copy;
200f320: a0 04 00 1d add %l0, %i5, %l0
blkofs = 0;
200f324: b8 10 20 00 clr %i4
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
while (count > 0)
200f328: 80 a6 e0 00 cmp %i3, 0
200f32c: 12 bf ff db bne 200f298 <rtems_blkdev_generic_write+0x58>
200f330: 92 06 00 12 add %i0, %l2, %o1
200f334: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
200f338: 81 c7 e0 08 ret
200f33c: 91 e8 00 08 restore %g0, %o0, %o0
02003874 <rtems_blkdev_imfs_fsync_or_fdatasync>:
}
static int rtems_blkdev_imfs_fsync_or_fdatasync(
rtems_libio_t *iop
)
{
2003874: 9d e3 bf a0 save %sp, -96, %sp
static inline void *IMFS_generic_get_context_by_node(
const IMFS_jnode_t *node
)
{
return node->info.generic.context;
2003878: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
int rv = 0;
200387c: 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);
2003880: 40 00 2f e0 call 200f800 <rtems_bdbuf_syncdev>
2003884: d0 00 60 50 ld [ %g1 + 0x50 ], %o0
if (sc != RTEMS_SUCCESSFUL) {
2003888: 80 a2 20 00 cmp %o0, 0
200388c: 02 80 00 06 be 20038a4 <rtems_blkdev_imfs_fsync_or_fdatasync+0x30><== ALWAYS TAKEN
2003890: 01 00 00 00 nop
errno = EIO;
2003894: 40 00 41 d7 call 2013ff0 <__errno> <== NOT EXECUTED
2003898: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
200389c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20038a0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20038a4: 81 c7 e0 08 ret
20038a8: 81 e8 00 00 restore
020038ac <rtems_blkdev_imfs_ioctl>:
static int rtems_blkdev_imfs_ioctl(
rtems_libio_t *iop,
uint32_t request,
void *buffer
)
{
20038ac: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
20038b0: 03 30 06 10 sethi %hi(0xc0184000), %g1
20038b4: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
20038b8: 80 a6 40 01 cmp %i1, %g1
20038bc: 02 80 00 09 be 20038e0 <rtems_blkdev_imfs_ioctl+0x34> <== NEVER TAKEN
20038c0: 92 10 00 19 mov %i1, %o1
20038c4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
20038c8: 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);
20038cc: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
20038d0: 9f c0 40 00 call %g1
20038d4: 94 10 00 1a mov %i2, %o2
20038d8: 81 c7 e0 08 ret
20038dc: 91 e8 00 08 restore %g0, %o0, %o0
} else {
/*
* It is not allowed to directly access the driver circumventing the cache.
*/
errno = EINVAL;
20038e0: 40 00 41 c4 call 2013ff0 <__errno> <== NOT EXECUTED
20038e4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20038e8: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
20038ec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20038f0: 81 c7 e0 08 ret <== NOT EXECUTED
20038f4: 81 e8 00 00 restore <== NOT EXECUTED
020036f8 <rtems_blkdev_imfs_read>:
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
20036f8: 9d e3 bf 98 save %sp, -104, %sp
20036fc: 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;
2003700: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
2003704: e4 00 60 50 ld [ %g1 + 0x50 ], %l2
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003708: 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);
200370c: f6 04 a0 24 ld [ %l2 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003710: 90 10 00 1c mov %i4, %o0
2003714: a3 3e e0 1f sra %i3, 0x1f, %l1
2003718: 96 10 00 1b mov %i3, %o3
200371c: 40 00 67 85 call 201d530 <__divdi3>
2003720: 94 10 00 11 mov %l1, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
2003724: 94 10 00 11 mov %l1, %o2
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003728: a0 10 00 09 mov %o1, %l0
ssize_t block_offset = (ssize_t) (offset % block_size);
200372c: 90 10 00 1c mov %i4, %o0
2003730: 92 10 00 1d mov %i5, %o1
2003734: 96 10 00 1b mov %i3, %o3
2003738: 40 00 68 69 call 201d8dc <__moddi3>
200373c: ba 10 00 1a mov %i2, %i5
char *dst = buffer;
while (remaining > 0) {
2003740: 10 80 00 19 b 20037a4 <rtems_blkdev_imfs_read+0xac>
2003744: a2 10 00 09 mov %o1, %l1
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
2003748: 92 10 00 10 mov %l0, %o1
200374c: 40 00 2f 12 call 200f394 <rtems_bdbuf_read>
2003750: 94 07 bf fc add %fp, -4, %o2
if (sc == RTEMS_SUCCESSFUL) {
2003754: 80 a2 20 00 cmp %o0, 0
2003758: 12 80 00 1f bne 20037d4 <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
200375c: b8 26 c0 11 sub %i3, %l1, %i4
2003760: 80 a7 00 1d cmp %i4, %i5
2003764: 34 80 00 02 bg,a 200376c <rtems_blkdev_imfs_read+0x74>
2003768: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
200376c: c2 07 bf fc ld [ %fp + -4 ], %g1
2003770: 94 10 00 1c mov %i4, %o2
2003774: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
2003778: 90 10 00 19 mov %i1, %o0
200377c: 40 00 44 98 call 20149dc <memcpy>
2003780: 92 02 40 11 add %o1, %l1, %o1
sc = rtems_bdbuf_release(bd);
2003784: 40 00 2f 80 call 200f584 <rtems_bdbuf_release>
2003788: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
200378c: 80 a2 20 00 cmp %o0, 0
2003790: 12 80 00 11 bne 20037d4 <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
2003794: ba 27 40 1c sub %i5, %i4, %i5
block_offset = 0;
remaining -= copy;
dst += copy;
2003798: b2 06 40 1c add %i1, %i4, %i1
++block;
200379c: a0 04 20 01 inc %l0
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
sc = rtems_bdbuf_release(bd);
if (sc == RTEMS_SUCCESSFUL) {
block_offset = 0;
20037a0: a2 10 20 00 clr %l1
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
ssize_t block_offset = (ssize_t) (offset % block_size);
char *dst = buffer;
while (remaining > 0) {
20037a4: 80 a7 60 00 cmp %i5, 0
20037a8: 14 bf ff e8 bg 2003748 <rtems_blkdev_imfs_read+0x50>
20037ac: 90 10 00 12 mov %l2, %o0
} else {
remaining = -1;
}
}
if (remaining >= 0) {
20037b0: 80 a7 60 00 cmp %i5, 0
20037b4: 12 80 00 08 bne 20037d4 <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
20037b8: 01 00 00 00 nop
iop->offset += count;
20037bc: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
20037c0: 86 80 c0 1a addcc %g3, %i2, %g3
20037c4: 84 40 a0 00 addx %g2, 0, %g2
20037c8: c4 3e 20 08 std %g2, [ %i0 + 8 ]
rv = (ssize_t) count;
20037cc: 81 c7 e0 08 ret
20037d0: 91 e8 00 1a restore %g0, %i2, %o0
} else {
errno = EIO;
20037d4: 40 00 42 07 call 2013ff0 <__errno> <== NOT EXECUTED
20037d8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20037dc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20037e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20037e4: 81 c7 e0 08 ret <== NOT EXECUTED
20037e8: 81 e8 00 00 restore <== NOT EXECUTED
020035cc <rtems_blkdev_imfs_write>:
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
20035cc: 9d e3 bf 98 save %sp, -104, %sp
20035d0: 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;
20035d4: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
20035d8: e4 00 60 50 ld [ %g1 + 0x50 ], %l2
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
20035dc: 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);
20035e0: f6 04 a0 24 ld [ %l2 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
20035e4: 90 10 00 1c mov %i4, %o0
20035e8: a3 3e e0 1f sra %i3, 0x1f, %l1
20035ec: 96 10 00 1b mov %i3, %o3
20035f0: 40 00 67 d0 call 201d530 <__divdi3>
20035f4: 94 10 00 11 mov %l1, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
20035f8: 94 10 00 11 mov %l1, %o2
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
20035fc: a0 10 00 09 mov %o1, %l0
ssize_t block_offset = (ssize_t) (offset % block_size);
2003600: 90 10 00 1c mov %i4, %o0
2003604: 92 10 00 1d mov %i5, %o1
2003608: 96 10 00 1b mov %i3, %o3
200360c: 40 00 68 b4 call 201d8dc <__moddi3>
2003610: ba 10 00 1a mov %i2, %i5
const char *src = buffer;
while (remaining > 0) {
2003614: 10 80 00 27 b 20036b0 <rtems_blkdev_imfs_write+0xe4>
2003618: a2 10 00 09 mov %o1, %l1
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
200361c: 16 80 00 03 bge 2003628 <rtems_blkdev_imfs_write+0x5c>
2003620: 82 10 20 01 mov 1, %g1
2003624: 82 10 20 00 clr %g1
sc = rtems_bdbuf_get(dd, block, &bd);
2003628: 90 10 00 12 mov %l2, %o0
200362c: 92 10 00 10 mov %l0, %o1
while (remaining > 0) {
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
2003630: 80 88 60 ff btst 0xff, %g1
2003634: 02 80 00 09 be 2003658 <rtems_blkdev_imfs_write+0x8c>
2003638: 94 07 bf fc add %fp, -4, %o2
200363c: 80 a4 60 00 cmp %l1, 0
2003640: 12 80 00 06 bne 2003658 <rtems_blkdev_imfs_write+0x8c>
2003644: 01 00 00 00 nop
sc = rtems_bdbuf_get(dd, block, &bd);
2003648: 40 00 2f 22 call 200f2d0 <rtems_bdbuf_get>
200364c: 01 00 00 00 nop
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
2003650: 10 80 00 05 b 2003664 <rtems_blkdev_imfs_write+0x98>
2003654: 80 a2 20 00 cmp %o0, 0
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
sc = rtems_bdbuf_get(dd, block, &bd);
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
2003658: 40 00 2f 4f call 200f394 <rtems_bdbuf_read>
200365c: 01 00 00 00 nop
}
if (sc == RTEMS_SUCCESSFUL) {
2003660: 80 a2 20 00 cmp %o0, 0
2003664: 12 80 00 1f bne 20036e0 <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
2003668: b8 26 c0 11 sub %i3, %l1, %i4
200366c: 80 a7 00 1d cmp %i4, %i5
2003670: 34 80 00 02 bg,a 2003678 <rtems_blkdev_imfs_write+0xac>
2003674: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
2003678: c2 07 bf fc ld [ %fp + -4 ], %g1
200367c: 92 10 00 19 mov %i1, %o1
2003680: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2003684: 94 10 00 1c mov %i4, %o2
2003688: 40 00 44 d5 call 20149dc <memcpy>
200368c: 90 02 00 11 add %o0, %l1, %o0
sc = rtems_bdbuf_release_modified(bd);
2003690: 40 00 2f f2 call 200f658 <rtems_bdbuf_release_modified>
2003694: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
2003698: 80 a2 20 00 cmp %o0, 0
200369c: 12 80 00 11 bne 20036e0 <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
20036a0: ba 27 40 1c sub %i5, %i4, %i5
block_offset = 0;
remaining -= copy;
src += copy;
20036a4: b2 06 40 1c add %i1, %i4, %i1
++block;
20036a8: a0 04 20 01 inc %l0
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
sc = rtems_bdbuf_release_modified(bd);
if (sc == RTEMS_SUCCESSFUL) {
block_offset = 0;
20036ac: a2 10 20 00 clr %l1
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
ssize_t block_offset = (ssize_t) (offset % block_size);
const char *src = buffer;
while (remaining > 0) {
20036b0: 80 a7 60 00 cmp %i5, 0
20036b4: 14 bf ff da bg 200361c <rtems_blkdev_imfs_write+0x50>
20036b8: 80 a7 40 1b cmp %i5, %i3
} else {
remaining = -1;
}
}
if (remaining >= 0) {
20036bc: 80 a7 60 00 cmp %i5, 0
20036c0: 12 80 00 08 bne 20036e0 <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
20036c4: 01 00 00 00 nop
iop->offset += count;
20036c8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
20036cc: 86 80 c0 1a addcc %g3, %i2, %g3
20036d0: 84 40 a0 00 addx %g2, 0, %g2
20036d4: c4 3e 20 08 std %g2, [ %i0 + 8 ]
rv = (ssize_t) count;
20036d8: 81 c7 e0 08 ret
20036dc: 91 e8 00 1a restore %g0, %i2, %o0
} else {
errno = EIO;
20036e0: 40 00 42 44 call 2013ff0 <__errno> <== NOT EXECUTED
20036e4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20036e8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20036ec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20036f0: 81 c7 e0 08 ret <== NOT EXECUTED
20036f4: 81 e8 00 00 restore <== NOT EXECUTED
0200f010 <rtems_blkdev_ioctl>:
#include <rtems/blkdev.h>
#include <rtems/bdbuf.h>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200f010: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
switch (req)
200f014: 03 10 01 10 sethi %hi(0x40044000), %g1
200f018: 84 10 62 03 or %g1, 0x203, %g2 ! 40044203 <RAM_END+0x3dc44203>
200f01c: 80 a6 40 02 cmp %i1, %g2
200f020: 02 80 00 2f be 200f0dc <rtems_blkdev_ioctl+0xcc>
200f024: 90 10 00 18 mov %i0, %o0
200f028: 80 a6 40 02 cmp %i1, %g2
200f02c: 18 80 00 16 bgu 200f084 <rtems_blkdev_ioctl+0x74>
200f030: 84 10 62 09 or %g1, 0x209, %g2
200f034: 05 08 00 10 sethi %hi(0x20004000), %g2
200f038: 86 10 a2 0a or %g2, 0x20a, %g3 ! 2000420a <RAM_END+0x1dc0420a>
200f03c: 80 a6 40 03 cmp %i1, %g3
200f040: 02 80 00 38 be 200f120 <rtems_blkdev_ioctl+0x110>
200f044: 01 00 00 00 nop
200f048: 38 80 00 07 bgu,a 200f064 <rtems_blkdev_ioctl+0x54>
200f04c: 84 10 a2 0c or %g2, 0x20c, %g2
200f050: 84 10 a2 06 or %g2, 0x206, %g2
200f054: 80 a6 40 02 cmp %i1, %g2
200f058: 12 80 00 3d bne 200f14c <rtems_blkdev_ioctl+0x13c>
200f05c: 01 00 00 00 nop
200f060: 30 80 00 27 b,a 200f0fc <rtems_blkdev_ioctl+0xec>
200f064: 80 a6 40 02 cmp %i1, %g2
200f068: 02 80 00 35 be 200f13c <rtems_blkdev_ioctl+0x12c>
200f06c: 82 10 62 02 or %g1, 0x202, %g1
200f070: 80 a6 40 01 cmp %i1, %g1
200f074: 12 80 00 36 bne 200f14c <rtems_blkdev_ioctl+0x13c> <== NEVER TAKEN
200f078: 01 00 00 00 nop
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
200f07c: 10 80 00 16 b 200f0d4 <rtems_blkdev_ioctl+0xc4>
200f080: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
200f084: 80 a6 40 02 cmp %i1, %g2
200f088: 22 80 00 2f be,a 200f144 <rtems_blkdev_ioctl+0x134>
200f08c: f0 26 80 00 st %i0, [ %i2 ]
200f090: 38 80 00 08 bgu,a 200f0b0 <rtems_blkdev_ioctl+0xa0>
200f094: 82 10 62 0b or %g1, 0x20b, %g1
200f098: 82 10 62 05 or %g1, 0x205, %g1
200f09c: 80 a6 40 01 cmp %i1, %g1
200f0a0: 12 80 00 2b bne 200f14c <rtems_blkdev_ioctl+0x13c> <== NEVER TAKEN
200f0a4: 01 00 00 00 nop
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
200f0a8: 10 80 00 13 b 200f0f4 <rtems_blkdev_ioctl+0xe4>
200f0ac: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
200f0b0: 80 a6 40 01 cmp %i1, %g1
200f0b4: 02 80 00 1e be 200f12c <rtems_blkdev_ioctl+0x11c>
200f0b8: 03 20 01 10 sethi %hi(0x80044000), %g1
200f0bc: 82 10 62 04 or %g1, 0x204, %g1 ! 80044204 <RAM_END+0x7dc44204>
200f0c0: 80 a6 40 01 cmp %i1, %g1
200f0c4: 12 80 00 22 bne 200f14c <rtems_blkdev_ioctl+0x13c> <== NEVER TAKEN
200f0c8: 01 00 00 00 nop
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);
200f0cc: 10 80 00 06 b 200f0e4 <rtems_blkdev_ioctl+0xd4>
200f0d0: d2 06 80 00 ld [ %i2 ], %o1
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
200f0d4: 10 80 00 1c b 200f144 <rtems_blkdev_ioctl+0x134>
200f0d8: c2 26 80 00 st %g1, [ %i2 ]
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
200f0dc: 10 80 00 06 b 200f0f4 <rtems_blkdev_ioctl+0xe4>
200f0e0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
break;
case RTEMS_BLKIO_SETBLKSIZE:
sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp, true);
200f0e4: 7f ff ff 7c call 200eed4 <rtems_bdbuf_set_block_size>
200f0e8: 94 10 20 01 mov 1, %o2
*(rtems_blkdev_bnum *) argp = dd->size;
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
if (sc != RTEMS_SUCCESSFUL) {
200f0ec: 10 80 00 07 b 200f108 <rtems_blkdev_ioctl+0xf8>
200f0f0: 80 a2 20 00 cmp %o0, 0
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
200f0f4: 10 80 00 14 b 200f144 <rtems_blkdev_ioctl+0x134>
200f0f8: c2 26 80 00 st %g1, [ %i2 ]
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
200f0fc: 7f ff fe f3 call 200ecc8 <rtems_bdbuf_syncdev>
200f100: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
200f104: 80 a2 20 00 cmp %o0, 0
200f108: 22 80 00 16 be,a 200f160 <rtems_blkdev_ioctl+0x150> <== ALWAYS TAKEN
200f10c: b0 10 20 00 clr %i0
errno = EIO;
200f110: 40 00 12 38 call 20139f0 <__errno> <== NOT EXECUTED
200f114: 01 00 00 00 nop <== NOT EXECUTED
200f118: 10 80 00 10 b 200f158 <rtems_blkdev_ioctl+0x148> <== NOT EXECUTED
200f11c: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
case RTEMS_BLKIO_GETDISKDEV:
*(rtems_disk_device **) argp = dd;
break;
case RTEMS_BLKIO_PURGEDEV:
rtems_bdbuf_purge_dev(dd);
200f120: 7f ff ff 01 call 200ed24 <rtems_bdbuf_purge_dev>
200f124: b0 10 20 00 clr %i0
200f128: 30 80 00 0e b,a 200f160 <rtems_blkdev_ioctl+0x150>
break;
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
200f12c: 7f ff ff a7 call 200efc8 <rtems_bdbuf_get_device_stats>
200f130: 92 10 00 1a mov %i2, %o1
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
200f134: 81 c7 e0 08 ret
200f138: 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);
200f13c: 7f ff ff ac call 200efec <rtems_bdbuf_reset_device_stats>
200f140: 01 00 00 00 nop
break;
200f144: 81 c7 e0 08 ret
200f148: 91 e8 20 00 restore %g0, 0, %o0
default:
errno = EINVAL;
200f14c: 40 00 12 29 call 20139f0 <__errno>
200f150: 01 00 00 00 nop
200f154: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
200f158: c2 22 00 00 st %g1, [ %o0 ]
rc = -1;
200f15c: b0 10 3f ff mov -1, %i0
break;
}
return rc;
}
200f160: 81 c7 e0 08 ret
200f164: 81 e8 00 00 restore
020222e4 <rtems_blkstats>:
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
void rtems_blkstats(FILE *output, const char *device, bool reset)
{
20222e4: 9d e3 bf 38 save %sp, -200, %sp <== NOT EXECUTED
int fd = open(device, O_RDONLY);
20222e8: 92 10 20 00 clr %o1 <== NOT EXECUTED
20222ec: 7f ff 87 13 call 2003f38 <open> <== NOT EXECUTED
20222f0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if (fd >= 0) {
20222f4: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
20222f8: 06 80 00 51 bl 202243c <rtems_blkstats+0x158> <== NOT EXECUTED
20222fc: 01 00 00 00 nop <== NOT EXECUTED
struct stat st;
int rv;
rv = fstat(fd, &st);
2022300: 40 00 06 9a call 2023d68 <fstat> <== NOT EXECUTED
2022304: 92 07 bf b8 add %fp, -72, %o1 <== NOT EXECUTED
if (rv == 0) {
2022308: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
202230c: 12 80 00 34 bne 20223dc <rtems_blkstats+0xf8> <== NOT EXECUTED
2022310: c4 07 bf c4 ld [ %fp + -60 ], %g2 <== NOT EXECUTED
if (S_ISBLK(st.st_mode)) {
2022314: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
2022318: 84 08 80 01 and %g2, %g1, %g2 <== NOT EXECUTED
202231c: 03 00 00 18 sethi %hi(0x6000), %g1 <== NOT EXECUTED
2022320: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2022324: 32 80 00 2a bne,a 20223cc <rtems_blkstats+0xe8> <== NOT EXECUTED
2022328: 11 00 81 61 sethi %hi(0x2058400), %o0 <== NOT EXECUTED
if (reset) {
202232c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2022330: 02 80 00 11 be 2022374 <rtems_blkstats+0x90> <== NOT EXECUTED
2022334: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
}
static inline int rtems_disk_fd_reset_device_stats(int fd)
{
return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);
2022338: 13 08 00 10 sethi %hi(0x20004000), %o1 <== NOT EXECUTED
202233c: 40 00 09 48 call 202485c <ioctl> <== NOT EXECUTED
2022340: 92 12 62 0c or %o1, 0x20c, %o1 ! 2000420c <RAM_END+0x1dc0420c><== NOT EXECUTED
rv = rtems_disk_fd_reset_device_stats(fd);
if (rv != 0) {
2022344: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2022348: 02 80 00 2f be 2022404 <rtems_blkstats+0x120> <== NOT EXECUTED
202234c: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: reset stats: %s\n", strerror(errno));
2022350: 40 00 51 c1 call 2036a54 <__errno> <== NOT EXECUTED
2022354: 01 00 00 00 nop <== NOT EXECUTED
2022358: 40 00 6d 8c call 203d988 <strerror> <== NOT EXECUTED
202235c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2022360: 13 00 81 61 sethi %hi(0x2058400), %o1 <== NOT EXECUTED
2022364: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2022368: 92 12 61 40 or %o1, 0x140, %o1 <== NOT EXECUTED
202236c: 10 80 00 24 b 20223fc <rtems_blkstats+0x118> <== NOT EXECUTED
2022370: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
static inline int rtems_disk_fd_get_device_stats(
int fd,
rtems_blkdev_stats *stats
)
{
return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
2022374: 13 10 01 10 sethi %hi(0x40044000), %o1 <== NOT EXECUTED
2022378: 94 07 bf 98 add %fp, -104, %o2 <== NOT EXECUTED
202237c: 40 00 09 38 call 202485c <ioctl> <== NOT EXECUTED
2022380: 92 12 62 0b or %o1, 0x20b, %o1 <== NOT EXECUTED
}
} else {
rtems_blkdev_stats stats;
rv = rtems_disk_fd_get_device_stats(fd, &stats);
if (rv == 0) {
2022384: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2022388: 12 80 00 08 bne 20223a8 <rtems_blkstats+0xc4> <== NOT EXECUTED
202238c: 01 00 00 00 nop <== NOT EXECUTED
rtems_blkdev_print_stats(
2022390: 90 07 bf 98 add %fp, -104, %o0 <== NOT EXECUTED
2022394: 13 00 80 dd sethi %hi(0x2037400), %o1 <== NOT EXECUTED
2022398: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
202239c: 40 00 00 34 call 202246c <rtems_blkdev_print_stats> <== NOT EXECUTED
20223a0: 92 12 61 60 or %o1, 0x160, %o1 <== NOT EXECUTED
20223a4: 30 80 00 18 b,a 2022404 <rtems_blkstats+0x120> <== NOT EXECUTED
&stats,
(rtems_printk_plugin_t) fprintf,
output
);
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
20223a8: 40 00 51 ab call 2036a54 <__errno> <== NOT EXECUTED
20223ac: 01 00 00 00 nop <== NOT EXECUTED
20223b0: 40 00 6d 76 call 203d988 <strerror> <== NOT EXECUTED
20223b4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20223b8: 13 00 81 61 sethi %hi(0x2058400), %o1 <== NOT EXECUTED
20223bc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20223c0: 92 12 61 58 or %o1, 0x158, %o1 <== NOT EXECUTED
20223c4: 10 80 00 0e b 20223fc <rtems_blkstats+0x118> <== NOT EXECUTED
20223c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
}
} else {
fprintf(output, "error: not a block device\n");
20223cc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
20223d0: 40 00 54 b4 call 20376a0 <fputs> <== NOT EXECUTED
20223d4: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
20223d8: 30 80 00 0b b,a 2022404 <rtems_blkstats+0x120> <== NOT EXECUTED
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
20223dc: 40 00 51 9e call 2036a54 <__errno> <== NOT EXECUTED
20223e0: 01 00 00 00 nop <== NOT EXECUTED
20223e4: 40 00 6d 69 call 203d988 <strerror> <== NOT EXECUTED
20223e8: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20223ec: 13 00 81 61 sethi %hi(0x2058400), %o1 <== NOT EXECUTED
20223f0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20223f4: 92 12 61 90 or %o1, 0x190, %o1 <== NOT EXECUTED
20223f8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20223fc: 40 00 54 59 call 2037560 <fprintf> <== NOT EXECUTED
2022400: 01 00 00 00 nop <== NOT EXECUTED
}
rv = close(fd);
2022404: 40 00 05 d7 call 2023b60 <close> <== NOT EXECUTED
2022408: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
202240c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2022410: 02 80 00 15 be 2022464 <rtems_blkstats+0x180> <== NOT EXECUTED
2022414: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: close device: %s\n", strerror(errno));
2022418: 40 00 51 8f call 2036a54 <__errno> <== NOT EXECUTED
202241c: 01 00 00 00 nop <== NOT EXECUTED
2022420: 40 00 6d 5a call 203d988 <strerror> <== NOT EXECUTED
2022424: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2022428: 13 00 81 61 sethi %hi(0x2058400), %o1 <== NOT EXECUTED
202242c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2022430: 92 12 61 b0 or %o1, 0x1b0, %o1 <== NOT EXECUTED
2022434: 10 80 00 0a b 202245c <rtems_blkstats+0x178> <== NOT EXECUTED
2022438: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
} else {
fprintf(output, "error: open device: %s\n", strerror(errno));
202243c: 40 00 51 86 call 2036a54 <__errno> <== NOT EXECUTED
2022440: 01 00 00 00 nop <== NOT EXECUTED
2022444: 40 00 6d 51 call 203d988 <strerror> <== NOT EXECUTED
2022448: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
202244c: 13 00 81 61 sethi %hi(0x2058400), %o1 <== NOT EXECUTED
2022450: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2022454: 92 12 61 d0 or %o1, 0x1d0, %o1 <== NOT EXECUTED
2022458: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
202245c: 40 00 54 41 call 2037560 <fprintf> <== NOT EXECUTED
2022460: 01 00 00 00 nop <== NOT EXECUTED
2022464: 81 c7 e0 08 ret <== NOT EXECUTED
2022468: 81 e8 00 00 restore <== NOT EXECUTED
02008338 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
2008338: 9d e3 bf 98 save %sp, -104, %sp
200833c: 30 80 00 08 b,a 200835c <rtems_chain_get_with_wait+0x24>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
2008340: 92 10 20 00 clr %o1
2008344: 94 10 00 1a mov %i2, %o2
2008348: 7f ff fc fb call 2007734 <rtems_event_receive>
200834c: 96 07 bf fc add %fp, -4, %o3
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
2008350: 80 a2 20 00 cmp %o0, 0
2008354: 32 80 00 09 bne,a 2008378 <rtems_chain_get_with_wait+0x40><== ALWAYS TAKEN
2008358: fa 26 c0 00 st %i5, [ %i3 ]
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
200835c: 40 00 01 95 call 20089b0 <_Chain_Get>
2008360: 90 10 00 18 mov %i0, %o0
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
2008364: ba 92 20 00 orcc %o0, 0, %i5
2008368: 02 bf ff f6 be 2008340 <rtems_chain_get_with_wait+0x8>
200836c: 90 10 00 19 mov %i1, %o0
2008370: 90 10 20 00 clr %o0
timeout,
&out
);
}
*node_ptr = node;
2008374: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
2008378: 81 c7 e0 08 ret
200837c: 91 e8 00 08 restore %g0, %o0, %o0
02003a40 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
2003a40: 9d e3 bf 70 save %sp, -144, %sp
uint32_t seconds, nanoseconds;
#else
uint32_t total_units = 0;
#endif
if ( !print )
2003a44: 80 a6 60 00 cmp %i1, 0
2003a48: 02 80 00 7c be 2003c38 <rtems_cpu_usage_report_with_plugin+0x1f8><== NEVER TAKEN
2003a4c: 03 00 80 81 sethi %hi(0x2020400), %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
2003a50: c0 27 bf e0 clr [ %fp + -32 ]
2003a54: c0 27 bf e4 clr [ %fp + -28 ]
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
2003a58: f8 18 63 d0 ldd [ %g1 + 0x3d0 ], %i4
}
}
}
#endif
(*print)(
2003a5c: 90 10 00 18 mov %i0, %o0
2003a60: 13 00 80 74 sethi %hi(0x201d000), %o1
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
2003a64: 29 00 80 74 sethi %hi(0x201d000), %l4
}
}
}
#endif
(*print)(
2003a68: 92 12 62 60 or %o1, 0x260, %o1
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
2003a6c: 27 00 80 80 sethi %hi(0x2020000), %l3
2003a70: 9f c6 40 00 call %i1
2003a74: 2b 00 80 74 sethi %hi(0x201d000), %l5
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
2003a78: a2 10 20 01 mov 1, %l1
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
2003a7c: a8 15 23 d8 or %l4, 0x3d8, %l4
2003a80: a6 14 e1 60 or %l3, 0x160, %l3
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2003a84: aa 15 63 f0 or %l5, 0x3f0, %l5
#endif
/*
* rtems_cpu_usage_report
*/
void rtems_cpu_usage_report_with_plugin(
2003a88: 83 2c 60 02 sll %l1, 2, %g1
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
2003a8c: 05 00 80 80 sethi %hi(0x2020000), %g2
2003a90: 84 10 a1 74 or %g2, 0x174, %g2 ! 2020174 <_Objects_Information_table>
2003a94: c2 00 80 01 ld [ %g2 + %g1 ], %g1
2003a98: e4 00 60 04 ld [ %g1 + 4 ], %l2
if ( information ) {
2003a9c: 80 a4 a0 00 cmp %l2, 0
2003aa0: 12 80 00 4a bne 2003bc8 <rtems_cpu_usage_report_with_plugin+0x188><== ALWAYS TAKEN
2003aa4: a0 10 20 01 mov 1, %l0
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
2003aa8: a2 04 60 01 inc %l1 <== NOT EXECUTED
2003aac: 80 a4 60 04 cmp %l1, 4
2003ab0: 12 bf ff f7 bne 2003a8c <rtems_cpu_usage_report_with_plugin+0x4c>
2003ab4: 83 2c 60 02 sll %l1, 2, %g1
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
2003ab8: 10 80 00 4a b 2003be0 <rtems_cpu_usage_report_with_plugin+0x1a0>
2003abc: f8 1f bf e0 ldd [ %fp + -32 ], %i4
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
2003ac0: 83 2c 20 02 sll %l0, 2, %g1
2003ac4: f6 00 80 01 ld [ %g2 + %g1 ], %i3
if ( !the_thread )
2003ac8: 80 a6 e0 00 cmp %i3, 0
2003acc: 02 80 00 3e be 2003bc4 <rtems_cpu_usage_report_with_plugin+0x184><== NEVER TAKEN
2003ad0: 92 10 20 0d mov 0xd, %o1
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
2003ad4: d0 06 e0 08 ld [ %i3 + 8 ], %o0
2003ad8: 40 00 13 92 call 2008920 <rtems_object_get_name>
2003adc: 94 07 bf f0 add %fp, -16, %o2
(*print)(
2003ae0: d4 06 e0 08 ld [ %i3 + 8 ], %o2
2003ae4: 90 10 00 18 mov %i0, %o0
2003ae8: 92 10 00 14 mov %l4, %o1
2003aec: 9f c6 40 00 call %i1
2003af0: 96 07 bf f0 add %fp, -16, %o3
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
2003af4: 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 ) {
2003af8: 03 00 80 81 sethi %hi(0x2020400), %g1
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
2003afc: c4 3f bf e8 std %g2, [ %fp + -24 ]
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
2003b00: 82 10 63 70 or %g1, 0x370, %g1
2003b04: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
2003b08: c6 00 a0 08 ld [ %g2 + 8 ], %g3
2003b0c: c4 06 e0 08 ld [ %i3 + 8 ], %g2
2003b10: 80 a0 c0 02 cmp %g3, %g2
2003b14: 12 80 00 4b bne 2003c40 <rtems_cpu_usage_report_with_plugin+0x200>
2003b18: 90 07 bf d8 add %fp, -40, %o0
*time_of_context_switch = _Thread_Time_of_last_context_switch;
2003b1c: f4 18 60 20 ldd [ %g1 + 0x20 ], %i2
2003b20: 40 00 18 96 call 2009d78 <_TOD_Get_with_nanoseconds>
2003b24: 92 10 00 13 mov %l3, %o1
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2003b28: d8 1f bf e8 ldd [ %fp + -24 ], %o4
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2003b2c: c4 1f bf d8 ldd [ %fp + -40 ], %g2
2003b30: 86 a0 c0 1b subcc %g3, %i3, %g3
2003b34: 84 60 80 1a subx %g2, %i2, %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2003b38: 96 83 40 03 addcc %o5, %g3, %o3
2003b3c: 94 43 00 02 addx %o4, %g2, %o2
2003b40: d4 3f bf e8 std %o2, [ %fp + -24 ]
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2003b44: c4 1f bf d8 ldd [ %fp + -40 ], %g2
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
_Timestamp_Divide( &ran, &total, &ival, &fval );
2003b48: 90 07 bf e8 add %fp, -24, %o0
2003b4c: 86 a0 c0 1d subcc %g3, %i5, %g3
2003b50: 84 60 80 1c subx %g2, %i4, %g2
2003b54: 92 07 bf e0 add %fp, -32, %o1
2003b58: c4 3f bf e0 std %g2, [ %fp + -32 ]
2003b5c: 94 07 bf d0 add %fp, -48, %o2
2003b60: 40 00 22 15 call 200c3b4 <_Timestamp64_Divide>
2003b64: 96 07 bf d4 add %fp, -44, %o3
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
2003b68: 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);
2003b6c: 94 10 20 00 clr %o2
2003b70: 90 10 00 1a mov %i2, %o0
2003b74: 92 10 00 1b mov %i3, %o1
2003b78: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003b7c: 40 00 5c 27 call 201ac18 <__divdi3>
2003b80: 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);
2003b84: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003b88: ac 10 00 09 mov %o1, %l6
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2003b8c: 90 10 00 1a mov %i2, %o0
2003b90: 92 10 00 1b mov %i3, %o1
2003b94: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003b98: 40 00 5d 0b call 201afc4 <__moddi3>
2003b9c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
2003ba0: 90 10 00 09 mov %o1, %o0
2003ba4: 40 00 5a c5 call 201a6b8 <.udiv>
2003ba8: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2003bac: d8 1f bf d0 ldd [ %fp + -48 ], %o4
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
2003bb0: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2003bb4: 92 10 00 15 mov %l5, %o1
2003bb8: 90 10 00 18 mov %i0, %o0
2003bbc: 9f c6 40 00 call %i1
2003bc0: 94 10 00 16 mov %l6, %o2
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
2003bc4: a0 04 20 01 inc %l0
2003bc8: c2 14 a0 10 lduh [ %l2 + 0x10 ], %g1
2003bcc: 80 a4 00 01 cmp %l0, %g1
2003bd0: 28 bf ff bc bleu,a 2003ac0 <rtems_cpu_usage_report_with_plugin+0x80>
2003bd4: c4 04 a0 1c ld [ %l2 + 0x1c ], %g2
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
2003bd8: 10 bf ff b5 b 2003aac <rtems_cpu_usage_report_with_plugin+0x6c>
2003bdc: a2 04 60 01 inc %l1
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003be0: 94 10 20 00 clr %o2
2003be4: 90 10 00 1c mov %i4, %o0
2003be8: 92 10 00 1d mov %i5, %o1
2003bec: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003bf0: 40 00 5c 0a call 201ac18 <__divdi3>
2003bf4: 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);
2003bf8: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003bfc: b6 10 00 09 mov %o1, %i3
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2003c00: 90 10 00 1c mov %i4, %o0
2003c04: 92 10 00 1d mov %i5, %o1
2003c08: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003c0c: 40 00 5c ee call 201afc4 <__moddi3>
2003c10: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
2003c14: 90 10 00 09 mov %o1, %o0
2003c18: 40 00 5a a8 call 201a6b8 <.udiv>
2003c1c: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
2003c20: 13 00 80 75 sethi %hi(0x201d400), %o1
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
2003c24: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
2003c28: 92 12 60 08 or %o1, 8, %o1
2003c2c: 90 10 00 18 mov %i0, %o0
2003c30: 9f c6 40 00 call %i1
2003c34: 94 10 00 1b mov %i3, %o2
2003c38: 81 c7 e0 08 ret
2003c3c: 81 e8 00 00 restore
2003c40: 40 00 18 4e call 2009d78 <_TOD_Get_with_nanoseconds>
2003c44: 92 10 00 13 mov %l3, %o1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2003c48: 10 bf ff c0 b 2003b48 <rtems_cpu_usage_report_with_plugin+0x108>
2003c4c: c4 1f bf d8 ldd [ %fp + -40 ], %g2
0200f584 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
200f584: 9d e3 bf a0 save %sp, -96, %sp
if (sc == RTEMS_SUCCESSFUL) {
200f588: 80 a6 20 00 cmp %i0, 0
200f58c: 02 80 00 0d be 200f5c0 <rtems_deviceio_errno+0x3c>
200f590: 82 10 20 00 clr %g1
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
200f594: 80 a6 20 1c cmp %i0, 0x1c
200f598: 18 80 00 06 bgu 200f5b0 <rtems_deviceio_errno+0x2c> <== NEVER TAKEN
200f59c: ba 10 20 16 mov 0x16, %i5
eno = status_code_to_errno [sc];
200f5a0: b1 2e 20 02 sll %i0, 2, %i0
200f5a4: 03 00 80 6e sethi %hi(0x201b800), %g1
200f5a8: 82 10 63 a4 or %g1, 0x3a4, %g1 ! 201bba4 <status_code_to_errno>
200f5ac: fa 00 40 18 ld [ %g1 + %i0 ], %i5
}
errno = eno;
200f5b0: 40 00 00 2f call 200f66c <__errno>
200f5b4: 01 00 00 00 nop
return -1;
200f5b8: 82 10 3f ff mov -1, %g1 ! ffffffff <RAM_END+0xfdbfffff>
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
}
errno = eno;
200f5bc: fa 22 00 00 st %i5, [ %o0 ]
return -1;
}
}
200f5c0: 81 c7 e0 08 ret
200f5c4: 91 e8 00 01 restore %g0, %g1, %o0
02003968 <rtems_disk_create_log>:
dev_t phys,
rtems_blkdev_bnum block_begin,
rtems_blkdev_bnum block_count,
const char *name
)
{
2003968: 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;
200396c: c0 27 bf f8 clr [ %fp + -8 ]
char *alloc_name = NULL;
sc = disk_lock();
2003970: 7f ff ff 11 call 20035b4 <disk_lock>
2003974: c0 27 bf fc clr [ %fp + -4 ]
if (sc != RTEMS_SUCCESSFUL) {
2003978: a0 92 20 00 orcc %o0, 0, %l0
200397c: 32 80 00 2b bne,a 2003a28 <rtems_disk_create_log+0xc0> <== NEVER TAKEN
2003980: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
return sc;
}
phys_dd = get_disk_entry(phys, true);
2003984: 92 10 00 1b mov %i3, %o1
2003988: 90 10 00 1a mov %i2, %o0
200398c: 7f ff fe cf call 20034c8 <get_disk_entry>
2003990: 94 10 20 01 mov 1, %o2
if (phys_dd == NULL) {
2003994: b6 92 20 00 orcc %o0, 0, %i3
2003998: 12 80 00 06 bne 20039b0 <rtems_disk_create_log+0x48>
200399c: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
disk_unlock();
20039a0: 7f ff ff 14 call 20035f0 <disk_unlock>
20039a4: a0 10 20 04 mov 4, %l0
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
20039a8: 81 c7 e0 08 ret
20039ac: 91 e8 00 10 restore %g0, %l0, %o0
disk_unlock();
return RTEMS_INVALID_ID;
}
sc = create_disk(dev, name, &dd, &alloc_name);
20039b0: 90 10 00 18 mov %i0, %o0
20039b4: 92 10 00 19 mov %i1, %o1
20039b8: 96 07 bf f8 add %fp, -8, %o3
20039bc: 7f ff ff 1a call 2003624 <create_disk>
20039c0: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
20039c4: a0 92 20 00 orcc %o0, 0, %l0
20039c8: 12 80 00 16 bne 2003a20 <rtems_disk_create_log+0xb8>
20039cc: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_log(
20039d0: 92 10 00 1b mov %i3, %o1
20039d4: 94 10 00 1c mov %i4, %o2
20039d8: 40 00 2e ea call 200f580 <rtems_disk_init_log>
20039dc: 96 10 00 1d mov %i5, %o3
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
20039e0: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
20039e4: c4 07 bf fc ld [ %fp + -4 ], %g2
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
20039e8: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
20039ec: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
++phys_dd->uses;
20039f0: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
disk_unlock();
return sc;
}
sc = rtems_disk_init_log(
20039f4: a0 10 00 08 mov %o0, %l0
);
dd->dev = dev;
dd->name = alloc_name;
++phys_dd->uses;
20039f8: 84 00 a0 01 inc %g2
if (sc != RTEMS_SUCCESSFUL) {
20039fc: 80 a2 20 00 cmp %o0, 0
2003a00: 02 80 00 08 be 2003a20 <rtems_disk_create_log+0xb8>
2003a04: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
dd->ioctl = null_handler;
2003a08: 05 00 80 0d sethi %hi(0x2003400), %g2
2003a0c: 84 10 a1 58 or %g2, 0x158, %g2 ! 2003558 <null_handler>
rtems_disk_delete(dev);
2003a10: 90 10 00 18 mov %i0, %o0
dd->name = alloc_name;
++phys_dd->uses;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
2003a14: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
2003a18: 7f ff ff 6c call 20037c8 <rtems_disk_delete>
2003a1c: 92 10 00 19 mov %i1, %o1
disk_unlock();
return sc;
}
disk_unlock();
2003a20: 7f ff fe f4 call 20035f0 <disk_unlock>
2003a24: b0 10 00 10 mov %l0, %i0
return RTEMS_SUCCESSFUL;
}
2003a28: 81 c7 e0 08 ret
2003a2c: 81 e8 00 00 restore
02003a30 <rtems_disk_create_phys>:
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
2003a30: 9d e3 bf 98 save %sp, -104, %sp
rtems_disk_device *dd = NULL;
2003a34: c0 27 bf f8 clr [ %fp + -8 ]
rtems_status_code sc = RTEMS_SUCCESSFUL;
char *alloc_name = NULL;
2003a38: c0 27 bf fc clr [ %fp + -4 ]
if (handler == NULL) {
2003a3c: 80 a7 20 00 cmp %i4, 0
2003a40: 02 80 00 23 be 2003acc <rtems_disk_create_phys+0x9c>
2003a44: a0 10 20 09 mov 9, %l0
return RTEMS_INVALID_ADDRESS;
}
sc = disk_lock();
2003a48: 7f ff fe db call 20035b4 <disk_lock>
2003a4c: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003a50: a0 92 20 00 orcc %o0, 0, %l0
2003a54: 12 80 00 1e bne 2003acc <rtems_disk_create_phys+0x9c> <== NEVER TAKEN
2003a58: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
return sc;
}
sc = create_disk(dev, name, &dd, &alloc_name);
2003a5c: 90 10 00 18 mov %i0, %o0
2003a60: 92 10 00 19 mov %i1, %o1
2003a64: 96 07 bf f8 add %fp, -8, %o3
2003a68: 7f ff fe ef call 2003624 <create_disk>
2003a6c: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
2003a70: a0 92 20 00 orcc %o0, 0, %l0
2003a74: 12 80 00 14 bne 2003ac4 <rtems_disk_create_phys+0x94>
2003a78: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_phys(
2003a7c: 92 10 00 1a mov %i2, %o1
2003a80: 94 10 00 1b mov %i3, %o2
2003a84: 96 10 00 1c mov %i4, %o3
2003a88: 40 00 2e a4 call 200f518 <rtems_disk_init_phys>
2003a8c: 98 10 00 1d mov %i5, %o4
block_count,
handler,
driver_data
);
dd->dev = dev;
2003a90: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
2003a94: c4 07 bf fc ld [ %fp + -4 ], %g2
block_count,
handler,
driver_data
);
dd->dev = dev;
2003a98: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
2003a9c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if (sc != RTEMS_SUCCESSFUL) {
2003aa0: 80 a2 20 00 cmp %o0, 0
2003aa4: 02 80 00 08 be 2003ac4 <rtems_disk_create_phys+0x94>
2003aa8: a0 10 00 08 mov %o0, %l0
dd->ioctl = null_handler;
2003aac: 05 00 80 0d sethi %hi(0x2003400), %g2
2003ab0: 84 10 a1 58 or %g2, 0x158, %g2 ! 2003558 <null_handler>
rtems_disk_delete(dev);
2003ab4: 90 10 00 18 mov %i0, %o0
dd->dev = dev;
dd->name = alloc_name;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
2003ab8: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
2003abc: 7f ff ff 43 call 20037c8 <rtems_disk_delete>
2003ac0: 92 10 00 19 mov %i1, %o1
disk_unlock();
return sc;
}
disk_unlock();
2003ac4: 7f ff fe cb call 20035f0 <disk_unlock>
2003ac8: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
2003acc: 81 c7 e0 08 ret
2003ad0: 91 e8 00 10 restore %g0, %l0, %o0
020037c8 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
20037c8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
20037cc: 7f ff ff 7a call 20035b4 <disk_lock>
20037d0: b8 10 00 18 mov %i0, %i4
if (sc != RTEMS_SUCCESSFUL) {
20037d4: b0 92 20 00 orcc %o0, 0, %i0
20037d8: 12 80 00 0a bne 2003800 <rtems_disk_delete+0x38> <== NEVER TAKEN
20037dc: 90 10 00 1c mov %i4, %o0
return sc;
}
dd = get_disk_entry(dev, true);
20037e0: 92 10 00 19 mov %i1, %o1
20037e4: 7f ff ff 39 call 20034c8 <get_disk_entry>
20037e8: 94 10 20 01 mov 1, %o2
if (dd == NULL) {
20037ec: 82 92 20 00 orcc %o0, 0, %g1
20037f0: 32 80 00 06 bne,a 2003808 <rtems_disk_delete+0x40> <== ALWAYS TAKEN
20037f4: fa 00 60 08 ld [ %g1 + 8 ], %i5
disk_unlock();
20037f8: 7f ff ff 7e call 20035f0 <disk_unlock> <== NOT EXECUTED
20037fc: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2003800: 81 c7 e0 08 ret <== NOT EXECUTED
2003804: 81 e8 00 00 restore <== NOT EXECUTED
return RTEMS_INVALID_ID;
}
dd->deleted = true;
2003808: 84 10 20 01 mov 1, %g2
200380c: 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) {
2003810: c4 0f 60 40 ldub [ %i5 + 0x40 ], %g2
2003814: 80 a0 a0 00 cmp %g2, 0
2003818: 22 80 00 41 be,a 200391c <rtems_disk_delete+0x154>
200381c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
dev_t dev = physical_disk->dev;
2003820: e2 07 40 00 ld [ %i5 ], %l1
2003824: e4 07 60 04 ld [ %i5 + 4 ], %l2
unsigned deleted_count = 0;
2003828: b4 10 20 00 clr %i2
for (major = 0; major < disktab_size; ++major) {
200382c: b8 10 20 00 clr %i4
2003830: 21 00 80 85 sethi %hi(0x2021400), %l0
rtems_disk_device_table *dtab = disktab + major;
2003834: 27 00 80 85 sethi %hi(0x2021400), %l3
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
2003838: 10 80 00 26 b 20038d0 <rtems_disk_delete+0x108>
200383c: a8 10 20 01 mov 1, %l4
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
2003840: 83 2f 20 03 sll %i4, 3, %g1
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
2003844: b6 10 20 00 clr %i3
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
2003848: 10 80 00 1d b 20038bc <rtems_disk_delete+0xf4>
200384c: b2 06 40 01 add %i1, %g1, %i1
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
2003850: 85 2e e0 02 sll %i3, 2, %g2
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
2003854: d0 00 c0 02 ld [ %g3 + %g2 ], %o0
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
2003858: 80 a2 20 00 cmp %o0, 0
200385c: 22 80 00 18 be,a 20038bc <rtems_disk_delete+0xf4>
2003860: b6 06 e0 01 inc %i3
2003864: c8 02 20 08 ld [ %o0 + 8 ], %g4
2003868: de 01 00 00 ld [ %g4 ], %o7
200386c: 80 a3 c0 11 cmp %o7, %l1
2003870: 32 80 00 13 bne,a 20038bc <rtems_disk_delete+0xf4> <== NEVER TAKEN
2003874: b6 06 e0 01 inc %i3 <== NOT EXECUTED
2003878: c8 01 20 04 ld [ %g4 + 4 ], %g4
200387c: 80 a1 00 12 cmp %g4, %l2
2003880: 32 80 00 0f bne,a 20038bc <rtems_disk_delete+0xf4> <== NEVER TAKEN
2003884: b6 06 e0 01 inc %i3 <== NOT EXECUTED
2003888: 80 a2 00 1d cmp %o0, %i5
200388c: 22 80 00 0c be,a 20038bc <rtems_disk_delete+0xf4>
2003890: b6 06 e0 01 inc %i3
if (dd->uses == 0) {
2003894: c8 02 20 14 ld [ %o0 + 0x14 ], %g4
2003898: 80 a1 20 00 cmp %g4, 0
200389c: 32 80 00 07 bne,a 20038b8 <rtems_disk_delete+0xf0>
20038a0: e8 2a 20 40 stb %l4, [ %o0 + 0x40 ]
++deleted_count;
20038a4: b4 06 a0 01 inc %i2
dtab->minor [minor] = NULL;
free_disk_device(dd);
20038a8: 7f ff ff 2e call 2003560 <free_disk_device>
20038ac: 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) {
20038b0: 10 80 00 03 b 20038bc <rtems_disk_delete+0xf4>
20038b4: b6 06 e0 01 inc %i3
20038b8: b6 06 e0 01 inc %i3
20038bc: c2 06 60 04 ld [ %i1 + 4 ], %g1
20038c0: 80 a6 c0 01 cmp %i3, %g1
20038c4: 2a bf ff e3 bcs,a 2003850 <rtems_disk_delete+0x88>
20038c8: c6 06 40 00 ld [ %i1 ], %g3
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
20038cc: b8 07 20 01 inc %i4
20038d0: c2 04 21 30 ld [ %l0 + 0x130 ], %g1
20038d4: 80 a7 00 01 cmp %i4, %g1
20038d8: 2a bf ff da bcs,a 2003840 <rtems_disk_delete+0x78>
20038dc: f2 04 e1 34 ld [ %l3 + 0x134 ], %i1
}
}
}
}
physical_disk->uses -= deleted_count;
20038e0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
20038e4: b4 20 40 1a sub %g1, %i2, %i2
if (physical_disk->uses == 0) {
20038e8: 80 a6 a0 00 cmp %i2, 0
20038ec: 12 80 00 1b bne 2003958 <rtems_disk_delete+0x190>
20038f0: f4 27 60 14 st %i2, [ %i5 + 0x14 ]
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
20038f4: c4 07 40 00 ld [ %i5 ], %g2
disktab [major].minor [minor] = NULL;
20038f8: 07 00 80 85 sethi %hi(0x2021400), %g3
20038fc: c6 00 e1 34 ld [ %g3 + 0x134 ], %g3 ! 2021534 <disktab>
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
2003900: c2 07 60 04 ld [ %i5 + 4 ], %g1
disktab [major].minor [minor] = NULL;
2003904: 85 28 a0 03 sll %g2, 3, %g2
2003908: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
200390c: 83 28 60 02 sll %g1, 2, %g1
free_disk_device(physical_disk);
2003910: 90 10 00 1d mov %i5, %o0
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
disktab [major].minor [minor] = NULL;
2003914: 10 80 00 0f b 2003950 <rtems_disk_delete+0x188>
2003918: c0 20 80 01 clr [ %g2 + %g1 ]
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
200391c: 80 a0 a0 00 cmp %g2, 0
2003920: 12 80 00 0e bne 2003958 <rtems_disk_delete+0x190> <== NEVER TAKEN
2003924: 07 00 80 85 sethi %hi(0x2021400), %g3
--physical_disk->uses;
2003928: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
200392c: 84 00 bf ff add %g2, -1, %g2
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
2003930: c6 00 e1 34 ld [ %g3 + 0x134 ], %g3
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
2003934: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
2003938: c4 00 40 00 ld [ %g1 ], %g2
200393c: c2 00 60 04 ld [ %g1 + 4 ], %g1
disktab [major].minor [minor] = NULL;
2003940: 85 28 a0 03 sll %g2, 3, %g2
2003944: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
2003948: 83 28 60 02 sll %g1, 2, %g1
200394c: c0 20 80 01 clr [ %g2 + %g1 ]
free_disk_device(disk_to_remove);
2003950: 7f ff ff 04 call 2003560 <free_disk_device>
2003954: 01 00 00 00 nop
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
2003958: 7f ff ff 26 call 20035f0 <disk_unlock>
200395c: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
2003960: 81 c7 e0 08 ret
2003964: 81 e8 00 00 restore
02003c88 <rtems_disk_io_initialize>:
rtems_status_code
rtems_disk_io_initialize(void)
{
2003c88: 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) {
2003c8c: 39 00 80 85 sethi %hi(0x2021400), %i4
2003c90: c2 07 21 30 ld [ %i4 + 0x130 ], %g1 ! 2021530 <disktab_size>
2003c94: 80 a0 60 00 cmp %g1, 0
2003c98: 12 80 00 19 bne 2003cfc <rtems_disk_io_initialize+0x74>
2003c9c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
2003ca0: 90 10 20 08 mov 8, %o0
2003ca4: 92 10 20 08 mov 8, %o1
2003ca8: 40 00 02 09 call 20044cc <calloc>
2003cac: 3b 00 80 85 sethi %hi(0x2021400), %i5
2003cb0: d0 27 61 34 st %o0, [ %i5 + 0x134 ] ! 2021534 <disktab>
if (disktab == NULL) {
2003cb4: 80 a2 20 00 cmp %o0, 0
2003cb8: 02 80 00 11 be 2003cfc <rtems_disk_io_initialize+0x74> <== NEVER TAKEN
2003cbc: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
2003cc0: 03 00 80 85 sethi %hi(0x2021400), %g1
sc = rtems_semaphore_create(
2003cc4: 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;
2003cc8: c0 28 61 28 clrb [ %g1 + 0x128 ]
sc = rtems_semaphore_create(
2003ccc: 90 12 21 56 or %o0, 0x156, %o0
2003cd0: 92 10 20 01 mov 1, %o1
2003cd4: 94 10 20 10 mov 0x10, %o2
2003cd8: 96 10 20 00 clr %o3
2003cdc: 37 00 80 85 sethi %hi(0x2021400), %i3
2003ce0: 40 00 12 e9 call 2008884 <rtems_semaphore_create>
2003ce4: 98 16 e1 2c or %i3, 0x12c, %o4 ! 202152c <diskdevs_mutex>
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
2003ce8: 80 a2 20 00 cmp %o0, 0
2003cec: 02 80 00 06 be 2003d04 <rtems_disk_io_initialize+0x7c> <== ALWAYS TAKEN
2003cf0: 01 00 00 00 nop
free(disktab);
2003cf4: 40 00 02 ca call 200481c <free> <== NOT EXECUTED
2003cf8: d0 07 61 34 ld [ %i5 + 0x134 ], %o0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
2003cfc: 81 c7 e0 08 ret
2003d00: 81 e8 00 00 restore
}
sc = rtems_bdbuf_init();
2003d04: 40 00 29 93 call 200e350 <rtems_bdbuf_init>
2003d08: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003d0c: 80 a2 20 00 cmp %o0, 0
2003d10: 02 80 00 09 be 2003d34 <rtems_disk_io_initialize+0xac> <== ALWAYS TAKEN
2003d14: 82 10 20 08 mov 8, %g1
rtems_semaphore_delete(diskdevs_mutex);
2003d18: d0 06 e1 2c ld [ %i3 + 0x12c ], %o0 <== NOT EXECUTED
2003d1c: 40 00 13 48 call 2008a3c <rtems_semaphore_delete> <== NOT EXECUTED
2003d20: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
free(disktab);
2003d24: 40 00 02 be call 200481c <free> <== NOT EXECUTED
2003d28: d0 07 61 34 ld [ %i5 + 0x134 ], %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
2003d2c: 81 c7 e0 08 ret <== NOT EXECUTED
2003d30: 81 e8 00 00 restore <== NOT EXECUTED
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
2003d34: b0 10 20 00 clr %i0
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
2003d38: c2 27 21 30 st %g1, [ %i4 + 0x130 ]
return RTEMS_SUCCESSFUL;
}
2003d3c: 81 c7 e0 08 ret
2003d40: 81 e8 00 00 restore
02003b98 <rtems_disk_next>:
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
2003b98: 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) {
2003b9c: 80 a6 3f ff cmp %i0, -1
2003ba0: 12 80 00 05 bne 2003bb4 <rtems_disk_next+0x1c>
2003ba4: b8 06 60 01 add %i1, 1, %i4
2003ba8: 80 a6 7f ff cmp %i1, -1
2003bac: 22 80 00 0b be,a 2003bd8 <rtems_disk_next+0x40> <== ALWAYS TAKEN
2003bb0: b8 10 20 00 clr %i4
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
2003bb4: 80 a7 00 19 cmp %i4, %i1
2003bb8: 1a 80 00 09 bcc 2003bdc <rtems_disk_next+0x44> <== ALWAYS TAKEN
2003bbc: ba 10 00 18 mov %i0, %i5
/* If major wraps around */
if ((major + 1) < major) {
2003bc0: ba 06 20 01 add %i0, 1, %i5 <== NOT EXECUTED
2003bc4: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2003bc8: 1a 80 00 05 bcc 2003bdc <rtems_disk_next+0x44> <== NOT EXECUTED
2003bcc: b8 10 20 00 clr %i4 <== NOT EXECUTED
}
if (major >= disktab_size) {
disk_unlock();
return NULL;
2003bd0: 81 c7 e0 08 ret <== NOT EXECUTED
2003bd4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
2003bd8: ba 10 20 00 clr %i5
} else {
++minor;
}
}
sc = disk_lock();
2003bdc: 7f ff fe 76 call 20035b4 <disk_lock>
2003be0: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003be4: 80 a2 20 00 cmp %o0, 0
2003be8: 12 80 00 08 bne 2003c08 <rtems_disk_next+0x70> <== NEVER TAKEN
2003bec: 03 00 80 85 sethi %hi(0x2021400), %g1
return NULL;
}
if (major >= disktab_size) {
2003bf0: c4 00 61 30 ld [ %g1 + 0x130 ], %g2 ! 2021530 <disktab_size>
2003bf4: 80 a7 40 02 cmp %i5, %g2
2003bf8: 0a 80 00 06 bcs 2003c10 <rtems_disk_next+0x78> <== ALWAYS TAKEN
2003bfc: 03 00 80 85 sethi %hi(0x2021400), %g1
disk_unlock();
2003c00: 7f ff fe 7c call 20035f0 <disk_unlock>
2003c04: 01 00 00 00 nop
return NULL;
2003c08: 81 c7 e0 08 ret
2003c0c: 91 e8 20 00 restore %g0, 0, %o0
}
dtab = disktab + major;
2003c10: c6 00 61 34 ld [ %g1 + 0x134 ], %g3
2003c14: b7 2f 60 03 sll %i5, 3, %i3
2003c18: b6 00 c0 1b add %g3, %i3, %i3
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
2003c1c: c2 06 c0 00 ld [ %i3 ], %g1
2003c20: 80 a0 60 00 cmp %g1, 0
2003c24: 22 80 00 07 be,a 2003c40 <rtems_disk_next+0xa8>
2003c28: ba 07 60 01 inc %i5
2003c2c: c8 06 e0 04 ld [ %i3 + 4 ], %g4
2003c30: 80 a7 00 04 cmp %i4, %g4
2003c34: 0a 80 00 09 bcs 2003c58 <rtems_disk_next+0xc0>
2003c38: b5 2f 20 02 sll %i4, 2, %i2
minor = 0;
++major;
2003c3c: ba 07 60 01 inc %i5
if (major >= disktab_size) {
2003c40: 80 a7 40 02 cmp %i5, %g2
2003c44: 1a bf ff ef bcc 2003c00 <rtems_disk_next+0x68>
2003c48: b7 2f 60 03 sll %i5, 3, %i3
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
2003c4c: b8 10 20 00 clr %i4
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
2003c50: 10 bf ff f3 b 2003c1c <rtems_disk_next+0x84>
2003c54: b6 00 c0 1b add %g3, %i3, %i3
} else if (dtab->minor [minor] == NULL) {
2003c58: c2 00 40 1a ld [ %g1 + %i2 ], %g1
2003c5c: 80 a0 60 00 cmp %g1, 0
2003c60: 02 bf ff ef be 2003c1c <rtems_disk_next+0x84>
2003c64: b8 07 20 01 inc %i4
++minor;
} else {
++dtab->minor [minor]->uses;
2003c68: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
2003c6c: 84 00 a0 01 inc %g2
disk_unlock();
2003c70: 7f ff fe 60 call 20035f0 <disk_unlock>
2003c74: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
return dtab->minor [minor];
2003c78: c2 06 c0 00 ld [ %i3 ], %g1
2003c7c: f0 00 40 1a ld [ %g1 + %i2 ], %i0
}
}
}
2003c80: 81 c7 e0 08 ret
2003c84: 81 e8 00 00 restore
02003ad4 <rtems_disk_obtain>:
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
2003ad4: 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);
2003ad8: 7f ff fc cd call 2002e0c <sparc_disable_interrupts>
2003adc: b8 10 00 18 mov %i0, %i4
2003ae0: b6 10 00 08 mov %o0, %i3
if (!diskdevs_protected) {
2003ae4: 03 00 80 85 sethi %hi(0x2021400), %g1
2003ae8: c2 08 61 28 ldub [ %g1 + 0x128 ], %g1 ! 2021528 <diskdevs_protected>
2003aec: 80 a0 60 00 cmp %g1, 0
2003af0: 12 80 00 0a bne 2003b18 <rtems_disk_obtain+0x44> <== NEVER TAKEN
2003af4: 92 10 00 19 mov %i1, %o1
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
2003af8: 90 10 00 18 mov %i0, %o0
2003afc: 7f ff fe 73 call 20034c8 <get_disk_entry>
2003b00: 94 10 20 00 clr %o2
2003b04: b0 10 00 08 mov %o0, %i0
rtems_interrupt_enable(level);
2003b08: 7f ff fc c5 call 2002e1c <sparc_enable_interrupts>
2003b0c: 90 10 00 1b mov %i3, %o0
2003b10: 81 c7 e0 08 ret
2003b14: 81 e8 00 00 restore
} else {
rtems_interrupt_enable(level);
2003b18: 7f ff fc c1 call 2002e1c <sparc_enable_interrupts> <== NOT EXECUTED
2003b1c: b0 10 20 00 clr %i0 <== NOT EXECUTED
sc = disk_lock();
2003b20: 7f ff fe a5 call 20035b4 <disk_lock> <== NOT EXECUTED
2003b24: 01 00 00 00 nop <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
2003b28: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2003b2c: 12 bf ff f9 bne 2003b10 <rtems_disk_obtain+0x3c> <== NOT EXECUTED
2003b30: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
2003b34: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2003b38: 7f ff fe 64 call 20034c8 <get_disk_entry> <== NOT EXECUTED
2003b3c: 94 10 20 00 clr %o2 <== NOT EXECUTED
disk_unlock();
2003b40: 7f ff fe ac call 20035f0 <disk_unlock> <== NOT EXECUTED
2003b44: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
return dd;
}
2003b48: 81 c7 e0 08 ret <== NOT EXECUTED
2003b4c: 81 e8 00 00 restore <== NOT EXECUTED
02011074 <rtems_event_system_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
2011074: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc;
if ( event_out != NULL ) {
2011078: 80 a6 e0 00 cmp %i3, 0
201107c: 02 80 00 1e be 20110f4 <rtems_event_system_receive+0x80> <== NEVER TAKEN
2011080: 82 10 20 09 mov 9, %g1
Thread_Control *executing = _Thread_Executing;
2011084: 03 00 80 87 sethi %hi(0x2021c00), %g1
2011088: fa 00 63 20 ld [ %g1 + 0x320 ], %i5 ! 2021f20 <_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 ) ) {
201108c: 80 a6 20 00 cmp %i0, 0
2011090: 02 80 00 16 be 20110e8 <rtems_event_system_receive+0x74> <== NEVER TAKEN
2011094: da 07 61 58 ld [ %i5 + 0x158 ], %o5
*
* 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;
2011098: 03 00 80 86 sethi %hi(0x2021800), %g1
201109c: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20219f0 <_Thread_Dispatch_disable_level>
++level;
20110a0: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
20110a4: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ]
_Thread_Disable_dispatch();
_Event_Seize(
20110a8: 03 00 80 88 sethi %hi(0x2022000), %g1
20110ac: 82 10 63 10 or %g1, 0x310, %g1 ! 2022310 <_System_event_Sync_state>
20110b0: 90 10 00 18 mov %i0, %o0
20110b4: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
20110b8: 92 10 00 19 mov %i1, %o1
20110bc: 03 00 01 00 sethi %hi(0x40000), %g1
20110c0: 94 10 00 1a mov %i2, %o2
20110c4: 96 10 00 1b mov %i3, %o3
20110c8: 98 10 00 1d mov %i5, %o4
20110cc: 9a 03 60 04 add %o5, 4, %o5
20110d0: 7f ff dd 1c call 2008540 <_Event_Seize>
20110d4: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
executing,
event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
20110d8: 7f ff e8 9d call 200b34c <_Thread_Enable_dispatch>
20110dc: 01 00 00 00 nop
sc = executing->Wait.return_code;
20110e0: 10 80 00 05 b 20110f4 <rtems_event_system_receive+0x80>
20110e4: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
} else {
*event_out = event->pending_events;
20110e8: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED
20110ec: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
20110f0: 82 10 20 00 clr %g1 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
20110f4: 81 c7 e0 08 ret
20110f8: 91 e8 00 01 restore %g0, %g1, %o0
0200789c <rtems_event_system_send>:
rtems_status_code rtems_event_system_send(
rtems_id id,
rtems_event_set event_in
)
{
200789c: 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 );
20078a0: 90 10 00 18 mov %i0, %o0
20078a4: 40 00 09 f7 call 200a080 <_Thread_Get>
20078a8: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
20078ac: c4 07 bf fc ld [ %fp + -4 ], %g2
20078b0: 80 a0 a0 00 cmp %g2, 0
20078b4: 12 80 00 0d bne 20078e8 <rtems_event_system_send+0x4c> <== NEVER TAKEN
20078b8: 92 10 00 19 mov %i1, %o1
case OBJECTS_LOCAL:
api = thread->API_Extensions[ THREAD_API_RTEMS ];
_Event_Surrender(
20078bc: d4 02 21 58 ld [ %o0 + 0x158 ], %o2
20078c0: 94 02 a0 04 add %o2, 4, %o2
20078c4: 19 00 01 00 sethi %hi(0x40000), %o4
20078c8: 17 00 80 77 sethi %hi(0x201dc00), %o3
20078cc: 96 12 e2 f0 or %o3, 0x2f0, %o3 ! 201def0 <_System_event_Sync_state>
20078d0: 7f ff fe 64 call 2007260 <_Event_Surrender>
20078d4: b0 10 20 00 clr %i0
event_in,
&api->System_event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
20078d8: 40 00 09 de call 200a050 <_Thread_Enable_dispatch>
20078dc: 01 00 00 00 nop
sc = RTEMS_SUCCESSFUL;
break;
20078e0: 81 c7 e0 08 ret
20078e4: 81 e8 00 00 restore
sc = RTEMS_INVALID_ID;
break;
}
return sc;
}
20078e8: 81 c7 e0 08 ret <== NOT EXECUTED
20078ec: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED
02007434 <rtems_fdisk_abort.constprop.0>:
*
* @param format The format string. See printf for details.
* @param ... The arguments for the format text.
*/
static void
rtems_fdisk_abort (const char *format, ...)
2007434: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
{
va_list args;
va_start (args, format);
2007438: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
200743c: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
2007440: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
2007444: 3b 00 80 d7 sethi %hi(0x2035c00), %i5 <== NOT EXECUTED
2007448: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 ! 2035f00 <_impure_ptr><== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
200744c: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
2007450: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2007454: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
2007458: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
200745c: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
2007460: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
2007464: 40 00 67 be call 202135c <fputs> <== NOT EXECUTED
2007468: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 2030ba0 <__FUNCTION__.7127+0x4c8><== NOT EXECUTED
vfprintf (stderr, format, args);
200746c: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
2007470: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
2007474: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
2007478: 40 00 67 b9 call 202135c <fputs> <== NOT EXECUTED
200747c: 90 12 23 b0 or %o0, 0x3b0, %o0 <== NOT EXECUTED
fprintf (stderr, "\n");
2007480: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
2007484: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
2007488: 40 00 67 81 call 202128c <fputc> <== NOT EXECUTED
200748c: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
fflush (stderr);
2007490: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
2007494: 40 00 66 66 call 2020e2c <fflush> <== NOT EXECUTED
2007498: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
exit (1);
200749c: 40 00 65 64 call 2020a2c <exit> <== NOT EXECUTED
20074a0: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
02005b70 <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)
{
2005b70: 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)
2005b74: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
2005b78: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
2005b7c: 80 a0 80 01 cmp %g2, %g1
2005b80: 1a 80 00 72 bcc 2005d48 <rtems_fdisk_compact+0x1d8>
2005b84: ba 10 00 18 mov %i0, %i5
fd->starvations++;
2005b88: 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");
2005b8c: 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++;
2005b90: 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");
2005b94: 13 00 80 c3 sethi %hi(0x2030c00), %o1
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
fd->starvations++;
2005b98: 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");
2005b9c: 7f ff fc ac call 2004e4c <rtems_fdisk_printf>
2005ba0: 92 12 63 78 or %o1, 0x378, %o1
#endif
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
2005ba4: 7f ff fb d6 call 2004afc <rtems_fdisk_segment_queue_pop_head>
2005ba8: 90 06 20 40 add %i0, 0x40, %o0
if (!ssc)
2005bac: b8 92 20 00 orcc %o0, 0, %i4
2005bb0: 12 80 00 07 bne 2005bcc <rtems_fdisk_compact+0x5c> <== ALWAYS TAKEN
2005bb4: 01 00 00 00 nop
ssc = rtems_fdisk_segment_queue_pop_head (&fd->available);
2005bb8: 7f ff fb d1 call 2004afc <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
2005bbc: 90 06 20 34 add %i0, 0x34, %o0 <== NOT EXECUTED
if (ssc)
2005bc0: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2005bc4: 02 80 00 12 be 2005c0c <rtems_fdisk_compact+0x9c> <== NOT EXECUTED
2005bc8: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
{
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005bcc: 7f ff fc 6e call 2004d84 <rtems_fdisk_seg_most_available>
2005bd0: 90 07 60 34 add %i5, 0x34, %o0
if (dsc)
2005bd4: 94 92 20 00 orcc %o0, 0, %o2
2005bd8: 02 80 00 0a be 2005c00 <rtems_fdisk_compact+0x90> <== NEVER TAKEN
2005bdc: 92 10 00 1c mov %i4, %o1
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
2005be0: 90 10 00 1d mov %i5, %o0
2005be4: 7f ff ff 02 call 20057ec <rtems_fdisk_recycle_segment>
2005be8: 96 07 bf fc add %fp, -4, %o3
if (ret)
2005bec: 80 a2 20 00 cmp %o0, 0
2005bf0: 02 80 00 57 be 2005d4c <rtems_fdisk_compact+0x1dc> <== ALWAYS TAKEN
2005bf4: 21 00 80 c3 sethi %hi(0x2030c00), %l0
compacted_segs += segments;
}
return 0;
}
2005bf8: 81 c7 e0 08 ret <== NOT EXECUTED
2005bfc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if (ret)
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
2005c00: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2005c04: 10 80 00 03 b 2005c10 <rtems_fdisk_compact+0xa0> <== NOT EXECUTED
2005c08: 90 12 23 90 or %o0, 0x390, %o0 ! 2030f90 <__FUNCTION__.7127+0x8b8><== NOT EXECUTED
return EIO;
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
2005c0c: 90 12 23 a8 or %o0, 0x3a8, %o0 <== NOT EXECUTED
2005c10: 7f ff fc cf call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
2005c14: 01 00 00 00 nop <== NOT EXECUTED
return EIO;
2005c18: 10 80 00 61 b 2005d9c <rtems_fdisk_compact+0x22c> <== NOT EXECUTED
2005c1c: 90 10 20 05 mov 5, %o0 ! 5 <PROM_START+0x5> <== NOT EXECUTED
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
2005c20: 7f ff fc 8b call 2004e4c <rtems_fdisk_printf>
2005c24: 90 10 00 1d mov %i5, %o0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005c28: 7f ff fc 57 call 2004d84 <rtems_fdisk_seg_most_available>
2005c2c: 90 10 00 19 mov %i1, %o0
if (dsc == 0)
2005c30: b6 92 20 00 orcc %o0, 0, %i3
2005c34: 12 80 00 05 bne 2005c48 <rtems_fdisk_compact+0xd8> <== ALWAYS TAKEN
2005c38: 01 00 00 00 nop
{
rtems_fdisk_error ("compacting: no available segments to compact too");
2005c3c: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2005c40: 10 bf ff f4 b 2005c10 <rtems_fdisk_compact+0xa0> <== NOT EXECUTED
2005c44: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 2030fd8 <__FUNCTION__.7127+0x900><== NOT EXECUTED
return EIO;
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
2005c48: 7f ff fc 47 call 2004d64 <rtems_fdisk_seg_pages_available>
2005c4c: 01 00 00 00 nop
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
2005c50: d4 06 e0 08 ld [ %i3 + 8 ], %o2
2005c54: d6 06 e0 0c ld [ %i3 + 0xc ], %o3
{
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
}
ssc = fd->used.head;
2005c58: f8 07 60 40 ld [ %i5 + 0x40 ], %i4
dst_pages = rtems_fdisk_seg_pages_available (dsc);
2005c5c: b0 10 00 08 mov %o0, %i0
segments = 0;
pages = 0;
2005c60: c0 27 bf fc clr [ %fp + -4 ]
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
2005c64: 90 10 00 1d mov %i5, %o0
2005c68: 7f ff fc 79 call 2004e4c <rtems_fdisk_printf>
2005c6c: 92 10 00 11 mov %l1, %o1
2005c70: d8 07 bf fc ld [ %fp + -4 ], %o4
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
2005c74: 10 80 00 04 b 2005c84 <rtems_fdisk_compact+0x114>
2005c78: 9a 10 20 00 clr %o5
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
segments++;
2005c7c: 9a 03 60 01 inc %o5
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
2005c80: 98 10 00 01 mov %g1, %o4
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
2005c84: 80 a7 20 00 cmp %i4, 0
2005c88: 32 80 00 09 bne,a 2005cac <rtems_fdisk_compact+0x13c>
2005c8c: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
2005c90: 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");
2005c94: 90 10 00 1d mov %i5, %o0
2005c98: 13 00 80 c4 sethi %hi(0x2031000), %o1
2005c9c: 7f ff fc 6c call 2004e4c <rtems_fdisk_printf>
2005ca0: 92 12 60 30 or %o1, 0x30, %o1 ! 2031030 <__FUNCTION__.7127+0x958>
}
compacted_segs += segments;
}
return 0;
2005ca4: 10 80 00 3e b 2005d9c <rtems_fdisk_compact+0x22c>
2005ca8: 90 10 20 00 clr %o0
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
2005cac: 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 &&
2005cb0: 80 a0 40 18 cmp %g1, %i0
2005cb4: 1a 80 00 34 bcc 2005d84 <rtems_fdisk_compact+0x214>
2005cb8: 86 03 40 1a add %o5, %i2, %g3
((pages + ssc->pages_active) < dst_pages) &&
2005cbc: c4 07 60 0c ld [ %i5 + 0xc ], %g2
2005cc0: 80 a0 c0 02 cmp %g3, %g2
2005cc4: 2a bf ff ee bcs,a 2005c7c <rtems_fdisk_compact+0x10c> <== ALWAYS TAKEN
2005cc8: f8 07 00 00 ld [ %i4 ], %i4
2005ccc: 10 80 00 2f b 2005d88 <rtems_fdisk_compact+0x218> <== NOT EXECUTED
2005cd0: d8 27 bf fc st %o4, [ %fp + -4 ] <== NOT EXECUTED
* We need a source segment and have pages to copy and
* compacting one segment to another is silly. Compaction needs
* to free at least one more segment.
*/
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
2005cd4: 80 a6 a0 01 cmp %i2, 1
2005cd8: 22 bf ff f0 be,a 2005c98 <rtems_fdisk_compact+0x128>
2005cdc: 90 10 00 1d mov %i5, %o0
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
2005ce0: d4 07 20 08 ld [ %i4 + 8 ], %o2
2005ce4: d6 07 20 0c ld [ %i4 + 0xc ], %o3
2005ce8: 92 10 00 12 mov %l2, %o1
2005cec: 7f ff fc 58 call 2004e4c <rtems_fdisk_printf>
2005cf0: 90 10 00 1d mov %i5, %o0
ssc->device, ssc->segment,
pages, segments);
#endif
rtems_fdisk_segment_queue_remove (&fd->available, dsc);
2005cf4: 90 10 00 19 mov %i1, %o0
2005cf8: 7f ff fb a3 call 2004b84 <rtems_fdisk_segment_queue_remove>
2005cfc: 92 10 00 1b mov %i3, %o1
/*
* We now copy the pages to the new segment.
*/
while (pages)
2005d00: 10 80 00 0e b 2005d38 <rtems_fdisk_compact+0x1c8>
2005d04: c2 07 bf fc ld [ %fp + -4 ], %g1
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
2005d08: 7f ff fb 7d call 2004afc <rtems_fdisk_segment_queue_pop_head>
2005d0c: 90 10 00 13 mov %l3, %o0
if (ssc)
2005d10: 92 92 20 00 orcc %o0, 0, %o1
2005d14: 02 80 00 09 be 2005d38 <rtems_fdisk_compact+0x1c8> <== NEVER TAKEN
2005d18: c2 07 bf fc ld [ %fp + -4 ], %g1
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
2005d1c: 90 10 00 1d mov %i5, %o0
2005d20: 94 10 00 1b mov %i3, %o2
2005d24: 7f ff fe b2 call 20057ec <rtems_fdisk_recycle_segment>
2005d28: 96 07 bf fc add %fp, -4, %o3
if (ret)
2005d2c: 80 a2 20 00 cmp %o0, 0
2005d30: 12 80 00 1b bne 2005d9c <rtems_fdisk_compact+0x22c> <== NEVER TAKEN
2005d34: c2 07 bf fc ld [ %fp + -4 ], %g1
/*
* We now copy the pages to the new segment.
*/
while (pages)
2005d38: 80 a0 60 00 cmp %g1, 0
2005d3c: 22 80 00 0d be,a 2005d70 <rtems_fdisk_compact+0x200>
2005d40: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
2005d44: 30 bf ff f1 b,a 2005d08 <rtems_fdisk_compact+0x198>
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
2005d48: 21 00 80 c3 sethi %hi(0x2030c00), %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",
2005d4c: 23 00 80 c4 sethi %hi(0x2031000), %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
2005d50: 25 00 80 c4 sethi %hi(0x2031000), %l2
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
2005d54: b4 10 20 00 clr %i2
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
2005d58: a0 14 23 c8 or %l0, 0x3c8, %l0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005d5c: b2 07 60 34 add %i5, 0x34, %i1
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
2005d60: a2 14 60 10 or %l1, 0x10, %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
2005d64: a4 14 a0 48 or %l2, 0x48, %l2
* We now copy the pages to the new segment.
*/
while (pages)
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
2005d68: a6 07 60 40 add %i5, 0x40, %l3
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
2005d6c: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
2005d70: 80 a0 60 00 cmp %g1, 0
2005d74: 12 bf ff ab bne 2005c20 <rtems_fdisk_compact+0xb0>
2005d78: 92 10 00 10 mov %l0, %o1
}
compacted_segs += segments;
}
return 0;
2005d7c: 10 80 00 08 b 2005d9c <rtems_fdisk_compact+0x22c>
2005d80: 90 10 20 00 clr %o0
2005d84: 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))
2005d88: 80 a3 20 00 cmp %o4, 0
2005d8c: 32 bf ff d2 bne,a 2005cd4 <rtems_fdisk_compact+0x164>
2005d90: b4 06 80 0d add %i2, %o5, %i2
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " nothing to compact");
2005d94: 10 bf ff c1 b 2005c98 <rtems_fdisk_compact+0x128>
2005d98: 90 10 00 1d mov %i5, %o0
compacted_segs += segments;
}
return 0;
}
2005d9c: b0 10 00 08 mov %o0, %i0
2005da0: 81 c7 e0 08 ret
2005da4: 81 e8 00 00 restore
02004fc0 <rtems_fdisk_erase_segment>:
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
2004fc0: 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;
2004fc4: d2 06 60 08 ld [ %i1 + 8 ], %o1
segment = sc->segment;
2004fc8: d4 06 60 0c ld [ %i1 + 0xc ], %o2
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
2004fcc: 85 2a 60 04 sll %o1, 4, %g2
2004fd0: 83 2a 60 02 sll %o1, 2, %g1
2004fd4: 82 20 80 01 sub %g2, %g1, %g1
2004fd8: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
2004fdc: 89 2a a0 06 sll %o2, 6, %g4
2004fe0: 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;
2004fe4: 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;
2004fe8: c2 00 80 01 ld [ %g2 + %g1 ], %g1
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
ret = ops->erase (sd, device, segment);
2004fec: 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;
2004ff0: 85 2a a0 04 sll %o2, 4, %g2
2004ff4: 84 21 00 02 sub %g4, %g2, %g2
2004ff8: 84 00 40 02 add %g1, %g2, %g2
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
ret = ops->erase (sd, device, segment);
2004ffc: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1
2005000: 9f c0 40 00 call %g1
2005004: d0 00 a0 04 ld [ %g2 + 4 ], %o0
if (ret)
2005008: ba 92 20 00 orcc %o0, 0, %i5
200500c: 22 80 00 16 be,a 2005064 <rtems_fdisk_erase_segment+0xa4><== ALWAYS TAKEN
2005010: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
2005014: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
2005018: 40 00 78 47 call 2023134 <strerror> <== NOT EXECUTED
200501c: f8 06 60 0c ld [ %i1 + 0xc ], %i4 <== NOT EXECUTED
2005020: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2005024: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2005028: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
200502c: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
2005030: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
2005034: 7f ff ff c6 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
2005038: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 2030bd0 <__FUNCTION__.7127+0x4f8><== NOT EXECUTED
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
200503c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
2005040: b0 06 20 58 add %i0, 0x58, %i0 <== NOT EXECUTED
if (ret)
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
2005044: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
2005048: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200504c: 7f ff ff 09 call 2004c70 <rtems_fdisk_segment_queue_present><== NOT EXECUTED
2005050: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2005054: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2005058: 12 80 00 18 bne 20050b8 <rtems_fdisk_erase_segment+0xf8> <== NOT EXECUTED
200505c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2005060: 30 80 00 14 b,a 20050b0 <rtems_fdisk_erase_segment+0xf0> <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
2005064: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
2005068: d2 06 60 18 ld [ %i1 + 0x18 ], %o1
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
200506c: 82 00 80 01 add %g2, %g1, %g1
2005070: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
sc->erased++;
2005074: c2 06 60 2c ld [ %i1 + 0x2c ], %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
2005078: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
sc->erased++;
200507c: 82 00 60 01 inc %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
2005080: f8 06 60 10 ld [ %i1 + 0x10 ], %i4
2005084: 7f ff f5 44 call 2002594 <.umul>
2005088: c2 26 60 2c st %g1, [ %i1 + 0x2c ]
200508c: 92 10 20 ff mov 0xff, %o1
2005090: 94 10 00 08 mov %o0, %o2
2005094: 40 00 73 3e call 2021d8c <memset>
2005098: 90 10 00 1c mov %i4, %o0
/*
* Push to the tail of the available queue. It is a very
* simple type of wear reduction. Every other available
* segment will now get a go.
*/
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
200509c: 90 06 20 34 add %i0, 0x34, %o0
fd->erased_blocks += sc->pages;
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
sc->pages_active = 0;
20050a0: c0 26 60 1c clr [ %i1 + 0x1c ]
sc->pages_used = 0;
20050a4: c0 26 60 20 clr [ %i1 + 0x20 ]
sc->pages_bad = 0;
20050a8: c0 26 60 24 clr [ %i1 + 0x24 ]
sc->failed = false;
20050ac: c0 26 60 28 clr [ %i1 + 0x28 ]
/*
* Push to the tail of the available queue. It is a very
* simple type of wear reduction. Every other available
* segment will now get a go.
*/
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
20050b0: 7f ff fe a3 call 2004b3c <rtems_fdisk_segment_queue_push_tail>
20050b4: 92 10 00 19 mov %i1, %o1
return 0;
}
20050b8: 81 c7 e0 08 ret
20050bc: 91 e8 00 1d restore %g0, %i5, %o0
02004f4c <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, ...)
{
2004f4c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int ret;
va_list args;
va_start (args, format);
2004f50: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
2004f54: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
2004f58: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
2004f5c: 3b 00 80 d7 sethi %hi(0x2035c00), %i5 <== NOT EXECUTED
2004f60: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 ! 2035f00 <_impure_ptr><== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
2004f64: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
2004f68: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2004f6c: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
2004f70: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
2004f74: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
2004f78: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
2004f7c: 40 00 70 f8 call 202135c <fputs> <== NOT EXECUTED
2004f80: 90 12 23 90 or %o0, 0x390, %o0 ! 2030b90 <__FUNCTION__.7127+0x4b8><== NOT EXECUTED
ret = vfprintf (stderr, format, args);
2004f84: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
2004f88: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
2004f8c: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
2004f90: 40 00 93 41 call 2029c94 <vfprintf> <== NOT EXECUTED
2004f94: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
fprintf (stderr, "\n");
2004f98: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
ret = vfprintf (stderr, format, args);
2004f9c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stderr, "\n");
2004fa0: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
2004fa4: 40 00 70 ba call 202128c <fputc> <== NOT EXECUTED
2004fa8: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stderr);
2004fac: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
2004fb0: 40 00 6f 9f call 2020e2c <fflush> <== NOT EXECUTED
2004fb4: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
return ret;
}
2004fb8: 81 c7 e0 08 ret <== NOT EXECUTED
2004fbc: 81 e8 00 00 restore <== NOT EXECUTED
02004dcc <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, ...)
{
2004dcc: 9d e3 bf 98 save %sp, -104, %sp
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
2004dd0: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2004dd4: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2004dd8: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
2004ddc: 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)
2004de0: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
2004de4: 80 a0 60 01 cmp %g1, 1
2004de8: 08 80 00 17 bleu 2004e44 <rtems_fdisk_info+0x78> <== ALWAYS TAKEN
2004dec: b0 10 20 00 clr %i0
{
va_list args;
va_start (args, format);
2004df0: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:");
2004df4: 3b 00 80 d7 sethi %hi(0x2035c00), %i5 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
2004df8: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:");
2004dfc: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
2004e00: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
2004e04: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2004e08: 40 00 71 55 call 202135c <fputs> <== NOT EXECUTED
2004e0c: 90 12 23 78 or %o0, 0x378, %o0 <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
2004e10: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
2004e14: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
2004e18: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
2004e1c: 40 00 93 9e call 2029c94 <vfprintf> <== NOT EXECUTED
2004e20: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
2004e24: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
ret = vfprintf (stdout, format, args);
2004e28: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
2004e2c: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2004e30: 40 00 71 17 call 202128c <fputc> <== NOT EXECUTED
2004e34: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
2004e38: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
2004e3c: 40 00 6f fc call 2020e2c <fflush> <== NOT EXECUTED
2004e40: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
2004e44: 81 c7 e0 08 ret
2004e48: 81 e8 00 00 restore
02006f38 <rtems_fdisk_initialize>:
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
2006f38: 9d e3 bf 68 save %sp, -152, %sp
const rtems_flashdisk_config* c = rtems_flashdisk_configuration;
rtems_flashdisk* fd;
rtems_status_code sc;
sc = rtems_disk_io_initialize ();
2006f3c: 7f ff f6 8b call 2004968 <rtems_disk_io_initialize>
2006f40: a0 10 00 18 mov %i0, %l0
if (sc != RTEMS_SUCCESSFUL)
2006f44: b0 92 20 00 orcc %o0, 0, %i0
2006f48: 12 80 01 39 bne 200742c <rtems_fdisk_initialize+0x4f4> <== NEVER TAKEN
2006f4c: 01 00 00 00 nop
static rtems_status_code
rtems_fdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
2006f50: 40 00 05 b6 call 2008628 <malloc>
2006f54: 90 10 22 00 mov 0x200, %o0 ! 200 <PROM_START+0x200>
2006f58: 03 00 81 19 sethi %hi(0x2046400), %g1
2006f5c: d0 20 60 88 st %o0, [ %g1 + 0x88 ] ! 2046488 <rtems_fdisk_crc16_factor>
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
2006f60: 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)
2006f64: 82 10 20 00 clr %g1
2006f68: 80 a2 20 00 cmp %o0, 0
2006f6c: 12 80 00 04 bne 2006f7c <rtems_fdisk_initialize+0x44> <== ALWAYS TAKEN
2006f70: 88 11 20 08 or %g4, 8, %g4
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
if (!fd->copy_buffer)
return RTEMS_NO_MEMORY;
2006f74: 81 c7 e0 08 ret <== NOT EXECUTED
2006f78: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
2006f7c: 84 10 00 01 mov %g1, %g2
2006f80: 10 80 00 06 b 2006f98 <rtems_fdisk_initialize+0x60>
2006f84: 86 10 20 09 mov 9, %g3
2006f88: 85 28 a0 10 sll %g2, 0x10, %g2
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
2006f8c: 02 80 00 03 be 2006f98 <rtems_fdisk_initialize+0x60>
2006f90: 85 30 a0 11 srl %g2, 0x11, %g2
2006f94: 84 18 80 04 xor %g2, %g4, %g2
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
2006f98: 86 80 ff ff addcc %g3, -1, %g3
2006f9c: 12 bf ff fb bne 2006f88 <rtems_fdisk_initialize+0x50>
2006fa0: 80 88 a0 01 btst 1, %g2
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
2006fa4: 87 28 60 01 sll %g1, 1, %g3
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_fdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
2006fa8: 82 00 60 01 inc %g1
2006fac: 80 a0 61 00 cmp %g1, 0x100
2006fb0: 12 bf ff f3 bne 2006f7c <rtems_fdisk_initialize+0x44>
2006fb4: c4 32 00 03 sth %g2, [ %o0 + %g3 ]
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
2006fb8: 10 80 01 0f b 20073f4 <rtems_fdisk_initialize+0x4bc>
2006fbc: 2f 00 80 d7 sethi %hi(0x2035c00), %l7
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
2006fc0: c2 05 60 80 ld [ %l5 + 0x80 ], %g1
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
2006fc4: f2 2f bf f9 stb %i1, [ %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";
2006fc8: 05 0b d9 19 sethi %hi(0x2f646400), %g2
2006fcc: 07 0b d9 99 sethi %hi(0x2f666400), %g3
2006fd0: 84 10 a1 76 or %g2, 0x176, %g2
2006fd4: 86 10 e0 64 or %g3, 0x64, %g3
2006fd8: c4 3f bf f0 std %g2, [ %fp + -16 ]
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
2006fdc: b6 00 40 12 add %g1, %l2, %i3
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
2006fe0: e0 20 40 12 st %l0, [ %g1 + %l2 ]
fd->minor = minor;
fd->flags = c->flags;
2006fe4: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
2006fe8: e6 06 80 00 ld [ %i2 ], %l3
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
2006fec: c2 26 e0 08 st %g1, [ %i3 + 8 ]
fd->compact_segs = c->compact_segs;
2006ff0: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
2006ff4: f2 26 e0 04 st %i1, [ %i3 + 4 ]
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
2006ff8: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
fd->avail_compact_segs = c->avail_compact_segs;
2006ffc: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
2007000: da 06 a0 04 ld [ %i2 + 4 ], %o5
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
2007004: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
2007008: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
200700c: e6 26 e0 14 st %l3, [ %i3 + 0x14 ]
fd->unavail_blocks = c->unavail_blocks;
2007010: c2 26 e0 20 st %g1, [ %i3 + 0x20 ]
fd->info_level = c->info_level;
2007014: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
for (device = 0; device < c->device_count; device++)
2007018: a8 10 20 00 clr %l4
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
200701c: c2 26 e0 6c st %g1, [ %i3 + 0x6c ]
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
2007020: a2 10 20 00 clr %l1
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++)
2007024: 10 80 00 25 b 20070b8 <rtems_fdisk_initialize+0x180>
2007028: b0 10 20 00 clr %i0
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
200702c: ba 10 20 00 clr %i5
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
2007030: b8 00 40 14 add %g1, %l4, %i4
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
2007034: d8 00 40 14 ld [ %g1 + %l4 ], %o4
2007038: 86 10 20 00 clr %g3
*/
static uint32_t
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
200703c: 10 80 00 19 b 20070a0 <rtems_fdisk_initialize+0x168>
2007040: 84 10 20 00 clr %g2
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
2007044: 92 10 00 13 mov %l3, %o1
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
2007048: 9e 01 00 1d add %g4, %i5, %o7
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
200704c: d0 03 e0 08 ld [ %o7 + 8 ], %o0
2007050: c4 3f bf e0 std %g2, [ %fp + -32 ]
2007054: d8 3f bf d0 std %o4, [ %fp + -48 ]
2007058: 7f ff ed 89 call 200267c <.udiv>
200705c: c8 27 bf dc st %g4, [ %fp + -36 ]
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;
2007060: 94 02 3f ff add %o0, -1, %o2
2007064: 92 10 00 13 mov %l3, %o1
2007068: d4 27 bf d8 st %o2, [ %fp + -40 ]
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);
200706c: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
2007070: 7f ff ed 83 call 200267c <.udiv>
2007074: 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;
2007078: c8 07 bf dc ld [ %fp + -36 ], %g4
200707c: d4 07 bf d8 ld [ %fp + -40 ], %o2
2007080: d2 11 00 1d lduh [ %g4 + %i5 ], %o1
2007084: 7f ff ed 44 call 2002594 <.umul>
2007088: 90 22 80 08 sub %o2, %o0, %o0
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
count +=
200708c: c4 1f bf e0 ldd [ %fp + -32 ], %g2
2007090: d8 1f bf d0 ldd [ %fp + -48 ], %o4
2007094: 84 00 80 08 add %g2, %o0, %g2
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
2007098: 86 00 e0 01 inc %g3
200709c: ba 07 60 0c add %i5, 0xc, %i5
20070a0: 80 a0 c0 0c cmp %g3, %o4
20070a4: 32 bf ff e8 bne,a 2007044 <rtems_fdisk_initialize+0x10c>
20070a8: c8 07 20 04 ld [ %i4 + 4 ], %g4
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
20070ac: a2 04 40 02 add %l1, %g2, %l1
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++)
20070b0: b0 06 20 01 inc %i0
20070b4: a8 05 20 0c add %l4, 0xc, %l4
20070b8: 80 a6 00 0d cmp %i0, %o5
20070bc: 32 bf ff dc bne,a 200702c <rtems_fdisk_initialize+0xf4>
20070c0: c2 06 a0 08 ld [ %i2 + 8 ], %g1
c->block_size);
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
20070c4: 40 00 05 59 call 2008628 <malloc>
20070c8: 90 10 00 13 mov %l3, %o0
if (!fd->copy_buffer)
20070cc: 80 a2 20 00 cmp %o0, 0
20070d0: 02 80 00 bf be 20073cc <rtems_fdisk_initialize+0x494> <== NEVER TAKEN
20070d4: d0 26 e0 68 st %o0, [ %i3 + 0x68 ]
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
20070d8: 90 10 00 11 mov %l1, %o0
20070dc: 40 00 02 c2 call 2007be4 <calloc>
20070e0: 92 10 20 08 mov 8, %o1
if (!fd->blocks)
20070e4: 80 a2 20 00 cmp %o0, 0
20070e8: 02 80 00 b9 be 20073cc <rtems_fdisk_initialize+0x494> <== NEVER TAKEN
20070ec: d0 26 e0 18 st %o0, [ %i3 + 0x18 ]
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
20070f0: e2 26 e0 1c st %l1, [ %i3 + 0x1c ]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
20070f4: 90 10 00 18 mov %i0, %o0
20070f8: 40 00 02 bb call 2007be4 <calloc>
20070fc: 92 10 20 0c mov 0xc, %o1
if (!fd->devices)
2007100: 80 a2 20 00 cmp %o0, 0
2007104: 02 80 00 b2 be 20073cc <rtems_fdisk_initialize+0x494> <== NEVER TAKEN
2007108: d0 26 e0 2c st %o0, [ %i3 + 0x2c ]
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
200710c: 07 00 80 c5 sethi %hi(0x2031400), %g3
2007110: d0 00 e3 1c ld [ %g3 + 0x31c ], %o0 ! 203171c <__FUNCTION__.7127+0x1044>
2007114: 92 10 20 01 mov 1, %o1
2007118: 94 10 20 54 mov 0x54, %o2
200711c: 96 10 20 00 clr %o3
2007120: 40 00 15 a6 call 200c7b8 <rtems_semaphore_create>
2007124: 98 06 e0 64 add %i3, 0x64, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
2007128: b0 92 20 00 orcc %o0, 0, %i0
200712c: 22 80 00 0d be,a 2007160 <rtems_fdisk_initialize+0x228> <== ALWAYS TAKEN
2007130: d6 06 e0 20 ld [ %i3 + 0x20 ], %o3
{
rtems_fdisk_error ("disk lock create failed");
2007134: 11 00 80 c5 sethi %hi(0x2031400), %o0 <== NOT EXECUTED
2007138: 7f ff f7 85 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
200713c: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 20316a0 <__FUNCTION__.7127+0xfc8><== NOT EXECUTED
free (fd->copy_buffer);
2007140: 40 00 03 a9 call 2007fe4 <free> <== NOT EXECUTED
2007144: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007148: 40 00 03 a7 call 2007fe4 <free> <== NOT EXECUTED
200714c: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
2007150: 40 00 03 a5 call 2007fe4 <free> <== NOT EXECUTED
2007154: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
2007158: 81 c7 e0 08 ret <== NOT EXECUTED
200715c: 81 e8 00 00 restore <== NOT EXECUTED
return sc;
}
sc = rtems_disk_create_phys(dev, c->block_size,
2007160: d4 06 80 00 ld [ %i2 ], %o2
2007164: 82 07 bf f0 add %fp, -16, %g1
2007168: 90 10 00 10 mov %l0, %o0
200716c: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2007170: 92 10 00 19 mov %i1, %o1
2007174: 96 24 40 0b sub %l1, %o3, %o3
2007178: 19 00 80 17 sethi %hi(0x2005c00), %o4
200717c: 9a 10 20 00 clr %o5
2007180: 7f ff f5 64 call 2004710 <rtems_disk_create_phys>
2007184: 98 13 21 a8 or %o4, 0x1a8, %o4
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
2007188: b0 92 20 00 orcc %o0, 0, %i0
200718c: 22 80 00 58 be,a 20072ec <rtems_fdisk_initialize+0x3b4> <== ALWAYS TAKEN
2007190: b0 10 20 00 clr %i0
{
rtems_semaphore_delete (fd->lock);
2007194: 40 00 15 f7 call 200c970 <rtems_semaphore_delete> <== NOT EXECUTED
2007198: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
rtems_disk_delete (dev);
200719c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20071a0: 7f ff f4 c2 call 20044a8 <rtems_disk_delete> <== NOT EXECUTED
20071a4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
free (fd->copy_buffer);
20071a8: 40 00 03 8f call 2007fe4 <free> <== NOT EXECUTED
20071ac: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
20071b0: 40 00 03 8d call 2007fe4 <free> <== NOT EXECUTED
20071b4: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
20071b8: 40 00 03 8b call 2007fe4 <free> <== NOT EXECUTED
20071bc: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("disk create phy failed");
20071c0: 11 00 80 c5 sethi %hi(0x2031400), %o0 <== NOT EXECUTED
20071c4: 7f ff f7 62 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
20071c8: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 20316b8 <__FUNCTION__.7127+0xfe0><== NOT EXECUTED
20071cc: 81 c7 e0 08 ret <== NOT EXECUTED
20071d0: 81 e8 00 00 restore <== NOT EXECUTED
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
20071d4: 84 10 20 00 clr %g2
{
rtems_fdisk_segment_ctl* sc;
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
20071d8: a8 00 40 18 add %g1, %i0, %l4
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++)
20071dc: da 00 40 18 ld [ %g1 + %i0 ], %o5
* Count the segments for a device.
*/
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
20071e0: a6 10 20 00 clr %l3
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
20071e4: 10 80 00 06 b 20071fc <rtems_fdisk_initialize+0x2c4>
20071e8: 82 10 20 00 clr %g1
20071ec: 82 00 60 01 inc %g1
count += dd->segments[segment].count;
20071f0: c6 10 c0 02 lduh [ %g3 + %g2 ], %g3
20071f4: 84 00 a0 0c add %g2, 0xc, %g2
20071f8: a6 04 c0 03 add %l3, %g3, %l3
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++)
20071fc: 80 a0 40 0d cmp %g1, %o5
2007200: 32 bf ff fb bne,a 20071ec <rtems_fdisk_initialize+0x2b4>
2007204: c6 05 20 04 ld [ %l4 + 4 ], %g3
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
2007208: c2 06 e0 2c ld [ %i3 + 0x2c ], %g1
200720c: 90 10 00 13 mov %l3, %o0
2007210: 88 00 40 18 add %g1, %i0, %g4
2007214: c2 27 bf ec st %g1, [ %fp + -20 ]
2007218: c8 27 bf dc st %g4, [ %fp + -36 ]
200721c: da 27 bf d4 st %o5, [ %fp + -44 ]
2007220: 40 00 02 71 call 2007be4 <calloc>
2007224: 92 10 20 30 mov 0x30, %o1
2007228: c2 07 bf ec ld [ %fp + -20 ], %g1
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
200722c: 80 a2 20 00 cmp %o0, 0
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
2007230: d0 20 40 18 st %o0, [ %g1 + %i0 ]
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
2007234: c8 07 bf dc ld [ %fp + -36 ], %g4
2007238: 12 80 00 23 bne 20072c4 <rtems_fdisk_initialize+0x38c> <== ALWAYS TAKEN
200723c: da 07 bf d4 ld [ %fp + -44 ], %o5
{
rtems_disk_delete (dev);
2007240: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2007244: 7f ff f4 99 call 20044a8 <rtems_disk_delete> <== NOT EXECUTED
2007248: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
200724c: 40 00 15 c9 call 200c970 <rtems_semaphore_delete> <== NOT EXECUTED
2007250: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
2007254: 40 00 03 64 call 2007fe4 <free> <== NOT EXECUTED
2007258: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
200725c: 40 00 03 62 call 2007fe4 <free> <== NOT EXECUTED
2007260: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
2007264: 40 00 03 60 call 2007fe4 <free> <== NOT EXECUTED
2007268: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
if (!fd->copy_buffer)
return RTEMS_NO_MEMORY;
200726c: 81 c7 e0 08 ret <== NOT EXECUTED
2007270: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
const rtems_fdisk_segment_desc* sd;
uint32_t seg_segment;
sd = &c->devices[device].segments[segment];
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
2007274: 86 10 20 00 clr %g3
for (segment = 0; segment < c->devices[device].segment_count; segment++)
{
const rtems_fdisk_segment_desc* sd;
uint32_t seg_segment;
sd = &c->devices[device].segments[segment];
2007278: 96 00 40 02 add %g1, %g2, %o3
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
200727c: d8 10 40 02 lduh [ %g1 + %g2 ], %o4
2007280: 10 80 00 07 b 200729c <rtems_fdisk_initialize+0x364>
2007284: 82 10 00 08 mov %o0, %g1
{
sc->descriptor = sd;
2007288: d6 20 60 04 st %o3, [ %g1 + 4 ]
sc->device = device;
200728c: e2 20 60 08 st %l1, [ %g1 + 8 ]
sc->segment = seg_segment;
sc->erased = 0;
2007290: 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++)
2007294: 86 00 e0 01 inc %g3
2007298: 82 00 60 30 add %g1, 0x30, %g1
200729c: 80 a0 c0 0c cmp %g3, %o4
20072a0: 2a bf ff fa bcs,a 2007288 <rtems_fdisk_initialize+0x350>
20072a4: c6 20 60 0c st %g3, [ %g1 + 0xc ]
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
20072a8: 83 2b 20 04 sll %o4, 4, %g1
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
20072ac: 9e 03 e0 01 inc %o7
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
20072b0: 99 2b 20 06 sll %o4, 6, %o4
20072b4: 84 00 a0 0c add %g2, 0xc, %g2
20072b8: 98 23 00 01 sub %o4, %g1, %o4
20072bc: 10 80 00 04 b 20072cc <rtems_fdisk_initialize+0x394>
20072c0: 90 02 00 0c add %o0, %o4, %o0
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
20072c4: 84 10 20 00 clr %g2
20072c8: 9e 10 20 00 clr %o7
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
20072cc: 80 a3 c0 0d cmp %o7, %o5
20072d0: 32 bf ff e9 bne,a 2007274 <rtems_fdisk_initialize+0x33c>
20072d4: c2 05 20 04 ld [ %l4 + 4 ], %g1
sc->segment = seg_segment;
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
20072d8: e6 21 20 04 st %l3, [ %g4 + 4 ]
fd->devices[device].descriptor = &c->devices[device];
20072dc: e8 21 20 08 st %l4, [ %g4 + 8 ]
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
20072e0: a2 04 60 01 inc %l1
20072e4: 10 80 00 03 b 20072f0 <rtems_fdisk_initialize+0x3b8>
20072e8: b0 06 20 0c add %i0, 0xc, %i0
}
sc = rtems_disk_create_phys(dev, c->block_size,
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
20072ec: a2 10 20 00 clr %l1
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
20072f0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
20072f4: 80 a4 40 01 cmp %l1, %g1
20072f8: 2a bf ff b7 bcs,a 20071d4 <rtems_fdisk_initialize+0x29c>
20072fc: c2 06 a0 08 ld [ %i2 + 8 ], %g1
fd->devices[device].segment_count = segment_count;
fd->devices[device].descriptor = &c->devices[device];
}
fd->device_count = c->device_count;
2007300: c2 26 e0 30 st %g1, [ %i3 + 0x30 ]
ret = rtems_fdisk_recover_block_mappings (fd);
2007304: 7f ff f8 46 call 200541c <rtems_fdisk_recover_block_mappings>
2007308: 90 10 00 1b mov %i3, %o0
if (ret)
200730c: b0 92 20 00 orcc %o0, 0, %i0
2007310: 22 80 00 13 be,a 200735c <rtems_fdisk_initialize+0x424> <== ALWAYS TAKEN
2007314: 90 10 00 1b mov %i3, %o0
{
rtems_disk_delete (dev);
2007318: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200731c: 7f ff f4 63 call 20044a8 <rtems_disk_delete> <== NOT EXECUTED
2007320: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
2007324: 40 00 15 93 call 200c970 <rtems_semaphore_delete> <== NOT EXECUTED
2007328: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
200732c: 40 00 03 2e call 2007fe4 <free> <== NOT EXECUTED
2007330: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007334: 40 00 03 2c call 2007fe4 <free> <== NOT EXECUTED
2007338: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
200733c: 40 00 03 2a call 2007fe4 <free> <== NOT EXECUTED
2007340: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
2007344: 40 00 6f 7c call 2023134 <strerror> <== NOT EXECUTED
2007348: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200734c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2007350: 11 00 80 c5 sethi %hi(0x2031400), %o0 <== NOT EXECUTED
2007354: 10 80 00 17 b 20073b0 <rtems_fdisk_initialize+0x478> <== NOT EXECUTED
2007358: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 20316d0 <__FUNCTION__.7127+0xff8><== NOT EXECUTED
strerror (ret), ret);
return ret;
}
ret = rtems_fdisk_compact (fd);
200735c: 7f ff fa 05 call 2005b70 <rtems_fdisk_compact>
2007360: a4 04 a0 74 add %l2, 0x74, %l2
if (ret)
2007364: 80 a2 20 00 cmp %o0, 0
2007368: 02 80 00 16 be 20073c0 <rtems_fdisk_initialize+0x488> <== ALWAYS TAKEN
200736c: b0 10 00 08 mov %o0, %i0
{
rtems_disk_delete (dev);
2007370: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2007374: 7f ff f4 4d call 20044a8 <rtems_disk_delete> <== NOT EXECUTED
2007378: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
200737c: 40 00 15 7d call 200c970 <rtems_semaphore_delete> <== NOT EXECUTED
2007380: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
2007384: 40 00 03 18 call 2007fe4 <free> <== NOT EXECUTED
2007388: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
200738c: 40 00 03 16 call 2007fe4 <free> <== NOT EXECUTED
2007390: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
2007394: 40 00 03 14 call 2007fe4 <free> <== NOT EXECUTED
2007398: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("compacting of disk failed: %s (%d)",
200739c: 40 00 6f 66 call 2023134 <strerror> <== NOT EXECUTED
20073a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20073a4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
20073a8: 11 00 80 c5 sethi %hi(0x2031400), %o0 <== NOT EXECUTED
20073ac: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 20316f8 <__FUNCTION__.7127+0x1020><== NOT EXECUTED
20073b0: 7f ff f6 e7 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
20073b4: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
20073b8: 81 c7 e0 08 ret <== NOT EXECUTED
20073bc: 81 e8 00 00 restore <== NOT EXECUTED
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
20073c0: b2 06 60 01 inc %i1
20073c4: 10 80 00 04 b 20073d4 <rtems_fdisk_initialize+0x49c>
20073c8: b4 06 a0 20 add %i2, 0x20, %i2
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
if (!fd->copy_buffer)
return RTEMS_NO_MEMORY;
20073cc: 81 c7 e0 08 ret <== NOT EXECUTED
20073d0: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
20073d4: c2 05 e0 9c ld [ %l7 + 0x9c ], %g1
20073d8: 80 a6 40 01 cmp %i1, %g1
20073dc: 2a bf fe f9 bcs,a 2006fc0 <rtems_fdisk_initialize+0x88>
20073e0: ec 37 bf f8 sth %l6, [ %fp + -8 ]
strerror (ret), ret);
return ret;
}
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
20073e4: 05 00 81 19 sethi %hi(0x2046400), %g2
20073e8: c2 20 a0 84 st %g1, [ %g2 + 0x84 ] ! 2046484 <rtems_flashdisk_count>
return RTEMS_SUCCESSFUL;
20073ec: 81 c7 e0 08 ret
20073f0: 91 e8 20 00 restore %g0, 0, %o0
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
20073f4: d0 05 e0 9c ld [ %l7 + 0x9c ], %o0
20073f8: 92 10 20 74 mov 0x74, %o1
20073fc: 40 00 01 fa call 2007be4 <calloc>
2007400: 2b 00 81 19 sethi %hi(0x2046400), %l5
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
2007404: 80 a2 20 00 cmp %o0, 0
2007408: 02 bf ff f1 be 20073cc <rtems_fdisk_initialize+0x494> <== NEVER TAKEN
200740c: d0 25 60 80 st %o0, [ %l5 + 0x80 ]
2007410: 35 00 80 c0 sethi %hi(0x2030000), %i2
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
2007414: 2d 00 00 18 sethi %hi(0x6000), %l6
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
2007418: a4 10 20 00 clr %l2
200741c: b4 16 a2 70 or %i2, 0x270, %i2
2007420: b2 10 20 00 clr %i1
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
2007424: 10 bf ff ec b 20073d4 <rtems_fdisk_initialize+0x49c>
2007428: ac 15 a1 00 or %l6, 0x100, %l6
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
200742c: 81 c7 e0 08 ret <== NOT EXECUTED
2007430: 81 e8 00 00 restore <== NOT EXECUTED
02005da8 <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)
{
2005da8: 9d e3 bf 38 save %sp, -200, %sp
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
errno = 0;
2005dac: 40 00 6b 1d call 2020a20 <__errno>
2005db0: f8 06 20 04 ld [ %i0 + 4 ], %i4
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
2005db4: 83 2f 20 02 sll %i4, 2, %g1
2005db8: b7 2f 20 05 sll %i4, 5, %i3
2005dbc: 3b 00 81 19 sethi %hi(0x2046400), %i5
2005dc0: b6 26 c0 01 sub %i3, %g1, %i3
2005dc4: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
errno = 0;
2005dc8: c0 22 00 00 clr [ %o0 ]
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
2005dcc: b6 06 c0 1c add %i3, %i4, %i3
2005dd0: b7 2e e0 02 sll %i3, 2, %i3
2005dd4: 82 00 40 1b add %g1, %i3, %g1
2005dd8: d0 00 60 64 ld [ %g1 + 0x64 ], %o0
2005ddc: 92 10 20 00 clr %o1
2005de0: 40 00 1b 13 call 200ca2c <rtems_semaphore_obtain>
2005de4: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
2005de8: 80 a2 20 00 cmp %o0, 0
2005dec: 12 80 04 42 bne 2006ef4 <rtems_fdisk_ioctl+0x114c> <== NEVER TAKEN
2005df0: 01 00 00 00 nop
errno = EIO;
else
{
errno = 0;
2005df4: 40 00 6b 0b call 2020a20 <__errno>
2005df8: 01 00 00 00 nop
switch (req)
2005dfc: 03 08 00 10 sethi %hi(0x20004000), %g1
2005e00: 84 10 62 83 or %g1, 0x283, %g2 ! 20004283 <RAM_END+0x1dc04283>
2005e04: 80 a6 40 02 cmp %i1, %g2
2005e08: 02 80 02 cf be 2006944 <rtems_fdisk_ioctl+0xb9c> <== NEVER TAKEN
2005e0c: c0 22 00 00 clr [ %o0 ]
2005e10: 80 a6 40 02 cmp %i1, %g2
2005e14: 38 80 00 0c bgu,a 2005e44 <rtems_fdisk_ioctl+0x9c>
2005e18: 82 10 62 85 or %g1, 0x285, %g1
2005e1c: 84 10 62 81 or %g1, 0x281, %g2
2005e20: 80 a6 40 02 cmp %i1, %g2
2005e24: 02 80 02 aa be 20068cc <rtems_fdisk_ioctl+0xb24> <== NEVER TAKEN
2005e28: 01 00 00 00 nop
2005e2c: 18 80 02 b0 bgu 20068ec <rtems_fdisk_ioctl+0xb44> <== NEVER TAKEN
2005e30: 82 10 62 80 or %g1, 0x280, %g1
2005e34: 80 a6 40 01 cmp %i1, %g1
2005e38: 32 80 04 24 bne,a 2006ec8 <rtems_fdisk_ioctl+0x1120> <== ALWAYS TAKEN
2005e3c: 90 10 00 18 mov %i0, %o0
2005e40: 30 80 02 67 b,a 20067dc <rtems_fdisk_ioctl+0xa34> <== NOT EXECUTED
2005e44: 80 a6 40 01 cmp %i1, %g1
2005e48: 02 80 03 1f be 2006ac4 <rtems_fdisk_ioctl+0xd1c>
2005e4c: 01 00 00 00 nop
2005e50: 0a 80 03 1a bcs 2006ab8 <rtems_fdisk_ioctl+0xd10> <== NEVER TAKEN
2005e54: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
2005e58: 03 30 06 10 sethi %hi(0xc0184000), %g1
2005e5c: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
2005e60: 80 a6 40 01 cmp %i1, %g1
2005e64: 12 80 04 19 bne 2006ec8 <rtems_fdisk_ioctl+0x1120>
2005e68: 90 10 00 18 mov %i0, %o0
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
2005e6c: 03 00 81 19 sethi %hi(0x2046400), %g1
2005e70: c2 00 60 84 ld [ %g1 + 0x84 ], %g1 ! 2046484 <rtems_flashdisk_count>
2005e74: 80 a7 00 01 cmp %i4, %g1
2005e78: 1a 80 00 08 bcc 2005e98 <rtems_fdisk_ioctl+0xf0> <== NEVER TAKEN
2005e7c: 01 00 00 00 nop
(rtems_flashdisks[minor].device_count == 0))
2005e80: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
2005e84: 82 00 40 1b add %g1, %i3, %g1
{
errno = 0;
switch (req)
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
2005e88: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
2005e8c: 80 a0 60 00 cmp %g1, 0
2005e90: 32 80 00 06 bne,a 2005ea8 <rtems_fdisk_ioctl+0x100> <== ALWAYS TAKEN
2005e94: c2 06 80 00 ld [ %i2 ], %g1
(rtems_flashdisks[minor].device_count == 0))
{
errno = ENODEV;
2005e98: 40 00 6a e2 call 2020a20 <__errno> <== NOT EXECUTED
2005e9c: 01 00 00 00 nop <== NOT EXECUTED
2005ea0: 10 80 02 4d b 20067d4 <rtems_fdisk_ioctl+0xa2c> <== NOT EXECUTED
2005ea4: 82 10 20 13 mov 0x13, %g1 ! 13 <PROM_START+0x13> <== NOT EXECUTED
}
else
{
switch (r->req)
2005ea8: 80 a0 60 00 cmp %g1, 0
2005eac: 02 80 00 05 be 2005ec0 <rtems_fdisk_ioctl+0x118>
2005eb0: 80 a0 60 01 cmp %g1, 1
2005eb4: 12 80 02 45 bne 20067c8 <rtems_fdisk_ioctl+0xa20> <== NEVER TAKEN
2005eb8: 01 00 00 00 nop
2005ebc: 30 80 00 b5 b,a 2006190 <rtems_fdisk_ioctl+0x3e8>
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
2005ec0: 40 00 6a d8 call 2020a20 <__errno>
2005ec4: b0 06 a0 18 add %i2, 0x18, %i0
2005ec8: f8 07 60 80 ld [ %i5 + 0x80 ], %i4
2005ecc: d0 27 bf ec st %o0, [ %fp + -20 ]
2005ed0: b8 07 00 1b add %i4, %i3, %i4
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
2005ed4: 10 80 00 a2 b 200615c <rtems_fdisk_ioctl+0x3b4>
2005ed8: a4 10 20 00 clr %l2
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
2005edc: d2 07 20 14 ld [ %i4 + 0x14 ], %o1
2005ee0: 7f ff f1 e7 call 200267c <.udiv>
2005ee4: a2 10 20 00 clr %l1
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
2005ee8: 2d 00 80 c3 sethi %hi(0x2030c00), %l6
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
2005eec: d0 27 bf e8 st %o0, [ %fp + -24 ]
data = sg->buffer;
2005ef0: e0 06 20 08 ld [ %i0 + 8 ], %l0
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
2005ef4: 10 80 00 91 b 2006138 <rtems_fdisk_ioctl+0x390>
2005ef8: 2f 00 80 c3 sethi %hi(0x2030c00), %l7
rtems_fdisk_block_ctl* bc;
rtems_fdisk_segment_ctl* sc;
rtems_fdisk_page_desc* pd;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block:%d", block);
2005efc: 90 10 00 1c mov %i4, %o0
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
{
ret = rtems_fdisk_read_block (fd, sg->block + b, data);
2005f00: b2 04 40 19 add %l1, %i1, %i1
rtems_fdisk_block_ctl* bc;
rtems_fdisk_segment_ctl* sc;
rtems_fdisk_page_desc* pd;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block:%d", block);
2005f04: 13 00 80 c4 sethi %hi(0x2031000), %o1
2005f08: 94 10 00 19 mov %i1, %o2
2005f0c: 7f ff fb b0 call 2004dcc <rtems_fdisk_info>
2005f10: 92 12 60 80 or %o1, 0x80, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
2005f14: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
2005f18: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
2005f1c: 82 20 80 01 sub %g2, %g1, %g1
2005f20: 80 a6 40 01 cmp %i1, %g1
2005f24: 2a 80 00 08 bcs,a 2005f44 <rtems_fdisk_ioctl+0x19c> <== ALWAYS TAKEN
2005f28: c6 07 20 18 ld [ %i4 + 0x18 ], %g3
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
2005f2c: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
2005f30: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2005f34: 7f ff fc 06 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
2005f38: 90 12 20 90 or %o0, 0x90, %o0 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2005f3c: 10 80 00 84 b 200614c <rtems_fdisk_ioctl+0x3a4> <== NOT EXECUTED
2005f40: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
2005f44: 83 2e 60 03 sll %i1, 3, %g1
if (!bc->segment)
2005f48: fa 00 c0 01 ld [ %g3 + %g1 ], %i5
2005f4c: 80 a7 60 00 cmp %i5, 0
2005f50: 12 80 00 0d bne 2005f84 <rtems_fdisk_ioctl+0x1dc>
2005f54: aa 00 c0 01 add %g3, %g1, %l5
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
2005f58: 94 10 00 19 mov %i1, %o2
2005f5c: 90 10 00 1c mov %i4, %o0
2005f60: 13 00 80 c4 sethi %hi(0x2031000), %o1
2005f64: 7f ff fb 9a call 2004dcc <rtems_fdisk_info>
2005f68: 92 12 60 b8 or %o1, 0xb8, %o1 ! 20310b8 <__FUNCTION__.7127+0x9e0>
#endif
memset (buffer, 0xff, fd->block_size);
2005f6c: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
2005f70: 90 10 00 10 mov %l0, %o0
2005f74: 40 00 6f 86 call 2021d8c <memset>
2005f78: 92 10 20 ff mov 0xff, %o1
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2005f7c: 10 80 03 ea b 2006f24 <rtems_fdisk_ioctl+0x117c>
2005f80: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
2005f84: da 05 60 04 ld [ %l5 + 4 ], %o5
2005f88: e8 07 60 10 ld [ %i5 + 0x10 ], %l4
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
2005f8c: 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];
2005f90: a7 2b 60 03 sll %o5, 3, %l3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
2005f94: 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];
2005f98: 86 05 00 13 add %l4, %l3, %g3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
2005f9c: d8 07 60 0c ld [ %i5 + 0xc ], %o4
2005fa0: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
2005fa4: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
2005fa8: d4 07 60 20 ld [ %i5 + 0x20 ], %o2
2005fac: 80 a1 20 00 cmp %g4, 0
2005fb0: 02 80 00 04 be 2005fc0 <rtems_fdisk_ioctl+0x218>
2005fb4: de 07 60 24 ld [ %i5 + 0x24 ], %o7
2005fb8: 10 80 00 03 b 2005fc4 <rtems_fdisk_ioctl+0x21c>
2005fbc: 88 15 e0 18 or %l7, 0x18, %g4
2005fc0: 88 15 a0 20 or %l6, 0x20, %g4
2005fc4: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
2005fc8: d2 23 a0 60 st %o1, [ %sp + 0x60 ]
2005fcc: d4 23 a0 64 st %o2, [ %sp + 0x64 ]
2005fd0: de 23 a0 68 st %o7, [ %sp + 0x68 ]
2005fd4: c8 23 a0 6c st %g4, [ %sp + 0x6c ]
2005fd8: c8 10 e0 02 lduh [ %g3 + 2 ], %g4
2005fdc: 90 10 00 1c mov %i4, %o0
2005fe0: c8 23 a0 70 st %g4, [ %sp + 0x70 ]
2005fe4: c8 15 00 13 lduh [ %l4 + %l3 ], %g4
2005fe8: 13 00 80 c4 sethi %hi(0x2031000), %o1
2005fec: c8 23 a0 74 st %g4, [ %sp + 0x74 ]
2005ff0: c8 00 e0 04 ld [ %g3 + 4 ], %g4
2005ff4: 92 12 60 e0 or %o1, 0xe0, %o1
2005ff8: c6 27 bf d4 st %g3, [ %fp + -44 ]
2005ffc: c8 23 a0 78 st %g4, [ %sp + 0x78 ]
2006000: 7f ff fb 73 call 2004dcc <rtems_fdisk_info>
2006004: 94 10 00 19 mov %i1, %o2
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
2006008: c6 07 bf d4 ld [ %fp + -44 ], %g3
200600c: 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))
2006010: 80 88 e0 01 btst 1, %g3
2006014: 12 80 00 41 bne 2006118 <rtems_fdisk_ioctl+0x370> <== NEVER TAKEN
2006018: d8 05 60 04 ld [ %l5 + 4 ], %o4
{
if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
200601c: 80 88 e0 02 btst 2, %g3
2006020: 02 80 00 3c be 2006110 <rtems_fdisk_ioctl+0x368> <== NEVER TAKEN
2006024: 11 00 80 c4 sethi %hi(0x2031000), %o0
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
page * fd->block_size, buffer, fd->block_size);
2006028: c6 07 20 14 ld [ %i4 + 0x14 ], %g3
/*
* We use the segment page offset not the page number used in the
* driver. This skips the page descriptors.
*/
int ret = rtems_fdisk_seg_read_page (fd, sc,
200602c: 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,
2006030: 92 10 00 03 mov %g3, %o1
2006034: 90 02 00 0c add %o0, %o4, %o0
2006038: 7f ff f1 57 call 2002594 <.umul>
200603c: c6 27 bf d4 st %g3, [ %fp + -44 ]
2006040: c6 07 bf d4 ld [ %fp + -44 ], %g3
2006044: 94 10 00 08 mov %o0, %o2
2006048: 98 10 00 03 mov %g3, %o4
200604c: 90 10 00 1c mov %i4, %o0
2006050: 92 10 00 1d mov %i5, %o1
2006054: 7f ff fc 78 call 2005234 <rtems_fdisk_seg_read>
2006058: 96 10 00 10 mov %l0, %o3
* driver. This skips the page descriptors.
*/
int ret = rtems_fdisk_seg_read_page (fd, sc,
bc->page + sc->pages_desc, buffer);
if (ret)
200605c: 86 92 20 00 orcc %o0, 0, %g3
2006060: 22 80 00 13 be,a 20060ac <rtems_fdisk_ioctl+0x304> <== ALWAYS TAKEN
2006064: 03 00 81 19 sethi %hi(0x2046400), %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
2006068: e0 07 60 08 ld [ %i5 + 8 ], %l0 <== NOT EXECUTED
200606c: f2 07 60 0c ld [ %i5 + 0xc ], %i1 <== NOT EXECUTED
2006070: fa 05 60 04 ld [ %l5 + 4 ], %i5 <== NOT EXECUTED
2006074: 40 00 74 30 call 2023134 <strerror> <== NOT EXECUTED
2006078: c6 27 bf d4 st %g3, [ %fp + -44 ] <== NOT EXECUTED
200607c: c6 07 bf d4 ld [ %fp + -44 ], %g3 <== NOT EXECUTED
2006080: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
2006084: c6 23 a0 5c st %g3, [ %sp + 0x5c ] <== NOT EXECUTED
2006088: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
200608c: 13 00 80 c4 sethi %hi(0x2031000), %o1 <== NOT EXECUTED
2006090: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2006094: 92 12 61 28 or %o1, 0x128, %o1 <== NOT EXECUTED
2006098: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
200609c: 7f ff fb 4c call 2004dcc <rtems_fdisk_info> <== NOT EXECUTED
20060a0: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
20060a4: 10 80 00 2a b 200614c <rtems_fdisk_ioctl+0x3a4> <== NOT EXECUTED
20060a8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
strerror (ret), ret);
#endif
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
20060ac: c6 07 20 14 ld [ %i4 + 0x14 ], %g3
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
20060b0: c8 00 60 88 ld [ %g1 + 0x88 ], %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++)
20060b4: 84 10 20 00 clr %g2
* Calculate the checksum of a page in a segment.
*/
static uint16_t
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
20060b8: 10 80 00 09 b 20060dc <rtems_fdisk_ioctl+0x334>
20060bc: 94 10 3f ff mov -1, %o2
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
20060c0: fa 0c 00 02 ldub [ %l0 + %g2 ], %i5
20060c4: 95 32 a0 10 srl %o2, 0x10, %o2
20060c8: 94 1f 40 0a xor %i5, %o2, %o2
20060cc: 94 0a a0 ff and %o2, 0xff, %o2
20060d0: 95 2a a0 01 sll %o2, 1, %o2
20060d4: d4 11 00 0a lduh [ %g4 + %o2 ], %o2
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20060d8: 84 00 a0 01 inc %g2
20060dc: 80 a0 80 03 cmp %g2, %g3
20060e0: 12 bf ff f8 bne 20060c0 <rtems_fdisk_ioctl+0x318>
20060e4: 95 2a a0 10 sll %o2, 0x10, %o2
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
if (cs == pd->crc)
20060e8: d6 15 00 13 lduh [ %l4 + %l3 ], %o3
20060ec: 95 32 a0 10 srl %o2, 0x10, %o2
20060f0: 80 a2 80 0b cmp %o2, %o3
20060f4: 02 80 03 8b be 2006f20 <rtems_fdisk_ioctl+0x1178> <== ALWAYS TAKEN
20060f8: 11 00 80 c4 sethi %hi(0x2031000), %o0
return 0;
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
20060fc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2006100: 7f ff fb 93 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
2006104: 90 12 21 60 or %o0, 0x160, %o0 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2006108: 10 80 00 11 b 200614c <rtems_fdisk_ioctl+0x3a4> <== NOT EXECUTED
200610c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
block, cs, pd->crc);
}
else
{
rtems_fdisk_error ("read-block: block points to used page: %d: %d-%d-%d",
2006110: 10 80 00 04 b 2006120 <rtems_fdisk_ioctl+0x378> <== NOT EXECUTED
2006114: 90 12 21 98 or %o0, 0x198, %o0 <== NOT EXECUTED
block, sc->device, sc->segment, bc->page);
}
}
else
{
rtems_fdisk_error ("read-block: block page not active: %d: %d-%d-%d",
2006118: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
200611c: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 20311d0 <__FUNCTION__.7127+0xaf8><== NOT EXECUTED
2006120: d4 07 60 08 ld [ %i5 + 8 ], %o2 <== NOT EXECUTED
2006124: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
2006128: 7f ff fb 89 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
200612c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2006130: 10 80 03 80 b 2006f30 <rtems_fdisk_ioctl+0x1188> <== NOT EXECUTED
2006134: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2006138: c4 07 bf e8 ld [ %fp + -24 ], %g2
200613c: 80 a4 40 02 cmp %l1, %g2
2006140: 32 bf ff 6f bne,a 2005efc <rtems_fdisk_ioctl+0x154>
2006144: f2 06 00 00 ld [ %i0 ], %i1
2006148: 82 10 20 00 clr %g1
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
200614c: a4 04 a0 01 inc %l2
2006150: 80 a0 60 00 cmp %g1, 0
2006154: 12 80 00 08 bne 2006174 <rtems_fdisk_ioctl+0x3cc> <== NEVER TAKEN
2006158: b0 06 20 10 add %i0, 0x10, %i0
200615c: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
2006160: 80 a4 80 01 cmp %l2, %g1
2006164: 2a bf ff 5e bcs,a 2005edc <rtems_fdisk_ioctl+0x134>
2006168: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
200616c: 10 80 00 03 b 2006178 <rtems_fdisk_ioctl+0x3d0>
2006170: 92 10 20 00 clr %o1
2006174: 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);
2006178: c2 06 a0 04 ld [ %i2 + 4 ], %g1
200617c: 9f c0 40 00 call %g1
2006180: 90 10 00 1a mov %i2, %o0
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
2006184: c2 07 bf ec ld [ %fp + -20 ], %g1
break;
2006188: 10 80 03 53 b 2006ed4 <rtems_fdisk_ioctl+0x112c>
200618c: c0 20 40 00 clr [ %g1 ]
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
2006190: 40 00 6a 24 call 2020a20 <__errno>
2006194: a0 06 a0 18 add %i2, 0x18, %l0
2006198: 03 00 81 19 sethi %hi(0x2046400), %g1
200619c: fa 00 60 80 ld [ %g1 + 0x80 ], %i5 ! 2046480 <rtems_flashdisks>
20061a0: d0 27 bf e8 st %o0, [ %fp + -24 ]
20061a4: ba 07 40 1b add %i5, %i3, %i5
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
20061a8: 10 80 01 7c b 2006798 <rtems_fdisk_ioctl+0x9f0>
20061ac: aa 10 20 00 clr %l5
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
20061b0: d2 07 60 14 ld [ %i5 + 0x14 ], %o1
20061b4: 7f ff f1 32 call 200267c <.udiv>
20061b8: a4 10 20 00 clr %l2
data = sg->buffer;
20061bc: e2 04 20 08 ld [ %l0 + 8 ], %l1
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
20061c0: 10 80 01 6d b 2006774 <rtems_fdisk_ioctl+0x9cc>
20061c4: d0 27 bf e4 st %o0, [ %fp + -28 ]
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
20061c8: 90 10 00 1d mov %i5, %o0
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
20061cc: b2 04 80 19 add %l2, %i1, %i1
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
20061d0: 13 00 80 c4 sethi %hi(0x2031000), %o1
20061d4: 94 10 00 19 mov %i1, %o2
20061d8: 7f ff fa fd call 2004dcc <rtems_fdisk_info>
20061dc: 92 12 62 00 or %o1, 0x200, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
20061e0: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
20061e4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
20061e8: 82 20 80 01 sub %g2, %g1, %g1
20061ec: 80 a6 40 01 cmp %i1, %g1
20061f0: 2a 80 00 08 bcs,a 2006210 <rtems_fdisk_ioctl+0x468> <== ALWAYS TAKEN
20061f4: ee 07 60 18 ld [ %i5 + 0x18 ], %l7
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
20061f8: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
20061fc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2006200: 7f ff fb 53 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
2006204: 90 12 22 10 or %o0, 0x210, %o0 <== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
rtems_fdisk_queue_segment (fd, sc);
return EIO;
2006208: 10 80 01 60 b 2006788 <rtems_fdisk_ioctl+0x9e0> <== NOT EXECUTED
200620c: b2 10 20 05 mov 5, %i1 <== NOT EXECUTED
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
2006210: ad 2e 60 03 sll %i1, 3, %l6
/*
* Does the page exist in flash ?
*/
if (bc->segment)
2006214: f8 05 c0 16 ld [ %l7 + %l6 ], %i4
2006218: 80 a7 20 00 cmp %i4, 0
200621c: 02 80 00 97 be 2006478 <rtems_fdisk_ioctl+0x6d0>
2006220: b0 05 c0 16 add %l7, %l6, %i0
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
2006224: c2 06 20 04 ld [ %i0 + 4 ], %g1
2006228: c4 07 20 10 ld [ %i4 + 0x10 ], %g2
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
200622c: d4 07 20 08 ld [ %i4 + 8 ], %o2
2006230: d6 07 20 0c ld [ %i4 + 0xc ], %o3
2006234: 98 10 00 01 mov %g1, %o4
2006238: c2 27 bf dc st %g1, [ %fp + -36 ]
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
200623c: c4 27 bf e0 st %g2, [ %fp + -32 ]
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
2006240: 90 10 00 1d mov %i5, %o0
2006244: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006248: 7f ff fa e1 call 2004dcc <rtems_fdisk_info>
200624c: 92 12 62 38 or %o1, 0x238, %o1 ! 2031238 <__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);
2006250: 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,
2006254: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
page * fd->block_size, buffer, fd->block_size);
2006258: c4 27 bf ec st %g2, [ %fp + -20 ]
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
200625c: c4 06 20 04 ld [ %i0 + 4 ], %g2
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
2006260: d2 07 bf ec ld [ %fp + -20 ], %o1
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
2006264: e8 07 20 08 ld [ %i4 + 8 ], %l4
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
2006268: 7f ff f0 cb call 2002594 <.umul>
200626c: 90 02 00 02 add %o0, %g2, %o0
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
2006270: 89 2d 20 04 sll %l4, 4, %g4
2006274: 87 2d 20 02 sll %l4, 2, %g3
2006278: 86 21 00 03 sub %g4, %g3, %g3
200627c: c8 07 60 2c ld [ %i5 + 0x2c ], %g4
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
2006280: e6 07 20 0c ld [ %i4 + 0xc ], %l3
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
2006284: 9e 01 00 03 add %g4, %g3, %o7
2006288: c8 01 00 03 ld [ %g4 + %g3 ], %g4
200628c: 9b 2c e0 06 sll %l3, 6, %o5
2006290: 87 2c e0 04 sll %l3, 4, %g3
2006294: 86 23 40 03 sub %o5, %g3, %g3
2006298: 86 01 00 03 add %g4, %g3, %g3
200629c: c8 00 e0 04 ld [ %g3 + 4 ], %g4
uint32_t size)
{
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
20062a0: c6 03 e0 08 ld [ %o7 + 8 ], %g3
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
20062a4: da 07 bf ec ld [ %fp + -20 ], %o5
uint32_t size)
{
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
20062a8: c6 00 e0 08 ld [ %g3 + 8 ], %g3
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
20062ac: 84 10 00 08 mov %o0, %g2
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
20062b0: 94 10 00 14 mov %l4, %o2
20062b4: 98 10 00 02 mov %g2, %o4
20062b8: c4 3f bf d0 std %g2, [ %fp + -48 ]
20062bc: 96 10 00 13 mov %l3, %o3
20062c0: c8 27 bf cc st %g4, [ %fp + -52 ]
20062c4: 90 10 00 1d mov %i5, %o0
20062c8: 13 00 80 c4 sethi %hi(0x2031000), %o1
20062cc: 7f ff fa e0 call 2004e4c <rtems_fdisk_printf>
20062d0: 92 12 62 60 or %o1, 0x260, %o1 ! 2031260 <__FUNCTION__.7127+0xb88>
device, segment, offset, size);
#endif
return ops->verify (sd, device, segment, offset, buffer, size);
20062d4: c6 07 bf d4 ld [ %fp + -44 ], %g3
20062d8: c8 07 bf cc ld [ %fp + -52 ], %g4
20062dc: c4 07 bf d0 ld [ %fp + -48 ], %g2
20062e0: c6 00 e0 0c ld [ %g3 + 0xc ], %g3
20062e4: da 07 bf ec ld [ %fp + -20 ], %o5
20062e8: 92 10 00 14 mov %l4, %o1
20062ec: 90 10 00 04 mov %g4, %o0
20062f0: 94 10 00 13 mov %l3, %o2
20062f4: 96 10 00 02 mov %g2, %o3
20062f8: 9f c0 c0 00 call %g3
20062fc: 98 10 00 11 mov %l1, %o4
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
2006300: c2 07 bf dc ld [ %fp + -36 ], %g1
2006304: 80 a2 20 00 cmp %o0, 0
2006308: 12 80 00 0c bne 2006338 <rtems_fdisk_ioctl+0x590>
200630c: e8 06 20 04 ld [ %i0 + 4 ], %l4
bc->page + sc->pages_desc, buffer) == 0)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d=>%02d-%03d-%03d: page verified",
2006310: d6 07 20 08 ld [ %i4 + 8 ], %o3
2006314: d8 07 20 0c ld [ %i4 + 0xc ], %o4
2006318: 90 10 00 1d mov %i5, %o0
200631c: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006320: 94 10 00 19 mov %i1, %o2
2006324: 92 12 62 88 or %o1, 0x288, %o1
2006328: 7f ff fa a9 call 2004dcc <rtems_fdisk_info>
200632c: 9a 10 00 14 mov %l4, %o5
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2006330: 10 80 01 0f b 200676c <rtems_fdisk_ioctl+0x9c4>
2006334: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
2006338: c4 07 bf e0 ld [ %fp + -32 ], %g2
200633c: 83 28 60 03 sll %g1, 3, %g1
2006340: 82 00 80 01 add %g2, %g1, %g1
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
2006344: c4 10 60 02 lduh [ %g1 + 2 ], %g2
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
2006348: c6 07 60 08 ld [ %i5 + 8 ], %g3
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
200634c: 84 08 bf fd and %g2, -3, %g2
2006350: c4 30 60 02 sth %g2, [ %g1 + 2 ]
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
2006354: 80 88 e0 08 btst 8, %g3
rtems_fdisk_seg_write_page_desc_flags (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +
2006358: 85 2d 20 03 sll %l4, 3, %g2
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
200635c: 02 80 00 20 be 20063dc <rtems_fdisk_ioctl+0x634> <== NEVER TAKEN
2006360: 84 00 a0 02 add %g2, 2, %g2
{
uint16_t flash_flags;
int ret;
ret = rtems_fdisk_seg_read (fd, sc, offset,
2006364: 94 10 00 02 mov %g2, %o2
2006368: c2 27 bf dc st %g1, [ %fp + -36 ]
200636c: c4 27 bf d0 st %g2, [ %fp + -48 ]
2006370: 90 10 00 1d mov %i5, %o0
2006374: 92 10 00 1c mov %i4, %o1
2006378: 96 07 bf f6 add %fp, -10, %o3
200637c: 7f ff fb ae call 2005234 <rtems_fdisk_seg_read>
2006380: 98 10 20 02 mov 2, %o4
&flash_flags, sizeof (flash_flags));
if (ret)
2006384: c2 07 bf dc ld [ %fp + -36 ], %g1
2006388: a6 92 20 00 orcc %o0, 0, %l3
200638c: 12 80 00 1d bne 2006400 <rtems_fdisk_ioctl+0x658> <== NEVER TAKEN
2006390: c4 07 bf d0 ld [ %fp + -48 ], %g2
return ret;
if ((flash_flags & page_desc->flags) != page_desc->flags)
2006394: c6 10 60 02 lduh [ %g1 + 2 ], %g3
2006398: d8 17 bf f6 lduh [ %fp + -10 ], %o4
200639c: 88 08 c0 0c and %g3, %o4, %g4
20063a0: 87 28 e0 10 sll %g3, 0x10, %g3
20063a4: 89 29 20 10 sll %g4, 0x10, %g4
20063a8: 80 a1 00 03 cmp %g4, %g3
20063ac: 02 80 00 0c be 20063dc <rtems_fdisk_ioctl+0x634> <== ALWAYS TAKEN
20063b0: 9b 30 e0 10 srl %g3, 0x10, %o5
{
rtems_fdisk_error (" seg-write-page-flags: %02d-%03d-%03d: "
20063b4: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED
20063b8: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED
20063bc: 99 2b 20 10 sll %o4, 0x10, %o4 <== NOT EXECUTED
20063c0: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
20063c4: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
20063c8: 99 33 20 10 srl %o4, 0x10, %o4 <== NOT EXECUTED
20063cc: 7f ff fa e0 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
20063d0: 90 12 22 b8 or %o0, 0x2b8, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
20063d4: 10 80 00 1b b 2006440 <rtems_fdisk_ioctl+0x698> <== NOT EXECUTED
20063d8: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 <== NOT EXECUTED
sc->device, sc->segment, page,
flash_flags, page_desc->flags);
return ret;
}
}
return rtems_fdisk_seg_write (fd, sc, offset,
20063dc: 90 10 00 1d mov %i5, %o0
20063e0: 92 10 00 1c mov %i4, %o1
20063e4: 94 10 00 02 mov %g2, %o2
20063e8: 96 00 60 02 add %g1, 2, %o3
20063ec: 7f ff fb d5 call 2005340 <rtems_fdisk_seg_write>
20063f0: 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)
20063f4: a6 92 20 00 orcc %o0, 0, %l3
20063f8: 22 80 00 12 be,a 2006440 <rtems_fdisk_ioctl+0x698> <== ALWAYS TAKEN
20063fc: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: " \
2006400: d4 07 20 08 ld [ %i4 + 8 ], %o2 <== NOT EXECUTED
2006404: d6 07 20 0c ld [ %i4 + 0xc ], %o3 <== NOT EXECUTED
2006408: e8 06 20 04 ld [ %i0 + 4 ], %l4 <== NOT EXECUTED
200640c: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
2006410: 40 00 73 49 call 2023134 <strerror> <== NOT EXECUTED
2006414: d4 3f bf c0 std %o2, [ %fp + -64 ] <== NOT EXECUTED
2006418: d4 1f bf c0 ldd [ %fp + -64 ], %o2 <== NOT EXECUTED
200641c: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
2006420: e6 23 a0 5c st %l3, [ %sp + 0x5c ] <== NOT EXECUTED
2006424: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006428: 13 00 80 c4 sethi %hi(0x2031000), %o1 <== NOT EXECUTED
200642c: 98 10 00 14 mov %l4, %o4 <== NOT EXECUTED
2006430: 7f ff fa 67 call 2004dcc <rtems_fdisk_info> <== NOT EXECUTED
2006434: 92 12 63 08 or %o1, 0x308, %o1 <== NOT EXECUTED
/*
* If possible reuse this segment. This will mean the segment
* needs to be removed from the available list and placed
* back if space is still available.
*/
rtems_fdisk_queue_segment (fd, sc);
2006438: 10 80 00 08 b 2006458 <rtems_fdisk_ioctl+0x6b0> <== NOT EXECUTED
200643c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
2006440: 82 00 7f ff add %g1, -1, %g1
2006444: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
sc->pages_used++;
2006448: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
200644c: 82 00 60 01 inc %g1
2006450: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
/*
* If possible reuse this segment. This will mean the segment
* needs to be removed from the available list and placed
* back if space is still available.
*/
rtems_fdisk_queue_segment (fd, sc);
2006454: 90 10 00 1d mov %i5, %o0
2006458: 7f ff fb 1a call 20050c0 <rtems_fdisk_queue_segment>
200645c: 92 10 00 1c mov %i4, %o1
/*
* If no background compacting then compact in the forground.
* If we compact we ignore the error as there is little we
* can do from here. The write may will work.
*/
if ((fd->flags & RTEMS_FDISK_BACKGROUND_COMPACT) == 0)
2006460: c2 07 60 08 ld [ %i5 + 8 ], %g1
2006464: 80 88 60 02 btst 2, %g1
2006468: 12 80 00 05 bne 200647c <rtems_fdisk_ioctl+0x6d4> <== NEVER TAKEN
200646c: b8 07 60 34 add %i5, 0x34, %i4
rtems_fdisk_compact (fd);
2006470: 7f ff fd c0 call 2005b70 <rtems_fdisk_compact>
2006474: 90 10 00 1d mov %i5, %o0
/*
* Is it time to compact the disk ?
*
* We override the background compaction configruation.
*/
if (rtems_fdisk_segment_count_queue (&fd->available) <=
2006478: b8 07 60 34 add %i5, 0x34, %i4
200647c: 7f ff f9 f4 call 2004c4c <rtems_fdisk_segment_count_queue>
2006480: 90 10 00 1c mov %i4, %o0
2006484: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2006488: 80 a2 00 01 cmp %o0, %g1
200648c: 18 80 00 04 bgu 200649c <rtems_fdisk_ioctl+0x6f4>
2006490: 01 00 00 00 nop
fd->avail_compact_segs)
rtems_fdisk_compact (fd);
2006494: 7f ff fd b7 call 2005b70 <rtems_fdisk_compact>
2006498: 90 10 00 1d mov %i5, %o0
/*
* Get the next avaliable segment.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
200649c: 7f ff f9 98 call 2004afc <rtems_fdisk_segment_queue_pop_head>
20064a0: 90 10 00 1c mov %i4, %o0
/*
* Is the flash disk full ?
*/
if (!sc)
20064a4: a6 92 20 00 orcc %o0, 0, %l3
20064a8: 32 80 00 13 bne,a 20064f4 <rtems_fdisk_ioctl+0x74c> <== ALWAYS TAKEN
20064ac: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
{
/*
* If compacting is configured for the background do it now
* to see if we can get some space back.
*/
if ((fd->flags & RTEMS_FDISK_BACKGROUND_COMPACT))
20064b0: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
20064b4: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
20064b8: 02 80 00 04 be 20064c8 <rtems_fdisk_ioctl+0x720> <== NOT EXECUTED
20064bc: 01 00 00 00 nop <== NOT EXECUTED
rtems_fdisk_compact (fd);
20064c0: 7f ff fd ac call 2005b70 <rtems_fdisk_compact> <== NOT EXECUTED
20064c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/*
* Try again for some free space.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
20064c8: 7f ff f9 8d call 2004afc <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
20064cc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (!sc)
20064d0: a6 92 20 00 orcc %o0, 0, %l3 <== NOT EXECUTED
20064d4: 32 80 00 08 bne,a 20064f4 <rtems_fdisk_ioctl+0x74c> <== NOT EXECUTED
20064d8: c2 07 60 6c ld [ %i5 + 0x6c ], %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("write-block: no available pages");
20064dc: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
return ENOSPC;
20064e0: b2 10 20 1c mov 0x1c, %i1 <== NOT EXECUTED
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
if (!sc)
{
rtems_fdisk_error ("write-block: no available pages");
20064e4: 7f ff fa 9a call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
20064e8: 90 12 23 48 or %o0, 0x348, %o0 <== NOT EXECUTED
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
20064ec: 10 80 00 a8 b 200678c <rtems_fdisk_ioctl+0x9e4> <== NOT EXECUTED
20064f0: aa 05 60 01 inc %l5 <== NOT EXECUTED
return ENOSPC;
}
}
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
20064f4: 80 a0 60 02 cmp %g1, 2
20064f8: 28 80 00 0f bleu,a 2006534 <rtems_fdisk_ioctl+0x78c> <== ALWAYS TAKEN
20064fc: c2 04 e0 10 ld [ %l3 + 0x10 ], %g1
{
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
2006500: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006504: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
2006508: 7f ff f9 e5 call 2004c9c <rtems_fdisk_queue_status> <== NOT EXECUTED
200650c: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",
2006510: d6 04 e0 08 ld [ %l3 + 8 ], %o3 <== NOT EXECUTED
2006514: d8 04 e0 0c ld [ %l3 + 0xc ], %o4 <== NOT EXECUTED
2006518: 13 00 80 c4 sethi %hi(0x2031000), %o1 <== NOT EXECUTED
200651c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006520: 92 12 63 68 or %o1, 0x368, %o1 <== NOT EXECUTED
2006524: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2006528: 7f ff fa 29 call 2004dcc <rtems_fdisk_info> <== NOT EXECUTED
200652c: 9a 07 bf f8 add %fp, -8, %o5 <== NOT EXECUTED
/*
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
2006530: c2 04 e0 10 ld [ %l3 + 0x10 ], %g1 <== NOT EXECUTED
for (page = 0; page < sc->pages; page++, pd++)
2006534: c4 04 e0 14 ld [ %l3 + 0x14 ], %g2
2006538: 10 80 00 79 b 200671c <rtems_fdisk_ioctl+0x974>
200653c: b8 10 20 00 clr %i4
{
if (rtems_fdisk_page_desc_erased (pd))
2006540: c2 27 bf dc st %g1, [ %fp + -36 ]
2006544: c4 27 bf d0 st %g2, [ %fp + -48 ]
2006548: 7f ff f9 fd call 2004d3c <rtems_fdisk_page_desc_erased>
200654c: 90 10 00 14 mov %l4, %o0
2006550: c2 07 bf dc ld [ %fp + -36 ], %g1
2006554: 80 8a 20 ff btst 0xff, %o0
2006558: 02 80 00 70 be 2006718 <rtems_fdisk_ioctl+0x970>
200655c: c4 07 bf d0 ld [ %fp + -48 ], %g2
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
2006560: 03 00 81 19 sethi %hi(0x2046400), %g1
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
2006564: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
2006568: de 00 60 88 ld [ %g1 + 0x88 ], %o7
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
200656c: 86 10 20 00 clr %g3
* Calculate the checksum of a page in a segment.
*/
static uint16_t
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
2006570: 10 80 00 07 b 200658c <rtems_fdisk_ioctl+0x7e4>
2006574: 82 10 3f ff mov -1, %g1
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
2006578: 82 08 60 ff and %g1, 0xff, %g1
200657c: 82 18 40 0d xor %g1, %o5, %g1
2006580: 83 28 60 01 sll %g1, 1, %g1
2006584: c2 13 c0 01 lduh [ %o7 + %g1 ], %g1
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
2006588: 86 00 e0 01 inc %g3
200658c: 80 a0 c0 04 cmp %g3, %g4
2006590: 32 bf ff fa bne,a 2006578 <rtems_fdisk_ioctl+0x7d0>
2006594: da 0c 40 03 ldub [ %l1 + %g3 ], %o5
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
2006598: c2 35 00 00 sth %g1, [ %l4 ]
pd->block = block;
200659c: f2 25 20 04 st %i1, [ %l4 + 4 ]
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
20065a0: c6 15 20 02 lduh [ %l4 + 2 ], %g3
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
pd->block = block;
bc->segment = sc;
20065a4: e6 25 c0 16 st %l3, [ %l7 + %l6 ]
bc->page = page;
20065a8: f8 26 20 04 st %i4, [ %i0 + 4 ]
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
20065ac: c8 04 c0 00 ld [ %l3 ], %g4
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
20065b0: 86 08 ff fe and %g3, -2, %g3
20065b4: c6 35 20 02 sth %g3, [ %l4 + 2 ]
bc->page = page;
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
20065b8: d6 04 e0 08 ld [ %l3 + 8 ], %o3
20065bc: d8 04 e0 0c ld [ %l3 + 0xc ], %o4
20065c0: d4 04 e0 1c ld [ %l3 + 0x1c ], %o2
20065c4: da 04 e0 20 ld [ %l3 + 0x20 ], %o5
20065c8: 80 a1 20 00 cmp %g4, 0
20065cc: 02 80 00 05 be 20065e0 <rtems_fdisk_ioctl+0x838> <== ALWAYS TAKEN
20065d0: de 04 e0 24 ld [ %l3 + 0x24 ], %o7
20065d4: 09 00 80 c3 sethi %hi(0x2030c00), %g4 <== NOT EXECUTED
20065d8: 10 80 00 04 b 20065e8 <rtems_fdisk_ioctl+0x840> <== NOT EXECUTED
20065dc: 88 11 20 18 or %g4, 0x18, %g4 ! 2030c18 <__FUNCTION__.7127+0x540><== NOT EXECUTED
20065e0: 09 00 80 c3 sethi %hi(0x2030c00), %g4
20065e4: 88 11 20 20 or %g4, 0x20, %g4 ! 2030c20 <__FUNCTION__.7127+0x548>
20065e8: 87 28 e0 10 sll %g3, 0x10, %g3
20065ec: 83 28 60 10 sll %g1, 0x10, %g1
20065f0: 87 30 e0 10 srl %g3, 0x10, %g3
20065f4: 83 30 60 10 srl %g1, 0x10, %g1
20065f8: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
20065fc: d4 23 a0 60 st %o2, [ %sp + 0x60 ]
2006600: da 23 a0 64 st %o5, [ %sp + 0x64 ]
2006604: 94 10 00 19 mov %i1, %o2
2006608: de 23 a0 68 st %o7, [ %sp + 0x68 ]
200660c: c8 23 a0 6c st %g4, [ %sp + 0x6c ]
2006610: c6 23 a0 70 st %g3, [ %sp + 0x70 ]
2006614: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
2006618: f2 23 a0 78 st %i1, [ %sp + 0x78 ]
200661c: 9a 10 00 1c mov %i4, %o5
2006620: 90 10 00 1d mov %i5, %o0
2006624: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006628: 7f ff f9 e9 call 2004dcc <rtems_fdisk_info>
200662c: 92 12 63 90 or %o1, 0x390, %o1 ! 2031390 <__FUNCTION__.7127+0xcb8>
/*
* 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);
2006630: d4 04 e0 18 ld [ %l3 + 0x18 ], %o2
2006634: 90 10 00 1d mov %i5, %o0
2006638: 92 10 00 13 mov %l3, %o1
200663c: 94 07 00 0a add %i4, %o2, %o2
2006640: 7f ff fc 50 call 2005780 <rtems_fdisk_seg_write_page>
2006644: 96 10 00 11 mov %l1, %o3
if (ret)
2006648: b2 92 20 00 orcc %o0, 0, %i1
200664c: 22 80 00 0d be,a 2006680 <rtems_fdisk_ioctl+0x8d8> <== ALWAYS TAKEN
2006650: 90 10 00 1d mov %i5, %o0
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
2006654: e8 04 e0 08 ld [ %l3 + 8 ], %l4 <== NOT EXECUTED
2006658: 40 00 72 b7 call 2023134 <strerror> <== NOT EXECUTED
200665c: f0 04 e0 0c ld [ %l3 + 0xc ], %i0 <== NOT EXECUTED
2006660: 13 00 80 c4 sethi %hi(0x2031000), %o1 <== NOT EXECUTED
2006664: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
2006668: f2 23 a0 5c st %i1, [ %sp + 0x5c ] <== NOT EXECUTED
200666c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006670: 92 12 63 e0 or %o1, 0x3e0, %o1 <== NOT EXECUTED
2006674: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
2006678: 10 80 00 14 b 20066c8 <rtems_fdisk_ioctl+0x920> <== NOT EXECUTED
200667c: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
2006680: 92 10 00 13 mov %l3, %o1
2006684: 94 10 00 1c mov %i4, %o2
2006688: 7f ff fb 54 call 20053d8 <rtems_fdisk_seg_write_page_desc>
200668c: 96 10 00 14 mov %l4, %o3
if (ret)
2006690: b2 92 20 00 orcc %o0, 0, %i1
2006694: 22 80 00 11 be,a 20066d8 <rtems_fdisk_ioctl+0x930> <== ALWAYS TAKEN
2006698: c2 04 e0 1c ld [ %l3 + 0x1c ], %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: " \
200669c: ec 04 e0 08 ld [ %l3 + 8 ], %l6 <== NOT EXECUTED
20066a0: e8 04 e0 0c ld [ %l3 + 0xc ], %l4 <== NOT EXECUTED
20066a4: 40 00 72 a4 call 2023134 <strerror> <== NOT EXECUTED
20066a8: f8 06 20 04 ld [ %i0 + 4 ], %i4 <== NOT EXECUTED
20066ac: 13 00 80 c5 sethi %hi(0x2031400), %o1 <== NOT EXECUTED
20066b0: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
20066b4: f2 23 a0 5c st %i1, [ %sp + 0x5c ] <== NOT EXECUTED
20066b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20066bc: 92 12 60 18 or %o1, 0x18, %o1 <== NOT EXECUTED
20066c0: 94 10 00 16 mov %l6, %o2 <== NOT EXECUTED
20066c4: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
20066c8: 7f ff f9 c1 call 2004dcc <rtems_fdisk_info> <== NOT EXECUTED
20066cc: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
20066d0: 10 80 00 05 b 20066e4 <rtems_fdisk_ioctl+0x93c> <== NOT EXECUTED
20066d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active++;
20066d8: 82 00 60 01 inc %g1
20066dc: c2 24 e0 1c st %g1, [ %l3 + 0x1c ]
}
}
rtems_fdisk_queue_segment (fd, sc);
20066e0: 90 10 00 1d mov %i5, %o0
20066e4: 7f ff fa 77 call 20050c0 <rtems_fdisk_queue_segment>
20066e8: 92 10 00 13 mov %l3, %o1
static bool
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
20066ec: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
20066f0: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
20066f4: 80 a0 80 01 cmp %g2, %g1
20066f8: 1a 80 00 19 bcc 200675c <rtems_fdisk_ioctl+0x9b4>
20066fc: 90 10 00 1d mov %i5, %o0
fd->starvations++;
2006700: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
2006704: 82 00 60 01 inc %g1
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
2006708: 7f ff fd 1a call 2005b70 <rtems_fdisk_compact>
200670c: 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)
2006710: 10 80 00 14 b 2006760 <rtems_fdisk_ioctl+0x9b8>
2006714: 80 a6 60 00 cmp %i1, 0
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
2006718: b8 07 20 01 inc %i4
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
200671c: a9 2f 20 03 sll %i4, 3, %l4
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
2006720: 80 a7 00 02 cmp %i4, %g2
2006724: 12 bf ff 87 bne 2006540 <rtems_fdisk_ioctl+0x798> <== ALWAYS TAKEN
2006728: a8 00 40 14 add %g1, %l4, %l4
return ret;
}
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
200672c: d2 04 e0 08 ld [ %l3 + 8 ], %o1 <== NOT EXECUTED
2006730: d4 04 e0 0c ld [ %l3 + 0xc ], %o2 <== NOT EXECUTED
2006734: 11 00 80 c5 sethi %hi(0x2031400), %o0 <== NOT EXECUTED
2006738: 7f ff fa 05 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
200673c: 90 12 20 58 or %o0, 0x58, %o0 ! 2031458 <__FUNCTION__.7127+0xd80><== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
2006740: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
2006744: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
sc->device, sc->segment);
sc->failed = true;
2006748: c2 24 e0 28 st %g1, [ %l3 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
200674c: 7f ff fa 5d call 20050c0 <rtems_fdisk_queue_segment> <== NOT EXECUTED
2006750: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
return EIO;
2006754: 10 80 00 0d b 2006788 <rtems_fdisk_ioctl+0x9e0> <== NOT EXECUTED
2006758: b2 10 20 05 mov 5, %i1 <== NOT EXECUTED
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
if (ret)
200675c: 80 a6 60 00 cmp %i1, 0
2006760: 32 80 00 0b bne,a 200678c <rtems_fdisk_ioctl+0x9e4> <== NEVER TAKEN
2006764: aa 05 60 01 inc %l5 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2006768: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200676c: a4 04 a0 01 inc %l2
2006770: a2 04 40 01 add %l1, %g1, %l1
2006774: c2 07 bf e4 ld [ %fp + -28 ], %g1
2006778: 80 a4 80 01 cmp %l2, %g1
200677c: 32 bf fe 93 bne,a 20061c8 <rtems_fdisk_ioctl+0x420>
2006780: f2 04 00 00 ld [ %l0 ], %i1
2006784: b2 10 20 00 clr %i1
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
2006788: aa 05 60 01 inc %l5
200678c: 80 a6 60 00 cmp %i1, 0
2006790: 12 80 00 08 bne 20067b0 <rtems_fdisk_ioctl+0xa08> <== NEVER TAKEN
2006794: a0 04 20 10 add %l0, 0x10, %l0
2006798: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
200679c: 80 a5 40 01 cmp %l5, %g1
20067a0: 2a bf fe 84 bcs,a 20061b0 <rtems_fdisk_ioctl+0x408>
20067a4: d0 04 20 04 ld [ %l0 + 4 ], %o0
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
20067a8: 10 80 00 03 b 20067b4 <rtems_fdisk_ioctl+0xa0c>
20067ac: 92 10 20 00 clr %o1
20067b0: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
20067b4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
20067b8: 9f c0 40 00 call %g1
20067bc: 90 10 00 1a mov %i2, %o0
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);
20067c0: 10 80 01 c0 b 2006ec0 <rtems_fdisk_ioctl+0x1118>
20067c4: c4 07 bf e8 ld [ %fp + -24 ], %g2
break;
default:
errno = EINVAL;
20067c8: 40 00 68 96 call 2020a20 <__errno> <== NOT EXECUTED
20067cc: 01 00 00 00 nop <== NOT EXECUTED
20067d0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
break;
20067d4: 10 80 01 c0 b 2006ed4 <rtems_fdisk_ioctl+0x112c> <== NOT EXECUTED
20067d8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
20067dc: 40 00 68 91 call 2020a20 <__errno> <== NOT EXECUTED
20067e0: 21 00 80 c5 sethi %hi(0x2031400), %l0 <== NOT EXECUTED
20067e4: fa 07 60 80 ld [ %i5 + 0x80 ], %i5 <== NOT EXECUTED
20067e8: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
20067ec: ba 07 40 1b add %i5, %i3, %i5 <== NOT EXECUTED
{
uint32_t device;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "erase-disk");
20067f0: 13 00 80 c5 sethi %hi(0x2031400), %o1 <== NOT EXECUTED
20067f4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20067f8: 92 12 60 90 or %o1, 0x90, %o1 <== NOT EXECUTED
20067fc: 7f ff f9 74 call 2004dcc <rtems_fdisk_info> <== NOT EXECUTED
2006800: 31 00 80 c5 sethi %hi(0x2031400), %i0 <== NOT EXECUTED
2006804: b4 10 20 00 clr %i2 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
2006808: b8 10 20 00 clr %i4 <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
200680c: a0 14 20 a0 or %l0, 0xa0, %l0 <== NOT EXECUTED
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device)
{
const rtems_fdisk_driver_handlers* ops;
ops = fd->devices[device].descriptor->flash_ops;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
2006810: 10 80 00 17 b 200686c <rtems_fdisk_ioctl+0xac4> <== NOT EXECUTED
2006814: b0 16 20 b8 or %i0, 0xb8, %i0 <== NOT EXECUTED
for (device = 0; device < fd->device_count; device++)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
2006818: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
200681c: 7f ff f9 6c call 2004dcc <rtems_fdisk_info> <== NOT EXECUTED
2006820: 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;
2006824: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
2006828: 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;
200682c: 82 00 40 1a add %g1, %i2, %g1 <== NOT EXECUTED
2006830: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
2006834: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
*/
static int
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device)
{
const rtems_fdisk_driver_handlers* ops;
ops = fd->devices[device].descriptor->flash_ops;
2006838: e2 00 60 08 ld [ %g1 + 8 ], %l1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
200683c: 7f ff f9 84 call 2004e4c <rtems_fdisk_printf> <== NOT EXECUTED
2006840: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
#endif
return ops->erase_device (fd->devices[device].descriptor, device);
2006844: c4 07 60 2c ld [ %i5 + 0x2c ], %g2 <== NOT EXECUTED
2006848: c2 04 60 14 ld [ %l1 + 0x14 ], %g1 <== NOT EXECUTED
200684c: 84 00 80 1a add %g2, %i2, %g2 <== NOT EXECUTED
2006850: d0 00 a0 08 ld [ %g2 + 8 ], %o0 <== NOT EXECUTED
2006854: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2006858: 9f c0 40 00 call %g1 <== NOT EXECUTED
200685c: b4 06 a0 0c add %i2, 0xc, %i2 <== NOT EXECUTED
rtems_fdisk_info (fd, " erase-flash:%02d", device);
#endif
ret = rtems_fdisk_device_erase (fd, device);
if (ret != 0)
2006860: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2006864: 12 80 00 18 bne 20068c4 <rtems_fdisk_ioctl+0xb1c> <== NOT EXECUTED
2006868: b8 07 20 01 inc %i4 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
200686c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
2006870: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2006874: 0a bf ff e9 bcs 2006818 <rtems_fdisk_ioctl+0xa70> <== NOT EXECUTED
2006878: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
200687c: b4 10 20 00 clr %i2 <== NOT EXECUTED
2006880: 10 80 00 0d b 20068b4 <rtems_fdisk_ioctl+0xb0c> <== NOT EXECUTED
2006884: b8 10 20 00 clr %i4 <== NOT EXECUTED
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
{
if (!fd->devices[device].segments)
2006888: c2 00 40 1a ld [ %g1 + %i2 ], %g1 <== NOT EXECUTED
200688c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006890: 02 80 00 0d be 20068c4 <rtems_fdisk_ioctl+0xb1c> <== NOT EXECUTED
2006894: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
return ENOMEM;
ret = rtems_fdisk_recover_block_mappings (fd);
2006898: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200689c: 7f ff fa e0 call 200541c <rtems_fdisk_recover_block_mappings><== NOT EXECUTED
20068a0: b4 06 a0 0c add %i2, 0xc, %i2 <== NOT EXECUTED
if (ret)
20068a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20068a8: 12 80 00 07 bne 20068c4 <rtems_fdisk_ioctl+0xb1c> <== NOT EXECUTED
20068ac: b8 07 20 01 inc %i4 <== NOT EXECUTED
ret = rtems_fdisk_erase_flash (fd);
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
20068b0: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
20068b4: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
20068b8: 2a bf ff f4 bcs,a 2006888 <rtems_fdisk_ioctl+0xae0> <== NOT EXECUTED
20068bc: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
20068c0: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
break;
20068c4: 10 80 01 84 b 2006ed4 <rtems_fdisk_ioctl+0x112c> <== NOT EXECUTED
20068c8: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
20068cc: 40 00 68 55 call 2020a20 <__errno> <== NOT EXECUTED
20068d0: 01 00 00 00 nop <== NOT EXECUTED
20068d4: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
20068d8: d0 07 60 80 ld [ %i5 + 0x80 ], %o0 <== NOT EXECUTED
20068dc: 7f ff fc a5 call 2005b70 <rtems_fdisk_compact> <== NOT EXECUTED
20068e0: 90 02 00 1b add %o0, %i3, %o0 <== NOT EXECUTED
break;
20068e4: 10 80 01 7c b 2006ed4 <rtems_fdisk_ioctl+0x112c> <== NOT EXECUTED
20068e8: d0 27 00 00 st %o0, [ %i4 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
20068ec: 40 00 68 4d call 2020a20 <__errno> <== NOT EXECUTED
20068f0: 01 00 00 00 nop <== NOT EXECUTED
20068f4: f8 07 60 80 ld [ %i5 + 0x80 ], %i4 <== NOT EXECUTED
20068f8: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
20068fc: b8 07 00 1b add %i4, %i3, %i4 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_used (rtems_flashdisk* fd)
{
rtems_fdisk_segment_ctl* sc;
int latched_ret = 0;
2006900: ba 10 20 00 clr %i5 <== NOT EXECUTED
while ((sc = rtems_fdisk_segment_queue_pop_head (&fd->erase)))
2006904: 10 80 00 09 b 2006928 <rtems_fdisk_ioctl+0xb80> <== NOT EXECUTED
2006908: b2 07 20 4c add %i4, 0x4c, %i1 <== NOT EXECUTED
{
/*
* The segment will either end up on the available queue or
* the failed queue.
*/
int ret = rtems_fdisk_erase_segment (fd, sc);
200690c: 7f ff f9 ad call 2004fc0 <rtems_fdisk_erase_segment> <== NOT EXECUTED
2006910: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (ret && !latched_ret)
2006914: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2006918: 02 80 00 04 be 2006928 <rtems_fdisk_ioctl+0xb80> <== NOT EXECUTED
200691c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2006920: 22 80 00 02 be,a 2006928 <rtems_fdisk_ioctl+0xb80> <== NOT EXECUTED
2006924: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
rtems_fdisk_erase_used (rtems_flashdisk* fd)
{
rtems_fdisk_segment_ctl* sc;
int latched_ret = 0;
while ((sc = rtems_fdisk_segment_queue_pop_head (&fd->erase)))
2006928: 7f ff f8 75 call 2004afc <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
200692c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2006930: 92 92 20 00 orcc %o0, 0, %o1 <== NOT EXECUTED
2006934: 12 bf ff f6 bne 200690c <rtems_fdisk_ioctl+0xb64> <== NOT EXECUTED
2006938: 01 00 00 00 nop <== NOT EXECUTED
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
break;
200693c: 10 80 01 66 b 2006ed4 <rtems_fdisk_ioctl+0x112c> <== NOT EXECUTED
2006940: fa 26 80 00 st %i5, [ %i2 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
2006944: 40 00 68 37 call 2020a20 <__errno> <== NOT EXECUTED
2006948: 01 00 00 00 nop <== NOT EXECUTED
200694c: fa 07 60 80 ld [ %i5 + 0x80 ], %i5 <== NOT EXECUTED
2006950: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
2006954: ba 07 40 1b add %i5, %i3, %i5 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
2006958: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
data->block_count = fd->block_count;
200695c: c4 07 60 1c ld [ %i5 + 0x1c ], %g2 <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
data->device_count = fd->device_count;
2006960: f2 07 60 30 ld [ %i5 + 0x30 ], %i1 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
2006964: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
2006968: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
data->block_count = fd->block_count;
200696c: c4 26 a0 04 st %g2, [ %i2 + 4 ] <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
2006970: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
data->device_count = fd->device_count;
2006974: f2 26 a0 0c st %i1, [ %i2 + 0xc ] <== NOT EXECUTED
data->blocks_used = 0;
2006978: c0 26 a0 18 clr [ %i2 + 0x18 ] <== NOT EXECUTED
for (i = 0; i < fd->block_count; i++)
200697c: 10 80 00 0a b 20069a4 <rtems_fdisk_ioctl+0xbfc> <== NOT EXECUTED
2006980: 82 10 20 00 clr %g1 <== NOT EXECUTED
if (fd->blocks[i].segment)
2006984: 87 28 60 03 sll %g1, 3, %g3 <== NOT EXECUTED
2006988: c6 01 00 03 ld [ %g4 + %g3 ], %g3 <== NOT EXECUTED
200698c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2006990: 02 80 00 05 be 20069a4 <rtems_fdisk_ioctl+0xbfc> <== NOT EXECUTED
2006994: 82 00 60 01 inc %g1 <== NOT EXECUTED
data->blocks_used++;
2006998: c6 06 a0 18 ld [ %i2 + 0x18 ], %g3 <== NOT EXECUTED
200699c: 86 00 e0 01 inc %g3 <== NOT EXECUTED
20069a0: c6 26 a0 18 st %g3, [ %i2 + 0x18 ] <== NOT EXECUTED
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
data->device_count = fd->device_count;
data->blocks_used = 0;
for (i = 0; i < fd->block_count; i++)
20069a4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20069a8: 32 bf ff f7 bne,a 2006984 <rtems_fdisk_ioctl+0xbdc> <== NOT EXECUTED
20069ac: c8 07 60 18 ld [ %i5 + 0x18 ], %g4 <== NOT EXECUTED
if (fd->blocks[i].segment)
data->blocks_used++;
data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
20069b0: 7f ff f8 a7 call 2004c4c <rtems_fdisk_segment_count_queue><== NOT EXECUTED
20069b4: 90 07 60 34 add %i5, 0x34, %o0 <== NOT EXECUTED
20069b8: d0 26 a0 1c st %o0, [ %i2 + 0x1c ] <== NOT EXECUTED
data->segs_used = rtems_fdisk_segment_count_queue (&fd->used);
20069bc: 7f ff f8 a4 call 2004c4c <rtems_fdisk_segment_count_queue><== NOT EXECUTED
20069c0: 90 07 60 40 add %i5, 0x40, %o0 <== NOT EXECUTED
20069c4: d0 26 a0 20 st %o0, [ %i2 + 0x20 ] <== NOT EXECUTED
data->segs_failed = rtems_fdisk_segment_count_queue (&fd->failed);
20069c8: 7f ff f8 a1 call 2004c4c <rtems_fdisk_segment_count_queue><== NOT EXECUTED
20069cc: 90 07 60 58 add %i5, 0x58, %o0 <== NOT EXECUTED
data->page_count = 0;
data->pages_desc = 0;
data->pages_active = 0;
data->pages_used = 0;
data->pages_bad = 0;
data->seg_erases = 0;
20069d0: 86 10 20 00 clr %g3 <== NOT EXECUTED
if (fd->blocks[i].segment)
data->blocks_used++;
data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
data->segs_used = rtems_fdisk_segment_count_queue (&fd->used);
data->segs_failed = rtems_fdisk_segment_count_queue (&fd->failed);
20069d4: d0 26 a0 24 st %o0, [ %i2 + 0x24 ] <== NOT EXECUTED
data->segment_count = 0;
20069d8: c0 26 a0 10 clr [ %i2 + 0x10 ] <== NOT EXECUTED
data->page_count = 0;
20069dc: c0 26 a0 14 clr [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc = 0;
20069e0: c0 26 a0 2c clr [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active = 0;
20069e4: c0 26 a0 30 clr [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used = 0;
20069e8: c0 26 a0 34 clr [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad = 0;
20069ec: c0 26 a0 38 clr [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases = 0;
20069f0: c0 26 a0 28 clr [ %i2 + 0x28 ] <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
20069f4: 10 80 00 2a b 2006a9c <rtems_fdisk_ioctl+0xcf4> <== NOT EXECUTED
20069f8: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
data->segment_count += fd->devices[i].segment_count;
20069fc: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
2006a00: 9e 03 c0 03 add %o7, %g3, %o7 <== NOT EXECUTED
2006a04: f0 03 e0 04 ld [ %o7 + 4 ], %i0 <== NOT EXECUTED
2006a08: b8 10 20 00 clr %i4 <== NOT EXECUTED
2006a0c: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
2006a10: 88 10 20 00 clr %g4 <== NOT EXECUTED
data->pages_bad = 0;
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
2006a14: 10 80 00 1d b 2006a88 <rtems_fdisk_ioctl+0xce0> <== NOT EXECUTED
2006a18: c2 26 a0 10 st %g1, [ %i2 + 0x10 ] <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
2006a1c: d8 06 a0 14 ld [ %i2 + 0x14 ], %o4 <== NOT EXECUTED
{
data->segment_count += fd->devices[i].segment_count;
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
2006a20: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
data->page_count += sc->pages;
2006a24: da 00 60 14 ld [ %g1 + 0x14 ], %o5 <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
for (j = 0; j < fd->devices[i].segment_count; j++)
2006a28: 88 01 20 01 inc %g4 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
2006a2c: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
2006a30: d8 06 a0 2c ld [ %i2 + 0x2c ], %o4 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
2006a34: da 26 a0 14 st %o5, [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
2006a38: da 00 60 18 ld [ %g1 + 0x18 ], %o5 <== NOT EXECUTED
2006a3c: b8 07 20 30 add %i4, 0x30, %i4 <== NOT EXECUTED
2006a40: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_active += sc->pages_active;
2006a44: d8 06 a0 30 ld [ %i2 + 0x30 ], %o4 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
2006a48: da 26 a0 2c st %o5, [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active += sc->pages_active;
2006a4c: da 00 60 1c ld [ %g1 + 0x1c ], %o5 <== NOT EXECUTED
2006a50: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_used += sc->pages_used;
2006a54: d8 06 a0 34 ld [ %i2 + 0x34 ], %o4 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
data->pages_active += sc->pages_active;
2006a58: da 26 a0 30 st %o5, [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used += sc->pages_used;
2006a5c: da 00 60 20 ld [ %g1 + 0x20 ], %o5 <== NOT EXECUTED
2006a60: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
2006a64: d8 06 a0 38 ld [ %i2 + 0x38 ], %o4 <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
data->pages_active += sc->pages_active;
data->pages_used += sc->pages_used;
2006a68: da 26 a0 34 st %o5, [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
2006a6c: da 00 60 24 ld [ %g1 + 0x24 ], %o5 <== NOT EXECUTED
data->seg_erases += sc->erased;
2006a70: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 <== NOT EXECUTED
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
data->pages_active += sc->pages_active;
data->pages_used += sc->pages_used;
data->pages_bad += sc->pages_bad;
2006a74: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
2006a78: da 26 a0 38 st %o5, [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases += sc->erased;
2006a7c: da 06 a0 28 ld [ %i2 + 0x28 ], %o5 <== NOT EXECUTED
2006a80: 82 03 40 01 add %o5, %g1, %g1 <== NOT EXECUTED
2006a84: c2 26 a0 28 st %g1, [ %i2 + 0x28 ] <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
for (j = 0; j < fd->devices[i].segment_count; j++)
2006a88: 80 a1 00 18 cmp %g4, %i0 <== NOT EXECUTED
2006a8c: 32 bf ff e4 bne,a 2006a1c <rtems_fdisk_ioctl+0xc74> <== NOT EXECUTED
2006a90: c2 03 c0 00 ld [ %o7 ], %g1 <== NOT EXECUTED
data->pages_active = 0;
data->pages_used = 0;
data->pages_bad = 0;
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
2006a94: 84 00 a0 01 inc %g2 <== NOT EXECUTED
2006a98: 86 00 e0 0c add %g3, 0xc, %g3 <== NOT EXECUTED
2006a9c: 80 a0 80 19 cmp %g2, %i1 <== NOT EXECUTED
2006aa0: 32 bf ff d7 bne,a 20069fc <rtems_fdisk_ioctl+0xc54> <== NOT EXECUTED
2006aa4: de 07 60 2c ld [ %i5 + 0x2c ], %o7 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
data->seg_erases += sc->erased;
}
}
data->info_level = fd->info_level;
2006aa8: c2 07 60 6c ld [ %i5 + 0x6c ], %g1 <== NOT EXECUTED
2006aac: c2 26 a0 3c st %g1, [ %i2 + 0x3c ] <== NOT EXECUTED
break;
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
(rtems_fdisk_monitor_data*) argp);
break;
2006ab0: 10 80 01 09 b 2006ed4 <rtems_fdisk_ioctl+0x112c> <== NOT EXECUTED
2006ab4: c0 24 00 00 clr [ %l0 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
2006ab8: 82 00 40 1b add %g1, %i3, %g1 <== NOT EXECUTED
break;
2006abc: 10 80 01 06 b 2006ed4 <rtems_fdisk_ioctl+0x112c> <== NOT EXECUTED
2006ac0: f4 20 60 6c st %i2, [ %g1 + 0x6c ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
2006ac4: 40 00 67 d7 call 2020a20 <__errno>
2006ac8: 01 00 00 00 nop
2006acc: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
2006ad0: d0 27 bf ec st %o0, [ %fp + -20 ]
2006ad4: ba 00 40 1b add %g1, %i3, %i5
*/
static int
rtems_fdisk_print_status (rtems_flashdisk* fd)
{
#if RTEMS_FDISK_TRACE
uint32_t current_info_level = fd->info_level;
2006ad8: c4 07 60 6c ld [ %i5 + 0x6c ], %g2
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
2006adc: d4 00 40 1b ld [ %g1 + %i3 ], %o2
2006ae0: d6 07 60 04 ld [ %i5 + 4 ], %o3
*/
static int
rtems_fdisk_print_status (rtems_flashdisk* fd)
{
#if RTEMS_FDISK_TRACE
uint32_t current_info_level = fd->info_level;
2006ae4: c4 27 bf e8 st %g2, [ %fp + -24 ]
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
2006ae8: 84 10 20 03 mov 3, %g2
rtems_fdisk_printf (fd,
2006aec: 90 10 00 1d mov %i5, %o0
uint32_t current_info_level = fd->info_level;
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
2006af0: c4 27 60 6c st %g2, [ %i5 + 0x6c ]
rtems_fdisk_printf (fd,
2006af4: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006af8: 7f ff f8 d5 call 2004e4c <rtems_fdisk_printf>
2006afc: 92 12 60 d0 or %o1, 0xd0, %o1 ! 20314d0 <__FUNCTION__.7127+0xdf8>
"Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
2006b00: d4 07 60 1c ld [ %i5 + 0x1c ], %o2
2006b04: 90 10 00 1d mov %i5, %o0
2006b08: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006b0c: 7f ff f8 d0 call 2004e4c <rtems_fdisk_printf>
2006b10: 92 12 60 f8 or %o1, 0xf8, %o1 ! 20314f8 <__FUNCTION__.7127+0xe20>
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
2006b14: d4 07 60 20 ld [ %i5 + 0x20 ], %o2
2006b18: 90 10 00 1d mov %i5, %o0
2006b1c: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006b20: 7f ff f8 cb call 2004e4c <rtems_fdisk_printf>
2006b24: 92 12 61 08 or %o1, 0x108, %o1 ! 2031508 <__FUNCTION__.7127+0xe30>
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
2006b28: d4 07 60 24 ld [ %i5 + 0x24 ], %o2
2006b2c: 90 10 00 1d mov %i5, %o0
2006b30: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006b34: 7f ff f8 c6 call 2004e4c <rtems_fdisk_printf>
2006b38: 92 12 61 20 or %o1, 0x120, %o1 ! 2031520 <__FUNCTION__.7127+0xe48>
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
2006b3c: d4 07 60 70 ld [ %i5 + 0x70 ], %o2
2006b40: 90 10 00 1d mov %i5, %o0
2006b44: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006b48: 7f ff f8 c1 call 2004e4c <rtems_fdisk_printf>
2006b4c: 92 12 61 38 or %o1, 0x138, %o1 ! 2031538 <__FUNCTION__.7127+0xe60>
count = rtems_fdisk_segment_count_queue (&fd->available);
2006b50: 7f ff f8 3f call 2004c4c <rtems_fdisk_segment_count_queue>
2006b54: 90 07 60 34 add %i5, 0x34, %o0
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
2006b58: d6 07 60 3c ld [ %i5 + 0x3c ], %o3
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
count = rtems_fdisk_segment_count_queue (&fd->available);
2006b5c: b8 10 00 08 mov %o0, %i4
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
2006b60: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006b64: 94 10 00 1c mov %i4, %o2
2006b68: 92 12 61 48 or %o1, 0x148, %o1
2006b6c: 7f ff f8 b8 call 2004e4c <rtems_fdisk_printf>
2006b70: 90 10 00 1d mov %i5, %o0
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
2006b74: 7f ff f8 36 call 2004c4c <rtems_fdisk_segment_count_queue>
2006b78: 90 07 60 40 add %i5, 0x40, %o0
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
2006b7c: d6 07 60 48 ld [ %i5 + 0x48 ], %o3
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
count = rtems_fdisk_segment_count_queue (&fd->available);
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
2006b80: 94 10 00 08 mov %o0, %o2
total += count;
2006b84: b8 02 00 1c add %o0, %i4, %i4
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
2006b88: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006b8c: 90 10 00 1d mov %i5, %o0
2006b90: 7f ff f8 af call 2004e4c <rtems_fdisk_printf>
2006b94: 92 12 61 68 or %o1, 0x168, %o1
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
2006b98: 7f ff f8 2d call 2004c4c <rtems_fdisk_segment_count_queue>
2006b9c: 90 07 60 4c add %i5, 0x4c, %o0
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
2006ba0: d6 07 60 54 ld [ %i5 + 0x54 ], %o3
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
2006ba4: 94 10 00 08 mov %o0, %o2
total += count;
2006ba8: b8 07 00 08 add %i4, %o0, %i4
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
2006bac: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006bb0: 90 10 00 1d mov %i5, %o0
2006bb4: 7f ff f8 a6 call 2004e4c <rtems_fdisk_printf>
2006bb8: 92 12 61 80 or %o1, 0x180, %o1
count, rtems_fdisk_segment_queue_count (&fd->erase));
count = rtems_fdisk_segment_count_queue (&fd->failed);
2006bbc: 7f ff f8 24 call 2004c4c <rtems_fdisk_segment_count_queue>
2006bc0: 90 07 60 58 add %i5, 0x58, %o0
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
2006bc4: d6 07 60 60 ld [ %i5 + 0x60 ], %o3
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->erase));
count = rtems_fdisk_segment_count_queue (&fd->failed);
2006bc8: 94 10 00 08 mov %o0, %o2
total += count;
2006bcc: b8 07 00 08 add %i4, %o0, %i4
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
2006bd0: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006bd4: 90 10 00 1d mov %i5, %o0
2006bd8: 7f ff f8 9d call 2004e4c <rtems_fdisk_printf>
2006bdc: 92 12 61 98 or %o1, 0x198, %o1
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
2006be0: c6 07 60 30 ld [ %i5 + 0x30 ], %g3
2006be4: 84 10 20 00 clr %g2
2006be8: 82 10 20 00 clr %g1
count = rtems_fdisk_segment_count_queue (&fd->failed);
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
2006bec: 10 80 00 07 b 2006c08 <rtems_fdisk_ioctl+0xe60>
2006bf0: 96 10 20 00 clr %o3
for (device = 0; device < fd->device_count; device++)
2006bf4: 82 00 60 01 inc %g1
count += fd->devices[device].segment_count;
2006bf8: 88 01 00 02 add %g4, %g2, %g4
2006bfc: c8 01 20 04 ld [ %g4 + 4 ], %g4
2006c00: 84 00 a0 0c add %g2, 0xc, %g2
2006c04: 96 02 c0 04 add %o3, %g4, %o3
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
2006c08: 80 a0 40 03 cmp %g1, %g3
2006c0c: 32 bf ff fa bne,a 2006bf4 <rtems_fdisk_ioctl+0xe4c>
2006c10: c8 07 60 2c ld [ %i5 + 0x2c ], %g4
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
2006c14: 19 00 80 c4 sethi %hi(0x2031000), %o4
2006c18: 80 a7 00 0b cmp %i4, %o3
2006c1c: 12 80 00 04 bne 2006c2c <rtems_fdisk_ioctl+0xe84> <== NEVER TAKEN
2006c20: 98 13 20 78 or %o4, 0x78, %o4
2006c24: 19 00 80 c4 sethi %hi(0x2031000), %o4
2006c28: 98 13 20 70 or %o4, 0x70, %o4 ! 2031070 <__FUNCTION__.7127+0x998>
2006c2c: 94 10 00 1c mov %i4, %o2
2006c30: 90 10 00 1d mov %i5, %o0
2006c34: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006c38: 7f ff f8 85 call 2004e4c <rtems_fdisk_printf>
2006c3c: 92 12 61 b0 or %o1, 0x1b0, %o1 ! 20315b0 <__FUNCTION__.7127+0xed8>
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
2006c40: d4 07 60 30 ld [ %i5 + 0x30 ], %o2
2006c44: 90 10 00 1d mov %i5, %o0
2006c48: 13 00 80 c5 sethi %hi(0x2031400), %o1
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
rtems_fdisk_printf (fd,
2006c4c: 2d 00 80 c5 sethi %hi(0x2031400), %l6
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
2006c50: 92 12 61 d0 or %o1, 0x1d0, %o1
2006c54: 7f ff f8 7e call 2004e4c <rtems_fdisk_printf>
2006c58: 2f 00 80 c5 sethi %hi(0x2031400), %l7
2006c5c: b4 10 20 00 clr %i2
for (device = 0; device < fd->device_count; device++)
2006c60: b2 10 20 00 clr %i1
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
rtems_fdisk_printf (fd,
2006c64: ac 15 a2 08 or %l6, 0x208, %l6
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
2006c68: 10 80 00 7b b 2006e54 <rtems_fdisk_ioctl+0x10ac>
2006c6c: ae 15 e2 38 or %l7, 0x238, %l7
for (device = 0; device < fd->device_count; device++)
{
uint32_t block;
uint32_t seg;
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
2006c70: 90 10 00 1d mov %i5, %o0
2006c74: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006c78: 7f ff f8 75 call 2004e4c <rtems_fdisk_printf>
2006c7c: 92 12 61 e0 or %o1, 0x1e0, %o1 ! 20315e0 <__FUNCTION__.7127+0xf08>
rtems_fdisk_printf (fd, " Segment count\t%ld",
2006c80: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
2006c84: 90 10 00 1d mov %i5, %o0
2006c88: 82 00 40 1a add %g1, %i2, %g1
2006c8c: d4 00 60 04 ld [ %g1 + 4 ], %o2
2006c90: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006c94: a0 10 20 00 clr %l0
2006c98: 92 12 61 f0 or %o1, 0x1f0, %o1
2006c9c: 7f ff f8 6c call 2004e4c <rtems_fdisk_printf>
2006ca0: b0 10 20 00 clr %i0
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
2006ca4: 10 80 00 65 b 2006e38 <rtems_fdisk_ioctl+0x1090>
2006ca8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
2006cac: 90 10 00 1d mov %i5, %o0
rtems_fdisk_printf (fd, " Segment count\t%ld",
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
2006cb0: b8 07 00 10 add %i4, %l0, %i4
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
2006cb4: 94 07 bf f8 add %fp, -8, %o2
2006cb8: 92 10 00 1c mov %i4, %o1
2006cbc: 7f ff f7 f8 call 2004c9c <rtems_fdisk_queue_status>
2006cc0: a2 10 20 00 clr %l1
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
uint32_t active = 0;
uint32_t used = 0;
2006cc4: a6 10 20 00 clr %l3
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
uint32_t active = 0;
2006cc8: a8 10 20 00 clr %l4
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
2006ccc: a4 10 20 00 clr %l2
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
2006cd0: 10 80 00 35 b 2006da4 <rtems_fdisk_ioctl+0xffc>
2006cd4: aa 10 20 00 clr %l5
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
2006cd8: 85 2d 60 03 sll %l5, 3, %g2
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
2006cdc: 84 03 c0 02 add %o7, %g2, %g2
2006ce0: 90 10 00 02 mov %g2, %o0
2006ce4: 7f ff f8 16 call 2004d3c <rtems_fdisk_page_desc_erased>
2006ce8: c4 27 bf d0 st %g2, [ %fp + -48 ]
2006cec: 80 8a 20 ff btst 0xff, %o0
2006cf0: 02 80 00 04 be 2006d00 <rtems_fdisk_ioctl+0xf58>
2006cf4: c4 07 bf d0 ld [ %fp + -48 ], %g2
erased++;
2006cf8: 10 80 00 0c b 2006d28 <rtems_fdisk_ioctl+0xf80>
2006cfc: a4 04 a0 01 inc %l2
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
2006d00: c4 10 a0 02 lduh [ %g2 + 2 ], %g2
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
erased++;
else if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
2006d04: 80 88 a0 01 btst 1, %g2
2006d08: 32 80 00 09 bne,a 2006d2c <rtems_fdisk_ioctl+0xf84> <== NEVER TAKEN
2006d0c: 84 10 20 00 clr %g2 <== NOT EXECUTED
RTEMS_FDISK_PAGE_ACTIVE))
{
if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
2006d10: 80 88 a0 02 btst 2, %g2
2006d14: 32 80 00 04 bne,a 2006d24 <rtems_fdisk_ioctl+0xf7c>
2006d18: a8 05 20 01 inc %l4
RTEMS_FDISK_PAGE_USED))
used++;
2006d1c: 10 80 00 03 b 2006d28 <rtems_fdisk_ioctl+0xf80>
2006d20: a6 04 e0 01 inc %l3
else
{
active++;
is_active = true;
2006d24: a2 10 20 01 mov 1, %l1
}
}
for (block = 0; block < fd->block_count; block++)
2006d28: 84 10 20 00 clr %g2
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
2006d2c: 10 80 00 19 b 2006d90 <rtems_fdisk_ioctl+0xfe8>
2006d30: 9a 0c 60 ff and %l1, 0xff, %o5
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
2006d34: 9f 28 a0 03 sll %g2, 3, %o7
}
}
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
2006d38: 96 03 00 0f add %o4, %o7, %o3
2006d3c: de 03 00 0f ld [ %o4 + %o7 ], %o7
2006d40: 80 a3 c0 1c cmp %o7, %i4
2006d44: 32 80 00 13 bne,a 2006d90 <rtems_fdisk_ioctl+0xfe8>
2006d48: 84 00 a0 01 inc %g2
2006d4c: de 02 e0 04 ld [ %o3 + 4 ], %o7
2006d50: 80 a3 c0 15 cmp %o7, %l5
2006d54: 32 80 00 0f bne,a 2006d90 <rtems_fdisk_ioctl+0xfe8>
2006d58: 84 00 a0 01 inc %g2
(fd->blocks[block].page == page) && !is_active)
2006d5c: 80 a3 60 00 cmp %o5, 0
2006d60: 32 80 00 0c bne,a 2006d90 <rtems_fdisk_ioctl+0xfe8> <== ALWAYS TAKEN
2006d64: 84 00 a0 01 inc %g2
rtems_fdisk_printf (fd,
2006d68: 96 10 00 02 mov %g2, %o3 <== NOT EXECUTED
2006d6c: c4 27 bf d0 st %g2, [ %fp + -48 ] <== NOT EXECUTED
2006d70: da 27 bf bc st %o5, [ %fp + -68 ] <== NOT EXECUTED
2006d74: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006d78: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
2006d7c: 7f ff f8 34 call 2004e4c <rtems_fdisk_printf> <== NOT EXECUTED
2006d80: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
2006d84: da 07 bf bc ld [ %fp + -68 ], %o5 <== NOT EXECUTED
2006d88: c4 07 bf d0 ld [ %fp + -48 ], %g2 <== NOT EXECUTED
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
2006d8c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
2006d90: de 07 60 1c ld [ %i5 + 0x1c ], %o7
2006d94: 80 a0 80 0f cmp %g2, %o7
2006d98: 2a bf ff e7 bcs,a 2006d34 <rtems_fdisk_ioctl+0xf8c>
2006d9c: d8 07 60 18 ld [ %i5 + 0x18 ], %o4
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
2006da0: aa 05 60 01 inc %l5
2006da4: d8 07 20 14 ld [ %i4 + 0x14 ], %o4
2006da8: 80 a5 40 0c cmp %l5, %o4
2006dac: 2a bf ff cb bcs,a 2006cd8 <rtems_fdisk_ioctl+0xf30>
2006db0: de 07 20 10 ld [ %i4 + 0x10 ], %o7
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
2006db4: de 07 60 1c ld [ %i5 + 0x1c ], %o7
2006db8: 82 10 20 00 clr %g1
2006dbc: 10 80 00 08 b 2006ddc <rtems_fdisk_ioctl+0x1034>
2006dc0: 84 10 20 00 clr %g2
{
if (fd->blocks[block].segment == sc)
2006dc4: 9b 28 60 03 sll %g1, 3, %o5
2006dc8: da 02 c0 0d ld [ %o3 + %o5 ], %o5
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
2006dcc: 82 00 60 01 inc %g1
{
if (fd->blocks[block].segment == sc)
count++;
2006dd0: 9a 1b 40 1c xor %o5, %i4, %o5
2006dd4: 80 a0 00 0d cmp %g0, %o5
2006dd8: 84 60 bf ff subx %g2, -1, %g2
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
2006ddc: 80 a0 40 0f cmp %g1, %o7
2006de0: 32 bf ff f9 bne,a 2006dc4 <rtems_fdisk_ioctl+0x101c>
2006de4: d6 07 60 18 ld [ %i5 + 0x18 ], %o3
" u:%3ld/%3ld e:%3ld/%3ld br:%ld",
seg, queues,
sc->pages, sc->pages_active, active,
sc->pages_used, used, erased,
sc->pages - (sc->pages_active +
sc->pages_used + sc->pages_bad),
2006de8: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
" u:%3ld/%3ld e:%3ld/%3ld br:%ld",
seg, queues,
sc->pages, sc->pages_active, active,
sc->pages_used, used, erased,
sc->pages - (sc->pages_active +
2006dec: da 07 20 1c ld [ %i4 + 0x1c ], %o5
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
2006df0: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
2006df4: e8 23 a0 5c st %l4, [ %sp + 0x5c ]
2006df8: e6 23 a0 64 st %l3, [ %sp + 0x64 ]
2006dfc: e4 23 a0 68 st %l2, [ %sp + 0x68 ]
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
2006e00: c6 07 20 24 ld [ %i4 + 0x24 ], %g3
2006e04: 82 03 40 01 add %o5, %g1, %g1
2006e08: 82 00 40 03 add %g1, %g3, %g1
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
2006e0c: 82 23 00 01 sub %o4, %g1, %g1
2006e10: 94 10 00 18 mov %i0, %o2
2006e14: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
2006e18: c4 23 a0 70 st %g2, [ %sp + 0x70 ]
2006e1c: 90 10 00 1d mov %i5, %o0
2006e20: 92 10 00 17 mov %l7, %o1
2006e24: 96 07 bf f8 add %fp, -8, %o3
2006e28: 7f ff f8 09 call 2004e4c <rtems_fdisk_printf>
2006e2c: b0 06 20 01 inc %i0
2006e30: a0 04 20 30 add %l0, 0x30, %l0
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
rtems_fdisk_printf (fd, " Segment count\t%ld",
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
2006e34: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
2006e38: 84 00 40 1a add %g1, %i2, %g2
2006e3c: c4 00 a0 04 ld [ %g2 + 4 ], %g2
2006e40: 80 a6 00 02 cmp %i0, %g2
2006e44: 2a bf ff 9a bcs,a 2006cac <rtems_fdisk_ioctl+0xf04>
2006e48: f8 00 40 1a ld [ %g1 + %i2 ], %i4
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
for (device = 0; device < fd->device_count; device++)
2006e4c: b2 06 60 01 inc %i1
2006e50: b4 06 a0 0c add %i2, 0xc, %i2
2006e54: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
2006e58: 80 a6 40 01 cmp %i1, %g1
2006e5c: 0a bf ff 85 bcs 2006c70 <rtems_fdisk_ioctl+0xec8>
2006e60: 94 10 00 19 mov %i1, %o2
count);
}
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
2006e64: f8 07 60 40 ld [ %i5 + 0x40 ], %i4
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
2006e68: 90 10 00 1d mov %i5, %o0
2006e6c: 13 00 80 c5 sethi %hi(0x2031400), %o1
while (sc)
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
2006e70: 33 00 80 c5 sethi %hi(0x2031400), %i1
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
2006e74: 92 12 62 78 or %o1, 0x278, %o1
2006e78: 7f ff f7 f5 call 2004e4c <rtems_fdisk_printf>
2006e7c: b4 10 20 00 clr %i2
while (sc)
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
2006e80: 10 80 00 0a b 2006ea8 <rtems_fdisk_ioctl+0x1100>
2006e84: b2 16 62 88 or %i1, 0x288, %i1
2006e88: d8 07 20 0c ld [ %i4 + 0xc ], %o4
2006e8c: da 07 20 20 ld [ %i4 + 0x20 ], %o5
2006e90: 94 10 00 1a mov %i2, %o2
2006e94: 90 10 00 1d mov %i5, %o0
2006e98: 7f ff f7 ed call 2004e4c <rtems_fdisk_printf>
2006e9c: 92 10 00 19 mov %i1, %o1
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
2006ea0: f8 07 00 00 ld [ %i4 ], %i4
count++;
2006ea4: b4 06 a0 01 inc %i2
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
while (sc)
2006ea8: 80 a7 20 00 cmp %i4, 0
2006eac: 32 bf ff f7 bne,a 2006e88 <rtems_fdisk_ioctl+0x10e0>
2006eb0: d6 07 20 08 ld [ %i4 + 8 ], %o3
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
2006eb4: c2 07 bf e8 ld [ %fp + -24 ], %g1
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
break;
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
2006eb8: c4 07 bf ec ld [ %fp + -20 ], %g2
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
2006ebc: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
break;
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
break;
2006ec0: 10 80 00 05 b 2006ed4 <rtems_fdisk_ioctl+0x112c>
2006ec4: c0 20 80 00 clr [ %g2 ]
default:
rtems_blkdev_ioctl (dd, req, argp);
2006ec8: 92 10 00 19 mov %i1, %o1
2006ecc: 40 00 3c 48 call 2015fec <rtems_blkdev_ioctl>
2006ed0: 94 10 00 1a mov %i2, %o2
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
2006ed4: 03 00 81 19 sethi %hi(0x2046400), %g1
2006ed8: c2 00 60 80 ld [ %g1 + 0x80 ], %g1 ! 2046480 <rtems_flashdisks>
2006edc: b6 00 40 1b add %g1, %i3, %i3
2006ee0: 40 00 17 1c call 200cb50 <rtems_semaphore_release>
2006ee4: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2006ee8: 80 a2 20 00 cmp %o0, 0
2006eec: 02 80 00 06 be 2006f04 <rtems_fdisk_ioctl+0x115c> <== ALWAYS TAKEN
2006ef0: 01 00 00 00 nop
errno = EIO;
2006ef4: 40 00 66 cb call 2020a20 <__errno> <== NOT EXECUTED
2006ef8: 01 00 00 00 nop <== NOT EXECUTED
2006efc: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2006f00: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
2006f04: 40 00 66 c7 call 2020a20 <__errno>
2006f08: 01 00 00 00 nop
2006f0c: c2 02 00 00 ld [ %o0 ], %g1
2006f10: 80 a0 00 01 cmp %g0, %g1
2006f14: b0 60 20 00 subx %g0, 0, %i0
2006f18: 81 c7 e0 08 ret
2006f1c: 81 e8 00 00 restore
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2006f20: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2006f24: a2 04 60 01 inc %l1
2006f28: 10 bf fc 84 b 2006138 <rtems_fdisk_ioctl+0x390>
2006f2c: a0 04 00 01 add %l0, %g1, %l0
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
2006f30: 10 bf fc 88 b 2006150 <rtems_fdisk_ioctl+0x3a8> <== NOT EXECUTED
2006f34: a4 04 a0 01 inc %l2 <== NOT EXECUTED
020050c0 <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)
{
20050c0: 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",
20050c4: 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)
{
20050c8: ba 10 00 18 mov %i0, %i5
20050cc: 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",
20050d0: d4 06 60 08 ld [ %i1 + 8 ], %o2
20050d4: d6 06 60 0c ld [ %i1 + 0xc ], %o3
20050d8: d8 06 60 14 ld [ %i1 + 0x14 ], %o4
20050dc: da 06 60 1c ld [ %i1 + 0x1c ], %o5
20050e0: c8 06 60 20 ld [ %i1 + 0x20 ], %g4
20050e4: 80 a0 60 00 cmp %g1, 0
20050e8: 02 80 00 05 be 20050fc <rtems_fdisk_queue_segment+0x3c> <== ALWAYS TAKEN
20050ec: c6 06 60 24 ld [ %i1 + 0x24 ], %g3
20050f0: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED
20050f4: 10 80 00 04 b 2005104 <rtems_fdisk_queue_segment+0x44> <== NOT EXECUTED
20050f8: 84 10 a0 08 or %g2, 8, %g2 ! 2030c08 <__FUNCTION__.7127+0x530><== NOT EXECUTED
20050fc: 05 00 80 c3 sethi %hi(0x2030c00), %g2
2005100: 84 10 a0 10 or %g2, 0x10, %g2 ! 2030c10 <__FUNCTION__.7127+0x538>
2005104: c2 06 80 00 ld [ %i2 ], %g1
2005108: 80 a0 60 00 cmp %g1, 0
200510c: 02 80 00 04 be 200511c <rtems_fdisk_queue_segment+0x5c>
2005110: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2005114: 10 80 00 04 b 2005124 <rtems_fdisk_queue_segment+0x64>
2005118: 82 10 60 18 or %g1, 0x18, %g1 ! 2030c18 <__FUNCTION__.7127+0x540>
200511c: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2005120: 82 10 60 20 or %g1, 0x20, %g1 ! 2030c20 <__FUNCTION__.7127+0x548>
2005124: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
2005128: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
200512c: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
2005130: c4 23 a0 64 st %g2, [ %sp + 0x64 ]
2005134: 90 10 00 1d mov %i5, %o0
2005138: 13 00 80 c3 sethi %hi(0x2030c00), %o1
200513c: 7f ff ff 24 call 2004dcc <rtems_fdisk_info>
2005140: 92 12 60 28 or %o1, 0x28, %o1 ! 2030c28 <__FUNCTION__.7127+0x550>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
2005144: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
2005148: 80 a0 60 00 cmp %g1, 0
200514c: 02 80 00 09 be 2005170 <rtems_fdisk_queue_segment+0xb0> <== ALWAYS TAKEN
2005150: 92 10 00 1a mov %i2, %o1
{
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
2005154: b0 07 60 58 add %i5, 0x58, %i0 <== NOT EXECUTED
2005158: 7f ff fe c6 call 2004c70 <rtems_fdisk_segment_queue_present><== NOT EXECUTED
200515c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2005160: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2005164: 12 80 00 32 bne 200522c <rtems_fdisk_queue_segment+0x16c> <== NOT EXECUTED
2005168: 01 00 00 00 nop <== NOT EXECUTED
200516c: 30 80 00 2e b,a 2005224 <rtems_fdisk_queue_segment+0x164><== NOT EXECUTED
}
/*
* Remove the queue from the available or used queue.
*/
rtems_fdisk_segment_queue_remove (&fd->available, sc);
2005170: b8 07 60 34 add %i5, 0x34, %i4
2005174: 7f ff fe 84 call 2004b84 <rtems_fdisk_segment_queue_remove>
2005178: 90 10 00 1c mov %i4, %o0
rtems_fdisk_segment_queue_remove (&fd->used, sc);
200517c: 92 10 00 1a mov %i2, %o1
2005180: b0 07 60 40 add %i5, 0x40, %i0
2005184: 7f ff fe 80 call 2004b84 <rtems_fdisk_segment_queue_remove>
2005188: 90 10 00 18 mov %i0, %o0
* If they are and the driver has been configured to background
* erase place the segment on the used queue. If not configured
* to background erase perform the erase now.
*
*/
if (rtems_fdisk_seg_pages_available (sc) == 0)
200518c: 7f ff fe f6 call 2004d64 <rtems_fdisk_seg_pages_available>
2005190: 90 10 00 1a mov %i2, %o0
2005194: b6 92 20 00 orcc %o0, 0, %i3
2005198: 32 80 00 1d bne,a 200520c <rtems_fdisk_queue_segment+0x14c>
200519c: f2 07 60 34 ld [ %i5 + 0x34 ], %i1
{
if (sc->pages_active)
20051a0: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
20051a4: 80 a0 60 00 cmp %g1, 0
20051a8: 22 80 00 0d be,a 20051dc <rtems_fdisk_queue_segment+0x11c><== NEVER TAKEN
20051ac: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
* pages. When we compact we want to move the pages into
* a new segment and cover more than one segment.
*/
rtems_fdisk_segment_ctl* seg = fd->used.head;
while (seg)
20051b0: 10 80 00 07 b 20051cc <rtems_fdisk_queue_segment+0x10c>
20051b4: f2 07 60 40 ld [ %i5 + 0x40 ], %i1
{
if (sc->pages_used > seg->pages_used)
20051b8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20051bc: 80 a0 80 01 cmp %g2, %g1
20051c0: 18 80 00 17 bgu 200521c <rtems_fdisk_queue_segment+0x15c>
20051c4: 01 00 00 00 nop
break;
seg = seg->next;
20051c8: 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)
20051cc: 80 a6 60 00 cmp %i1, 0
20051d0: 32 bf ff fa bne,a 20051b8 <rtems_fdisk_queue_segment+0xf8>
20051d4: c4 06 a0 20 ld [ %i2 + 0x20 ], %g2
20051d8: 30 80 00 13 b,a 2005224 <rtems_fdisk_queue_segment+0x164>
else
rtems_fdisk_segment_queue_push_tail (&fd->used, sc);
}
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
20051dc: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
20051e0: 12 80 00 11 bne 2005224 <rtems_fdisk_queue_segment+0x164> <== NOT EXECUTED
20051e4: b0 07 60 4c add %i5, 0x4c, %i0 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->erase, sc);
else
rtems_fdisk_erase_segment (fd, sc);
20051e8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
20051ec: 7f ff ff 75 call 2004fc0 <rtems_fdisk_erase_segment> <== NOT EXECUTED
20051f0: 93 e8 00 1a restore %g0, %i2, %o1 <== NOT EXECUTED
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
rtems_fdisk_seg_pages_available (seg))
20051f4: 7f ff fe dc call 2004d64 <rtems_fdisk_seg_pages_available>
20051f8: 90 10 00 19 mov %i1, %o0
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
20051fc: 80 a6 c0 08 cmp %i3, %o0
2005200: 0a 80 00 07 bcs 200521c <rtems_fdisk_queue_segment+0x15c>
2005204: b0 10 00 1c mov %i4, %i0
rtems_fdisk_seg_pages_available (seg))
break;
seg = seg->next;
2005208: 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)
200520c: 80 a6 60 00 cmp %i1, 0
2005210: 12 bf ff f9 bne 20051f4 <rtems_fdisk_queue_segment+0x134>
2005214: b0 10 00 1c mov %i4, %i0
2005218: 30 80 00 03 b,a 2005224 <rtems_fdisk_queue_segment+0x164>
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
200521c: 7f ff fe 77 call 2004bf8 <rtems_fdisk_segment_queue_insert_before>
2005220: 81 e8 00 00 restore
else
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
2005224: 7f ff fe 46 call 2004b3c <rtems_fdisk_segment_queue_push_tail>
2005228: 93 e8 00 1a restore %g0, %i2, %o1
200522c: 81 c7 e0 08 ret <== NOT EXECUTED
2005230: 81 e8 00 00 restore <== NOT EXECUTED
0200541c <rtems_fdisk_recover_block_mappings>:
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
200541c: 9d e3 bf 98 save %sp, -104, %sp
rtems_fdisk_segment_queue_init (&fd->failed);
/*
* Clear the lock mappings.
*/
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
2005420: d4 06 20 1c ld [ %i0 + 0x1c ], %o2
2005424: 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;
2005428: c0 26 20 38 clr [ %i0 + 0x38 ]
200542c: c0 26 20 34 clr [ %i0 + 0x34 ]
queue->count = 0;
2005430: 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;
2005434: c0 26 20 44 clr [ %i0 + 0x44 ]
2005438: c0 26 20 40 clr [ %i0 + 0x40 ]
queue->count = 0;
200543c: 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;
2005440: c0 26 20 50 clr [ %i0 + 0x50 ]
2005444: c0 26 20 4c clr [ %i0 + 0x4c ]
queue->count = 0;
2005448: 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;
200544c: c0 26 20 5c clr [ %i0 + 0x5c ]
2005450: c0 26 20 58 clr [ %i0 + 0x58 ]
queue->count = 0;
2005454: 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));
2005458: 92 10 20 00 clr %o1
200545c: 95 2a a0 03 sll %o2, 3, %o2
2005460: 40 00 72 4b call 2021d8c <memset>
2005464: 27 00 80 c3 sethi %hi(0x2030c00), %l3
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
2005468: 29 00 80 c3 sethi %hi(0x2030c00), %l4
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
{
if (pd->block >= fd->block_count)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
200546c: 2b 00 80 c3 sethi %hi(0x2030c00), %l5
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
2005470: 2d 00 80 c3 sethi %hi(0x2030c00), %l6
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
page, pd);
if (ret)
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
2005474: 2f 00 80 c3 sethi %hi(0x2030c00), %l7
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
2005478: ba 10 00 18 mov %i0, %i5
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
200547c: c0 26 20 28 clr [ %i0 + 0x28 ]
fd->starvation_threshold = 0;
2005480: c0 26 20 24 clr [ %i0 + 0x24 ]
for (device = 0; device < fd->device_count; device++)
2005484: a2 10 20 00 clr %l1
2005488: 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);
200548c: a6 14 e0 d8 or %l3, 0xd8, %l3
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
2005490: a8 15 21 c0 or %l4, 0x1c0, %l4
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
{
if (pd->block >= fd->block_count)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
2005494: aa 15 61 90 or %l5, 0x190, %l5
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
2005498: ac 15 a1 48 or %l6, 0x148, %l6
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
200549c: 10 80 00 b3 b 2005768 <rtems_fdisk_recover_block_mappings+0x34c>
20054a0: ae 15 e1 68 or %l7, 0x168, %l7
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
20054a4: 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];
20054a8: b8 07 00 12 add %i4, %l2, %i4
const rtems_fdisk_segment_desc* sd = sc->descriptor;
20054ac: f6 07 20 04 ld [ %i4 + 4 ], %i3
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
20054b0: 96 10 00 10 mov %l0, %o3
20054b4: 92 10 00 13 mov %l3, %o1
20054b8: 7f ff fe 45 call 2004dcc <rtems_fdisk_info>
20054bc: 90 10 00 1d mov %i5, %o0
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
20054c0: d0 06 e0 08 ld [ %i3 + 8 ], %o0
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
20054c4: f4 07 60 14 ld [ %i5 + 0x14 ], %i2
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
20054c8: 7f ff f4 6d call 200267c <.udiv>
20054cc: 92 10 00 1a mov %i2, %o1
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
return ((bytes - 1) / page_size) + 1;
20054d0: 92 10 00 1a mov %i2, %o1
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
20054d4: b6 10 00 08 mov %o0, %i3
static uint32_t
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
20054d8: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
20054dc: 7f ff f4 68 call 200267c <.udiv>
20054e0: 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)
20054e4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
return ((bytes - 1) / page_size) + 1;
20054e8: b0 02 20 01 add %o0, 1, %i0
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
20054ec: 90 26 c0 18 sub %i3, %i0, %o0
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
20054f0: f0 27 20 18 st %i0, [ %i4 + 0x18 ]
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
20054f4: 80 a2 00 01 cmp %o0, %g1
20054f8: 08 80 00 03 bleu 2005504 <rtems_fdisk_recover_block_mappings+0xe8>
20054fc: d0 27 20 14 st %o0, [ %i4 + 0x14 ]
fd->starvation_threshold = sc->pages;
2005500: d0 27 60 24 st %o0, [ %i5 + 0x24 ]
sc->pages_used = 0;
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
2005504: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
fd->starvation_threshold = sc->pages;
sc->pages_active = 0;
2005508: c0 27 20 1c clr [ %i4 + 0x1c ]
sc->pages_used = 0;
200550c: c0 27 20 20 clr [ %i4 + 0x20 ]
sc->pages_bad = 0;
2005510: c0 27 20 24 clr [ %i4 + 0x24 ]
sc->failed = false;
if (!sc->page_descriptors)
2005514: 80 a0 60 00 cmp %g1, 0
2005518: 12 80 00 08 bne 2005538 <rtems_fdisk_recover_block_mappings+0x11c><== NEVER TAKEN
200551c: c0 27 20 28 clr [ %i4 + 0x28 ]
sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
2005520: 92 10 00 1a mov %i2, %o1
2005524: 7f ff f4 1c call 2002594 <.umul>
2005528: 90 10 00 18 mov %i0, %o0
200552c: 40 00 0c 3f call 2008628 <malloc>
2005530: 01 00 00 00 nop
2005534: d0 27 20 10 st %o0, [ %i4 + 0x10 ]
if (!sc->page_descriptors)
2005538: f6 07 20 10 ld [ %i4 + 0x10 ], %i3
200553c: 80 a6 e0 00 cmp %i3, 0
2005540: 32 80 00 05 bne,a 2005554 <rtems_fdisk_recover_block_mappings+0x138><== ALWAYS TAKEN
2005544: 90 10 00 18 mov %i0, %o0
rtems_fdisk_abort ("no memory for page descriptors");
2005548: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
200554c: 40 00 07 ba call 2007434 <rtems_fdisk_abort.constprop.0> <== NOT EXECUTED
2005550: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 2030bb0 <__FUNCTION__.7127+0x4d8><== 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,
2005554: 7f ff f4 10 call 2002594 <.umul>
2005558: 92 10 00 1a mov %i2, %o1
200555c: 92 10 00 1c mov %i4, %o1
2005560: 98 10 00 08 mov %o0, %o4
2005564: 94 10 20 00 clr %o2
2005568: 90 10 00 1d mov %i5, %o0
200556c: 7f ff ff 32 call 2005234 <rtems_fdisk_seg_read>
2005570: 96 10 00 1b mov %i3, %o3
sc->pages_desc * fd->block_size);
if (ret)
2005574: b0 92 20 00 orcc %o0, 0, %i0
2005578: 22 80 00 6a be,a 2005720 <rtems_fdisk_recover_block_mappings+0x304><== ALWAYS TAKEN
200557c: b4 10 20 00 clr %i2
{
rtems_fdisk_error ("recover-block-mappings:%02d-%03d: " \
2005580: 40 00 76 ed call 2023134 <strerror> <== NOT EXECUTED
2005584: 01 00 00 00 nop <== NOT EXECUTED
2005588: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200558c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2005590: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2005594: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2005598: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
200559c: 7f ff fe 6c call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
20055a0: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
"read page desc failed: %s (%d)",
device, segment, strerror (ret), ret);
return ret;
20055a4: 81 c7 e0 08 ret <== NOT EXECUTED
20055a8: 81 e8 00 00 restore <== NOT EXECUTED
* If the page is active see if the block is with-in range and
* if the block is a duplicate.
*/
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
20055ac: 7f ff fd e4 call 2004d3c <rtems_fdisk_page_desc_erased>
20055b0: 90 10 00 1b mov %i3, %o0
20055b4: 80 8a 20 ff btst 0xff, %o0
20055b8: 22 80 00 2b be,a 2005664 <rtems_fdisk_recover_block_mappings+0x248><== NEVER TAKEN
20055bc: c2 16 e0 02 lduh [ %i3 + 2 ], %g1 <== NOT EXECUTED
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
page * fd->block_size, fd->block_size);
20055c0: f0 07 60 14 ld [ %i5 + 0x14 ], %i0
if (rtems_fdisk_page_desc_erased (pd))
{
/*
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
20055c4: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
static int
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
20055c8: 92 10 00 18 mov %i0, %o1
20055cc: 7f ff f3 f2 call 2002594 <.umul>
20055d0: 90 06 80 08 add %i2, %o0, %o0
20055d4: 92 10 00 1c mov %i4, %o1
20055d8: 94 10 00 08 mov %o0, %o2
20055dc: 96 10 00 18 mov %i0, %o3
20055e0: 7f ff ff 37 call 20052bc <rtems_fdisk_seg_blank_check>
20055e4: 90 10 00 1d mov %i5, %o0
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
page + sc->pages_desc);
if (ret == 0)
20055e8: 80 a2 20 00 cmp %o0, 0
20055ec: 32 80 00 06 bne,a 2005604 <rtems_fdisk_recover_block_mappings+0x1e8><== NEVER TAKEN
20055f0: da 06 e0 04 ld [ %i3 + 4 ], %o5 <== NOT EXECUTED
{
++fd->erased_blocks;
20055f4: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
20055f8: 82 00 60 01 inc %g1
20055fc: 10 80 00 47 b 2005718 <rtems_fdisk_recover_block_mappings+0x2fc>
2005600: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
2005604: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
2005608: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
200560c: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
2005610: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
2005614: 7f ff fe 2e call 2004ecc <rtems_fdisk_warning> <== NOT EXECUTED
2005618: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
200561c: c2 16 e0 02 lduh [ %i3 + 2 ], %g1 <== NOT EXECUTED
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
device, segment, page, pd->block);
#endif
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
2005620: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
2005624: 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,
2005628: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
200562c: c2 36 e0 02 sth %g1, [ %i3 + 2 ] <== NOT EXECUTED
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
device, segment, page, pd->block);
#endif
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
2005630: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2005634: 7f ff ff 69 call 20053d8 <rtems_fdisk_seg_write_page_desc><== NOT EXECUTED
2005638: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
page, pd);
if (ret)
200563c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2005640: 22 80 00 0d be,a 2005674 <rtems_fdisk_recover_block_mappings+0x258><== NOT EXECUTED
2005644: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
2005648: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
200564c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2005650: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2005654: 7f ff fe 3e call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
2005658: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
{
sc->pages_used++;
200565c: 10 80 00 06 b 2005674 <rtems_fdisk_recover_block_mappings+0x258><== NOT EXECUTED
2005660: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
sc->pages_used++;
}
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
2005664: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
2005668: 12 80 00 06 bne 2005680 <rtems_fdisk_recover_block_mappings+0x264><== NOT EXECUTED
200566c: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
{
sc->pages_used++;
2005670: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
2005674: 82 00 60 01 inc %g1 <== NOT EXECUTED
2005678: 10 80 00 28 b 2005718 <rtems_fdisk_recover_block_mappings+0x2fc><== NOT EXECUTED
200567c: c2 27 20 20 st %g1, [ %i4 + 0x20 ] <== NOT EXECUTED
}
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
2005680: 32 80 00 24 bne,a 2005710 <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
2005684: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
{
if (pd->block >= fd->block_count)
2005688: da 06 e0 04 ld [ %i3 + 4 ], %o5 <== NOT EXECUTED
200568c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
2005690: 80 a3 40 01 cmp %o5, %g1 <== NOT EXECUTED
2005694: 2a 80 00 0a bcs,a 20056bc <rtems_fdisk_recover_block_mappings+0x2a0><== NOT EXECUTED
2005698: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
200569c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20056a0: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
20056a4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
20056a8: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
20056ac: 7f ff fe 08 call 2004ecc <rtems_fdisk_warning> <== NOT EXECUTED
20056b0: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
20056b4: 10 80 00 17 b 2005710 <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
20056b8: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
"invalid block number: %d-%d-%d: block: %d",
device, segment, page, pd->block);
#endif
sc->pages_bad++;
}
else if (fd->blocks[pd->block].segment)
20056bc: 9b 2b 60 03 sll %o5, 3, %o5 <== NOT EXECUTED
20056c0: c4 00 40 0d ld [ %g1 + %o5 ], %g2 <== NOT EXECUTED
20056c4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
20056c8: 02 80 00 0c be 20056f8 <rtems_fdisk_recover_block_mappings+0x2dc><== NOT EXECUTED
20056cc: 86 00 40 0d add %g1, %o5, %g3 <== NOT EXECUTED
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
20056d0: d2 00 a0 08 ld [ %g2 + 8 ], %o1 <== NOT EXECUTED
20056d4: d4 00 a0 0c ld [ %g2 + 0xc ], %o2 <== NOT EXECUTED
20056d8: d6 00 e0 04 ld [ %g3 + 4 ], %o3 <== NOT EXECUTED
20056dc: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
20056e0: f4 23 a0 5c st %i2, [ %sp + 0x5c ] <== NOT EXECUTED
20056e4: 98 10 00 19 mov %i1, %o4 <== NOT EXECUTED
20056e8: 7f ff fe 19 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
20056ec: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
20056f0: 10 80 00 08 b 2005710 <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
20056f4: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
{
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
20056f8: f8 20 40 0d st %i4, [ %g1 + %o5 ] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
/*
* The page is active.
*/
sc->pages_active++;
20056fc: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 <== NOT EXECUTED
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
fd->blocks[pd->block].page = page;
2005700: f4 20 e0 04 st %i2, [ %g3 + 4 ] <== NOT EXECUTED
/*
* The page is active.
*/
sc->pages_active++;
2005704: 82 00 60 01 inc %g1 <== NOT EXECUTED
2005708: 10 80 00 04 b 2005718 <rtems_fdisk_recover_block_mappings+0x2fc><== NOT EXECUTED
200570c: c2 27 20 1c st %g1, [ %i4 + 0x1c ] <== NOT EXECUTED
}
}
else
sc->pages_bad++;
2005710: 82 00 60 01 inc %g1 <== NOT EXECUTED
2005714: c2 27 20 24 st %g1, [ %i4 + 0x24 ] <== NOT EXECUTED
* are active and how many are used.
*
* If the page is active see if the block is with-in range and
* if the block is a duplicate.
*/
for (page = 0; page < sc->pages; page++, pd++)
2005718: b4 06 a0 01 inc %i2
200571c: b6 06 e0 08 add %i3, 8, %i3
2005720: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2005724: 80 a6 80 01 cmp %i2, %g1
2005728: 0a bf ff a1 bcs 20055ac <rtems_fdisk_recover_block_mappings+0x190>
200572c: 90 10 00 1d mov %i5, %o0
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
2005730: 92 10 00 1c mov %i4, %o1
2005734: 7f ff fe 63 call 20050c0 <rtems_fdisk_queue_segment>
2005738: a0 04 20 01 inc %l0
200573c: 10 80 00 03 b 2005748 <rtems_fdisk_recover_block_mappings+0x32c>
2005740: a4 04 a0 30 add %l2, 0x30, %l2
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
2005744: a0 10 20 00 clr %l0
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
2005748: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
200574c: 84 00 40 11 add %g1, %l1, %g2
2005750: c4 00 a0 04 ld [ %g2 + 4 ], %g2
2005754: 80 a4 00 02 cmp %l0, %g2
2005758: 2a bf ff 53 bcs,a 20054a4 <rtems_fdisk_recover_block_mappings+0x88>
200575c: f8 00 40 11 ld [ %g1 + %l1 ], %i4
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
2005760: b2 06 60 01 inc %i1
2005764: a2 04 60 0c add %l1, 0xc, %l1
2005768: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
200576c: 80 a6 40 01 cmp %i1, %g1
2005770: 0a bf ff f5 bcs 2005744 <rtems_fdisk_recover_block_mappings+0x328>
2005774: a4 10 20 00 clr %l2
rtems_fdisk_queue_segment (fd, sc);
}
}
return 0;
}
2005778: 81 c7 e0 08 ret
200577c: 91 e8 20 00 restore %g0, 0, %o0
020057ec <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)
{
20057ec: 9d e3 bf 80 save %sp, -128, %sp
int ret;
uint32_t spage;
uint32_t used = 0;
20057f0: 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);
20057f4: 82 06 20 34 add %i0, 0x34, %g1
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* ssc,
rtems_fdisk_segment_ctl* dsc,
uint32_t *pages)
{
20057f8: aa 10 00 19 mov %i1, %l5
20057fc: a2 10 00 1a mov %i2, %l1
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
2005800: c0 27 bf fc clr [ %fp + -4 ]
for (spage = 0; spage < ssc->pages; spage++)
2005804: b8 10 20 00 clr %i4
2005808: 10 80 00 c2 b 2005b10 <rtems_fdisk_recycle_segment+0x324>
200580c: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
2005810: ad 2f 20 03 sll %i4, 3, %l6
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (!dsc && ssc->pages_active > 0)
2005814: 80 a4 60 00 cmp %l1, 0
2005818: 12 80 00 0b bne 2005844 <rtems_fdisk_recycle_segment+0x58>
200581c: a0 05 c0 16 add %l7, %l6, %l0
2005820: c6 05 60 1c ld [ %l5 + 0x1c ], %g3
2005824: 80 a0 e0 00 cmp %g3, 0
2005828: 22 80 00 08 be,a 2005848 <rtems_fdisk_recycle_segment+0x5c><== ALWAYS TAKEN
200582c: c6 14 20 02 lduh [ %l0 + 2 ], %g3
{
rtems_fdisk_error ("recycle: no available dst segment");
2005830: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2005834: 7f ff fd c6 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
2005838: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 2030df0 <__FUNCTION__.7127+0x718><== 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;
200583c: 10 80 00 ca b 2005b64 <rtems_fdisk_recycle_segment+0x378> <== NOT EXECUTED
2005840: a8 10 20 05 mov 5, %l4 <== NOT EXECUTED
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
2005844: c6 14 20 02 lduh [ %l0 + 2 ], %g3
{
rtems_fdisk_error ("recycle: no available dst segment");
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
2005848: 80 88 e0 01 btst 1, %g3
200584c: 12 80 00 a8 bne 2005aec <rtems_fdisk_recycle_segment+0x300><== NEVER TAKEN
2005850: 80 88 e0 02 btst 2, %g3
2005854: 02 80 00 a6 be 2005aec <rtems_fdisk_recycle_segment+0x300>
2005858: ba 10 20 00 clr %i5
* Find the next available page in a segment.
*/
static uint32_t
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
200585c: e6 04 60 10 ld [ %l1 + 0x10 ], %l3
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
2005860: 10 80 00 08 b 2005880 <rtems_fdisk_recycle_segment+0x94>
2005864: e8 04 60 14 ld [ %l1 + 0x14 ], %l4
if (rtems_fdisk_page_desc_erased (pd))
2005868: 7f ff fd 35 call 2004d3c <rtems_fdisk_page_desc_erased>
200586c: 01 00 00 00 nop
2005870: 80 8a 20 ff btst 0xff, %o0
2005874: 12 80 00 08 bne 2005894 <rtems_fdisk_recycle_segment+0xa8>
2005878: c2 07 bf fc ld [ %fp + -4 ], %g1
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
200587c: ba 07 60 01 inc %i5
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
2005880: 91 2f 60 03 sll %i5, 3, %o0
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
2005884: 80 a7 40 14 cmp %i5, %l4
2005888: 12 bf ff f8 bne 2005868 <rtems_fdisk_recycle_segment+0x7c><== ALWAYS TAKEN
200588c: 90 04 c0 08 add %l3, %o0, %o0
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
active++;
2005890: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
uint32_t dst_pages;
rtems_fdisk_page_desc* dpd;
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
2005894: b3 2f 60 03 sll %i5, 3, %i1
active++;
2005898: 82 00 60 01 inc %g1
200589c: c2 27 bf fc st %g1, [ %fp + -4 ]
if (dpage >= dsc->pages)
20058a0: 80 a7 40 14 cmp %i5, %l4
20058a4: 0a 80 00 14 bcs 20058f4 <rtems_fdisk_recycle_segment+0x108><== ALWAYS TAKEN
20058a8: b4 04 c0 19 add %l3, %i1, %i2
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
20058ac: 7f ff fd 2e call 2004d64 <rtems_fdisk_seg_pages_available><== NOT EXECUTED
20058b0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
20058b4: d2 04 60 08 ld [ %l1 + 8 ], %o1 <== NOT EXECUTED
20058b8: d4 04 60 0c ld [ %l1 + 0xc ], %o2 <== NOT EXECUTED
20058bc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20058c0: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
20058c4: 7f ff fd a2 call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
20058c8: 90 12 22 18 or %o0, 0x218, %o0 ! 2030e18 <__FUNCTION__.7127+0x740><== NOT EXECUTED
"no page desc available: %d",
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
20058cc: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
20058d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20058d4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
20058d8: 7f ff fd fa call 20050c0 <rtems_fdisk_queue_segment> <== NOT EXECUTED
20058dc: c6 24 60 28 st %g3, [ %l1 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
20058e0: 90 06 20 40 add %i0, 0x40, %o0 <== NOT EXECUTED
20058e4: 7f ff fc 77 call 2004ac0 <rtems_fdisk_segment_queue_push_head><== NOT EXECUTED
20058e8: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
return EIO;
20058ec: 10 80 00 9e b 2005b64 <rtems_fdisk_recycle_segment+0x378> <== NOT EXECUTED
20058f0: a8 10 20 05 mov 5, %l4 <== NOT EXECUTED
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
20058f4: da 04 60 08 ld [ %l1 + 8 ], %o5
20058f8: c6 04 60 0c ld [ %l1 + 0xc ], %g3
20058fc: d4 05 60 08 ld [ %l5 + 8 ], %o2
2005900: d6 05 60 0c ld [ %l5 + 0xc ], %o3
2005904: c6 23 a0 5c st %g3, [ %sp + 0x5c ]
2005908: 98 10 00 1c mov %i4, %o4
200590c: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
2005910: 90 10 00 18 mov %i0, %o0
2005914: 13 00 80 c3 sethi %hi(0x2030c00), %o1
2005918: 7f ff fd 2d call 2004dcc <rtems_fdisk_info>
200591c: 92 12 62 48 or %o1, 0x248, %o1 ! 2030e48 <__FUNCTION__.7127+0x770>
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
2005920: c8 04 60 18 ld [ %l1 + 0x18 ], %g4
2005924: c6 05 60 18 ld [ %l5 + 0x18 ], %g3
rtems_fdisk_segment_ctl* dst_sc,
uint32_t dst_page)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
2005928: da 04 60 08 ld [ %l1 + 8 ], %o5
200592c: de 04 60 0c ld [ %l1 + 0xc ], %o7
2005930: d4 05 60 08 ld [ %l5 + 8 ], %o2
2005934: d6 05 60 0c ld [ %l5 + 0xc ], %o3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
2005938: 88 07 40 04 add %i5, %g4, %g4
200593c: 86 07 00 03 add %i4, %g3, %g3
rtems_fdisk_segment_ctl* dst_sc,
uint32_t dst_page)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
2005940: c8 23 a0 60 st %g4, [ %sp + 0x60 ]
2005944: 98 10 00 03 mov %g3, %o4
2005948: c8 27 bf f0 st %g4, [ %fp + -16 ]
200594c: de 23 a0 5c st %o7, [ %sp + 0x5c ]
2005950: c6 27 bf f4 st %g3, [ %fp + -12 ]
2005954: 90 10 00 18 mov %i0, %o0
2005958: 13 00 80 c3 sethi %hi(0x2030c00), %o1
200595c: 7f ff fd 3c call 2004e4c <rtems_fdisk_printf>
2005960: 92 12 62 70 or %o1, 0x270, %o1 ! 2030e70 <__FUNCTION__.7127+0x798>
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,
2005964: c6 07 bf f4 ld [ %fp + -12 ], %g3
page * fd->block_size, buffer, fd->block_size);
2005968: e8 06 20 14 ld [ %i0 + 0x14 ], %l4
rtems_fdisk_seg_read_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
200596c: 90 10 00 03 mov %g3, %o0
2005970: 7f ff f3 09 call 2002594 <.umul>
2005974: 92 10 00 14 mov %l4, %o1
2005978: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
200597c: 94 10 00 08 mov %o0, %o2
2005980: 98 10 00 14 mov %l4, %o4
2005984: 90 10 00 18 mov %i0, %o0
2005988: 7f ff fe 2b call 2005234 <rtems_fdisk_seg_read>
200598c: 92 10 00 15 mov %l5, %o1
src_sc->device, src_sc->segment, src_page,
dst_sc->device, dst_sc->segment, dst_page);
#endif
ret = rtems_fdisk_seg_read_page (fd, src_sc, src_page,
fd->copy_buffer);
if (ret)
2005990: a8 92 20 00 orcc %o0, 0, %l4
2005994: 12 80 00 0a bne 20059bc <rtems_fdisk_recycle_segment+0x1d0><== NEVER TAKEN
2005998: c8 07 bf f0 ld [ %fp + -16 ], %g4
return ret;
return rtems_fdisk_seg_write_page (fd, dst_sc, dst_page,
200599c: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
20059a0: 90 10 00 18 mov %i0, %o0
20059a4: 92 10 00 11 mov %l1, %o1
20059a8: 7f ff ff 76 call 2005780 <rtems_fdisk_seg_write_page>
20059ac: 94 10 00 04 mov %g4, %o2
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
spage + ssc->pages_desc,
dsc,
dpage + dsc->pages_desc);
if (ret)
20059b0: a8 92 20 00 orcc %o0, 0, %l4
20059b4: 22 80 00 0e be,a 20059ec <rtems_fdisk_recycle_segment+0x200><== ALWAYS TAKEN
20059b8: c6 05 c0 16 ld [ %l7 + %l6 ], %g3
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
20059bc: e0 05 60 08 ld [ %l5 + 8 ], %l0 <== NOT EXECUTED
20059c0: f2 05 60 0c ld [ %l5 + 0xc ], %i1 <== NOT EXECUTED
20059c4: f4 04 60 08 ld [ %l1 + 8 ], %i2 <== NOT EXECUTED
20059c8: f6 04 60 0c ld [ %l1 + 0xc ], %i3 <== NOT EXECUTED
20059cc: 40 00 75 da call 2023134 <strerror> <== NOT EXECUTED
20059d0: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
20059d4: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
20059d8: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
20059dc: e8 23 a0 64 st %l4, [ %sp + 0x64 ] <== NOT EXECUTED
20059e0: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
20059e4: 10 80 00 17 b 2005a40 <rtems_fdisk_recycle_segment+0x254> <== NOT EXECUTED
20059e8: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 2030ea0 <__FUNCTION__.7127+0x7c8><== NOT EXECUTED
return ret;
}
*dpd = *spd;
ret = rtems_fdisk_seg_write_page_desc (fd,
20059ec: 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;
20059f0: c6 24 c0 19 st %g3, [ %l3 + %i1 ]
20059f4: c6 04 20 04 ld [ %l0 + 4 ], %g3
ret = rtems_fdisk_seg_write_page_desc (fd,
20059f8: 92 10 00 11 mov %l1, %o1
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
20059fc: c6 26 a0 04 st %g3, [ %i2 + 4 ]
ret = rtems_fdisk_seg_write_page_desc (fd,
2005a00: 94 10 00 1d mov %i5, %o2
2005a04: 7f ff fe 75 call 20053d8 <rtems_fdisk_seg_write_page_desc>
2005a08: 96 10 00 1a mov %i2, %o3
dsc,
dpage, dpd);
if (ret)
2005a0c: a8 92 20 00 orcc %o0, 0, %l4
2005a10: 22 80 00 1a be,a 2005a78 <rtems_fdisk_recycle_segment+0x28c><== ALWAYS TAKEN
2005a14: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
2005a18: e0 05 60 08 ld [ %l5 + 8 ], %l0 <== NOT EXECUTED
2005a1c: f2 05 60 0c ld [ %l5 + 0xc ], %i1 <== NOT EXECUTED
2005a20: f4 04 60 08 ld [ %l1 + 8 ], %i2 <== NOT EXECUTED
2005a24: 40 00 75 c4 call 2023134 <strerror> <== NOT EXECUTED
2005a28: f6 04 60 0c ld [ %l1 + 0xc ], %i3 <== NOT EXECUTED
2005a2c: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
2005a30: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
2005a34: e8 23 a0 64 st %l4, [ %sp + 0x64 ] <== NOT EXECUTED
2005a38: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2005a3c: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 2030ee8 <__FUNCTION__.7127+0x810><== NOT EXECUTED
2005a40: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2005a44: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2005a48: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
2005a4c: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
2005a50: 7f ff fd 3f call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
2005a54: 9a 10 00 1b mov %i3, %o5 <== NOT EXECUTED
"%02d-%03d-%03d: copy pd failed: %s (%d)",
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage,
strerror (ret), ret);
rtems_fdisk_queue_segment (fd, dsc);
2005a58: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2005a5c: 7f ff fd 99 call 20050c0 <rtems_fdisk_queue_segment> <== NOT EXECUTED
2005a60: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
2005a64: 90 06 20 40 add %i0, 0x40, %o0 <== NOT EXECUTED
2005a68: 7f ff fc 16 call 2004ac0 <rtems_fdisk_segment_queue_push_head><== NOT EXECUTED
2005a6c: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
return ret;
2005a70: 81 c7 e0 08 ret <== NOT EXECUTED
2005a74: 91 e8 00 14 restore %g0, %l4, %o0 <== NOT EXECUTED
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
2005a78: c8 06 20 18 ld [ %i0 + 0x18 ], %g4
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
dsc->pages_active++;
2005a7c: 86 00 e0 01 inc %g3
2005a80: c6 24 60 1c st %g3, [ %l1 + 0x1c ]
* segment will be erased. Power down could be a problem.
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
2005a84: c6 05 60 1c ld [ %l5 + 0x1c ], %g3
fd->blocks[spd->block].page = dpage;
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
2005a88: 90 10 00 18 mov %i0, %o0
* segment will be erased. Power down could be a problem.
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
2005a8c: 86 00 ff ff add %g3, -1, %g3
2005a90: c6 25 60 1c st %g3, [ %l5 + 0x1c ]
ssc->pages_used++;
2005a94: c6 05 60 20 ld [ %l5 + 0x20 ], %g3
2005a98: 86 00 e0 01 inc %g3
2005a9c: c6 25 60 20 st %g3, [ %l5 + 0x20 ]
fd->blocks[spd->block].segment = dsc;
2005aa0: c6 04 20 04 ld [ %l0 + 4 ], %g3
2005aa4: 87 28 e0 03 sll %g3, 3, %g3
2005aa8: 9e 01 00 03 add %g4, %g3, %o7
2005aac: e2 21 00 03 st %l1, [ %g4 + %g3 ]
fd->blocks[spd->block].page = dpage;
2005ab0: fa 23 e0 04 st %i5, [ %o7 + 4 ]
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
2005ab4: 7f ff fd 83 call 20050c0 <rtems_fdisk_queue_segment>
2005ab8: 92 10 00 11 mov %l1, %o1
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
2005abc: 7f ff fc aa call 2004d64 <rtems_fdisk_seg_pages_available>
2005ac0: 90 10 00 11 mov %l1, %o0
if (dst_pages == 0)
2005ac4: 80 a2 20 00 cmp %o0, 0
2005ac8: 32 80 00 06 bne,a 2005ae0 <rtems_fdisk_recycle_segment+0x2f4>
2005acc: c6 06 c0 00 ld [ %i3 ], %g3
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005ad0: 7f ff fc ad call 2004d84 <rtems_fdisk_seg_most_available>
2005ad4: d0 07 bf f8 ld [ %fp + -8 ], %o0
2005ad8: a2 10 00 08 mov %o0, %l1
(*pages)--;
2005adc: c6 06 c0 00 ld [ %i3 ], %g3
2005ae0: 86 00 ff ff add %g3, -1, %g3
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
!rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_USED))
{
2005ae4: 10 80 00 0a b 2005b0c <rtems_fdisk_recycle_segment+0x320>
2005ae8: c6 26 c0 00 st %g3, [ %i3 ]
if (dst_pages == 0)
dsc = rtems_fdisk_seg_most_available (&fd->available);
(*pages)--;
}
else if (rtems_fdisk_page_desc_erased (spd))
2005aec: 7f ff fc 94 call 2004d3c <rtems_fdisk_page_desc_erased>
2005af0: 90 10 00 10 mov %l0, %o0
2005af4: 80 8a 20 ff btst 0xff, %o0
2005af8: 22 80 00 05 be,a 2005b0c <rtems_fdisk_recycle_segment+0x320><== ALWAYS TAKEN
2005afc: a4 04 a0 01 inc %l2
{
--fd->erased_blocks;
2005b00: c6 06 20 28 ld [ %i0 + 0x28 ], %g3 <== NOT EXECUTED
2005b04: 86 00 ff ff add %g3, -1, %g3 <== NOT EXECUTED
2005b08: c6 26 20 28 st %g3, [ %i0 + 0x28 ] <== NOT EXECUTED
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
2005b0c: b8 07 20 01 inc %i4
2005b10: c6 05 60 14 ld [ %l5 + 0x14 ], %g3
2005b14: 80 a7 00 03 cmp %i4, %g3
2005b18: 2a bf ff 3e bcs,a 2005810 <rtems_fdisk_recycle_segment+0x24>
2005b1c: ee 05 60 10 ld [ %l5 + 0x10 ], %l7
used++;
}
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, "ssc end: %d-%d: p=%ld, a=%ld, u=%ld",
2005b20: d4 05 60 08 ld [ %l5 + 8 ], %o2
2005b24: d6 05 60 0c ld [ %l5 + 0xc ], %o3
2005b28: da 07 bf fc ld [ %fp + -4 ], %o5
2005b2c: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
2005b30: 90 10 00 18 mov %i0, %o0
2005b34: 13 00 80 c3 sethi %hi(0x2030c00), %o1
2005b38: 98 10 00 1b mov %i3, %o4
2005b3c: 7f ff fc c4 call 2004e4c <rtems_fdisk_printf>
2005b40: 92 12 63 30 or %o1, 0x330, %o1
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
2005b44: d2 05 60 1c ld [ %l5 + 0x1c ], %o1
2005b48: 80 a2 60 00 cmp %o1, 0
2005b4c: 02 80 00 04 be 2005b5c <rtems_fdisk_recycle_segment+0x370><== ALWAYS TAKEN
2005b50: 11 00 80 c3 sethi %hi(0x2030c00), %o0
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
2005b54: 7f ff fc fe call 2004f4c <rtems_fdisk_error> <== NOT EXECUTED
2005b58: 90 12 23 58 or %o0, 0x358, %o0 ! 2030f58 <__FUNCTION__.7127+0x880><== NOT EXECUTED
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
2005b5c: 7f ff fd 19 call 2004fc0 <rtems_fdisk_erase_segment>
2005b60: 93 e8 00 15 restore %g0, %l5, %o1
return ret;
}
2005b64: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
2005b68: 81 c7 e0 08 ret <== NOT EXECUTED
2005b6c: 81 e8 00 00 restore <== NOT EXECUTED
02005340 <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)
{
2005340: 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;
2005344: e0 06 60 08 ld [ %i1 + 8 ], %l0
segment = sc->segment;
2005348: 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;
200534c: 85 2c 20 04 sll %l0, 4, %g2
2005350: 83 2c 20 02 sll %l0, 2, %g1
2005354: 82 20 80 01 sub %g2, %g1, %g1
2005358: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
200535c: 89 2f 60 06 sll %i5, 6, %g4
2005360: 86 00 80 01 add %g2, %g1, %g3
2005364: c4 00 80 01 ld [ %g2 + %g1 ], %g2
2005368: 83 2f 60 04 sll %i5, 4, %g1
200536c: 82 21 00 01 sub %g4, %g1, %g1
2005370: 82 00 80 01 add %g2, %g1, %g1
2005374: e2 00 60 04 ld [ %g1 + 4 ], %l1
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
2005378: c2 00 e0 08 ld [ %g3 + 8 ], %g1
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
200537c: 90 10 00 18 mov %i0, %o0
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
2005380: e4 00 60 08 ld [ %g1 + 8 ], %l2
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
2005384: 94 10 00 10 mov %l0, %o2
2005388: 96 10 00 1d mov %i5, %o3
200538c: 98 10 00 1a mov %i2, %o4
2005390: 9a 10 00 1c mov %i4, %o5
2005394: 13 00 80 c3 sethi %hi(0x2030c00), %o1
2005398: 7f ff fe ad call 2004e4c <rtems_fdisk_printf>
200539c: 92 12 60 b0 or %o1, 0xb0, %o1 ! 2030cb0 <__FUNCTION__.7127+0x5d8>
device, segment, offset, size);
#endif
ret = ops->write (sd, device, segment, offset, buffer, size);
20053a0: c2 04 a0 04 ld [ %l2 + 4 ], %g1
20053a4: 90 10 00 11 mov %l1, %o0
20053a8: 92 10 00 10 mov %l0, %o1
20053ac: 94 10 00 1d mov %i5, %o2
20053b0: 96 10 00 1a mov %i2, %o3
20053b4: 98 10 00 1b mov %i3, %o4
20053b8: 9f c0 40 00 call %g1
20053bc: 9a 10 00 1c mov %i4, %o5
if (ret)
20053c0: b0 92 20 00 orcc %o0, 0, %i0
20053c4: 02 80 00 03 be 20053d0 <rtems_fdisk_seg_write+0x90> <== ALWAYS TAKEN
20053c8: 82 10 20 01 mov 1, %g1
sc->failed = true;
20053cc: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
return ret;
}
20053d0: 81 c7 e0 08 ret
20053d4: 81 e8 00 00 restore
02005780 <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)
{
2005780: 9d e3 bf a0 save %sp, -96, %sp
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
2005784: c2 06 20 08 ld [ %i0 + 8 ], %g1
2005788: 80 88 60 08 btst 8, %g1
200578c: 32 80 00 0b bne,a 20057b8 <rtems_fdisk_seg_write_page+0x38><== ALWAYS TAKEN
2005790: fa 06 20 14 ld [ %i0 + 0x14 ], %i5
{
int ret = rtems_fdisk_seg_blank_check_page (fd, sc, page);
if (ret)
return ret;
}
--fd->erased_blocks;
2005794: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
return rtems_fdisk_seg_write (fd, sc,
page * fd->block_size, buffer, fd->block_size);
2005798: 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;
200579c: 82 00 7f ff add %g1, -1, %g1
return rtems_fdisk_seg_write (fd, sc,
20057a0: 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;
20057a4: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
return rtems_fdisk_seg_write (fd, sc,
20057a8: 7f ff f3 7b call 2002594 <.umul>
20057ac: 92 10 00 1c mov %i4, %o1
20057b0: 7f ff fe e4 call 2005340 <rtems_fdisk_seg_write>
20057b4: 95 e8 00 08 restore %g0, %o0, %o2
static int
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
20057b8: 90 10 00 1a mov %i2, %o0
20057bc: 7f ff f3 76 call 2002594 <.umul>
20057c0: 92 10 00 1d mov %i5, %o1
20057c4: 92 10 00 19 mov %i1, %o1
20057c8: 94 10 00 08 mov %o0, %o2
20057cc: 96 10 00 1d mov %i5, %o3
20057d0: 7f ff fe bb call 20052bc <rtems_fdisk_seg_blank_check>
20057d4: 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)
20057d8: 80 a2 20 00 cmp %o0, 0
20057dc: 22 bf ff ef be,a 2005798 <rtems_fdisk_seg_write_page+0x18><== ALWAYS TAKEN
20057e0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
return ret;
}
--fd->erased_blocks;
return rtems_fdisk_seg_write (fd, sc,
page * fd->block_size, buffer, fd->block_size);
}
20057e4: 81 c7 e0 08 ret <== NOT EXECUTED
20057e8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
020053d8 <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)
{
20053d8: 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))
20053dc: c2 06 20 08 ld [ %i0 + 8 ], %g1
20053e0: 80 88 60 08 btst 8, %g1
20053e4: 12 80 00 04 bne 20053f4 <rtems_fdisk_seg_write_page_desc+0x1c><== ALWAYS TAKEN
20053e8: b5 2e a0 03 sll %i2, 3, %i2
offset,
sizeof (rtems_fdisk_page_desc));
if (ret)
return ret;
}
return rtems_fdisk_seg_write (fd, sc, offset,
20053ec: 7f ff ff d5 call 2005340 <rtems_fdisk_seg_write>
20053f0: 99 e8 20 08 restore %g0, 8, %o4
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = page * sizeof (rtems_fdisk_page_desc);
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
{
int ret = rtems_fdisk_seg_blank_check (fd, sc,
20053f4: 90 10 00 18 mov %i0, %o0
20053f8: 92 10 00 19 mov %i1, %o1
20053fc: 94 10 00 1a mov %i2, %o2
2005400: 7f ff ff af call 20052bc <rtems_fdisk_seg_blank_check>
2005404: 96 10 20 08 mov 8, %o3
offset,
sizeof (rtems_fdisk_page_desc));
if (ret)
2005408: 80 a2 20 00 cmp %o0, 0
200540c: 02 bf ff f8 be 20053ec <rtems_fdisk_seg_write_page_desc+0x14><== ALWAYS TAKEN
2005410: 01 00 00 00 nop
return ret;
}
return rtems_fdisk_seg_write (fd, sc, offset,
page_desc, sizeof (rtems_fdisk_page_desc));
}
2005414: 81 c7 e0 08 ret <== NOT EXECUTED
2005418: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02004bf8 <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)
2004bf8: 80 a2 60 00 cmp %o1, 0
2004bfc: 02 80 00 10 be 2004c3c <rtems_fdisk_segment_queue_insert_before+0x44><== NEVER TAKEN
2004c00: 84 10 00 08 mov %o0, %g2
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
2004c04: 10 80 00 0b b 2004c30 <rtems_fdisk_segment_queue_insert_before+0x38>
2004c08: c2 02 00 00 ld [ %o0 ], %g1
{
if (item == it)
2004c0c: 32 80 00 08 bne,a 2004c2c <rtems_fdisk_segment_queue_insert_before+0x34>
2004c10: 84 10 00 01 mov %g1, %g2
{
sc->next = item;
2004c14: d2 22 80 00 st %o1, [ %o2 ]
*prev = sc;
queue->count++;
2004c18: c2 02 20 08 ld [ %o0 + 8 ], %g1
while (it)
{
if (item == it)
{
sc->next = item;
*prev = sc;
2004c1c: d4 20 80 00 st %o2, [ %g2 ]
queue->count++;
2004c20: 82 00 60 01 inc %g1
return;
2004c24: 81 c3 e0 08 retl
2004c28: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
prev = &it->next;
it = it->next;
2004c2c: c2 00 40 00 ld [ %g1 ], %g1
if (item)
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
2004c30: 80 a0 60 00 cmp %g1, 0
2004c34: 12 bf ff f6 bne 2004c0c <rtems_fdisk_segment_queue_insert_before+0x14><== ALWAYS TAKEN
2004c38: 80 a2 40 01 cmp %o1, %g1
prev = &it->next;
it = it->next;
}
}
rtems_fdisk_segment_queue_push_tail (queue, sc);
2004c3c: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
2004c40: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2004c44: 7f ff ff be call 2004b3c <rtems_fdisk_segment_queue_push_tail><== NOT EXECUTED
2004c48: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02004afc <rtems_fdisk_segment_queue_pop_head>:
/**
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
2004afc: 82 10 00 08 mov %o0, %g1
if (queue->head)
2004b00: d0 02 00 00 ld [ %o0 ], %o0
2004b04: 80 a2 20 00 cmp %o0, 0
2004b08: 02 80 00 0b be 2004b34 <rtems_fdisk_segment_queue_pop_head+0x38><== NEVER TAKEN
2004b0c: 01 00 00 00 nop
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
2004b10: c4 02 00 00 ld [ %o0 ], %g2
if (!queue->head)
2004b14: 80 a0 a0 00 cmp %g2, 0
2004b18: 12 80 00 03 bne 2004b24 <rtems_fdisk_segment_queue_pop_head+0x28>
2004b1c: c4 20 40 00 st %g2, [ %g1 ]
queue->tail = 0;
2004b20: c0 20 60 04 clr [ %g1 + 4 ]
queue->count--;
2004b24: c4 00 60 08 ld [ %g1 + 8 ], %g2
2004b28: 84 00 bf ff add %g2, -1, %g2
2004b2c: c4 20 60 08 st %g2, [ %g1 + 8 ]
sc->next = 0;
2004b30: c0 22 00 00 clr [ %o0 ]
return sc;
}
return 0;
}
2004b34: 81 c3 e0 08 retl
02004ac0 <rtems_fdisk_segment_queue_push_head>:
*/
static void
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
2004ac0: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
2004ac4: 02 80 00 0c be 2004af4 <rtems_fdisk_segment_queue_push_head+0x34><== NOT EXECUTED
2004ac8: 01 00 00 00 nop <== NOT EXECUTED
{
sc->next = queue->head;
2004acc: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
2004ad0: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
2004ad4: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED
2004ad8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2004adc: 12 80 00 03 bne 2004ae8 <rtems_fdisk_segment_queue_push_head+0x28><== NOT EXECUTED
2004ae0: d2 22 00 00 st %o1, [ %o0 ] <== NOT EXECUTED
queue->tail = sc;
2004ae4: d2 22 20 04 st %o1, [ %o0 + 4 ] <== NOT EXECUTED
queue->count++;
2004ae8: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED
2004aec: 82 00 60 01 inc %g1 <== NOT EXECUTED
2004af0: c2 22 20 08 st %g1, [ %o0 + 8 ] <== NOT EXECUTED
2004af4: 81 c3 e0 08 retl <== NOT EXECUTED
02004b3c <rtems_fdisk_segment_queue_push_tail>:
*/
static void
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
2004b3c: 80 a2 60 00 cmp %o1, 0
2004b40: 02 80 00 0f be 2004b7c <rtems_fdisk_segment_queue_push_tail+0x40><== NEVER TAKEN
2004b44: 01 00 00 00 nop
{
sc->next = 0;
if (queue->head)
2004b48: c2 02 00 00 ld [ %o0 ], %g1
2004b4c: 80 a0 60 00 cmp %g1, 0
2004b50: 02 80 00 06 be 2004b68 <rtems_fdisk_segment_queue_push_tail+0x2c>
2004b54: c0 22 40 00 clr [ %o1 ]
{
queue->tail->next = sc;
2004b58: c2 02 20 04 ld [ %o0 + 4 ], %g1
2004b5c: d2 20 40 00 st %o1, [ %g1 ]
queue->tail = sc;
2004b60: 10 80 00 04 b 2004b70 <rtems_fdisk_segment_queue_push_tail+0x34>
2004b64: d2 22 20 04 st %o1, [ %o0 + 4 ]
}
else
{
queue->head = queue->tail = sc;
2004b68: d2 22 20 04 st %o1, [ %o0 + 4 ]
2004b6c: d2 22 00 00 st %o1, [ %o0 ]
}
queue->count++;
2004b70: c2 02 20 08 ld [ %o0 + 8 ], %g1
2004b74: 82 00 60 01 inc %g1
2004b78: c2 22 20 08 st %g1, [ %o0 + 8 ]
2004b7c: 81 c3 e0 08 retl
02004b84 <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;
2004b84: c2 02 00 00 ld [ %o0 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
2004b88: 10 80 00 17 b 2004be4 <rtems_fdisk_segment_queue_remove+0x60>
2004b8c: 84 10 20 00 clr %g2
{
if (sc == it)
2004b90: 32 80 00 14 bne,a 2004be0 <rtems_fdisk_segment_queue_remove+0x5c>
2004b94: 84 10 00 01 mov %g1, %g2
{
if (prev == 0)
2004b98: 80 a0 a0 00 cmp %g2, 0
2004b9c: 12 80 00 07 bne 2004bb8 <rtems_fdisk_segment_queue_remove+0x34>
2004ba0: c2 02 40 00 ld [ %o1 ], %g1
{
queue->head = sc->next;
if (queue->head == 0)
2004ba4: 80 a0 60 00 cmp %g1, 0
2004ba8: 12 80 00 09 bne 2004bcc <rtems_fdisk_segment_queue_remove+0x48>
2004bac: c2 22 00 00 st %g1, [ %o0 ]
queue->tail = 0;
2004bb0: 10 80 00 07 b 2004bcc <rtems_fdisk_segment_queue_remove+0x48>
2004bb4: c0 22 20 04 clr [ %o0 + 4 ]
}
else
{
prev->next = sc->next;
2004bb8: c2 20 80 00 st %g1, [ %g2 ]
if (queue->tail == sc)
2004bbc: c2 02 20 04 ld [ %o0 + 4 ], %g1
2004bc0: 80 a0 40 09 cmp %g1, %o1
2004bc4: 22 80 00 02 be,a 2004bcc <rtems_fdisk_segment_queue_remove+0x48><== ALWAYS TAKEN
2004bc8: c4 22 20 04 st %g2, [ %o0 + 4 ]
queue->tail = prev;
}
sc->next = 0;
queue->count--;
2004bcc: c2 02 20 08 ld [ %o0 + 8 ], %g1
{
prev->next = sc->next;
if (queue->tail == sc)
queue->tail = prev;
}
sc->next = 0;
2004bd0: c0 22 40 00 clr [ %o1 ]
queue->count--;
2004bd4: 82 00 7f ff add %g1, -1, %g1
break;
2004bd8: 81 c3 e0 08 retl
2004bdc: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
prev = it;
it = it->next;
2004be0: c2 00 40 00 ld [ %g1 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
2004be4: 80 a0 60 00 cmp %g1, 0
2004be8: 12 bf ff ea bne 2004b90 <rtems_fdisk_segment_queue_remove+0xc>
2004bec: 80 a2 40 01 cmp %o1, %g1
2004bf0: 81 c3 e0 08 retl
02004ecc <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, ...)
{
2004ecc: 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);
2004ed0: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2004ed4: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
2004ed8: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
2004edc: 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)
2004ee0: c2 06 20 6c ld [ %i0 + 0x6c ], %g1 <== NOT EXECUTED
2004ee4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2004ee8: 02 80 00 17 be 2004f44 <rtems_fdisk_warning+0x78> <== NOT EXECUTED
2004eec: b0 10 20 00 clr %i0 <== NOT EXECUTED
{
va_list args;
va_start (args, format);
2004ef0: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
2004ef4: 3b 00 80 d7 sethi %hi(0x2035c00), %i5 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
2004ef8: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
2004efc: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
2004f00: 11 00 80 c2 sethi %hi(0x2030800), %o0 <== NOT EXECUTED
2004f04: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2004f08: 40 00 71 15 call 202135c <fputs> <== NOT EXECUTED
2004f0c: 90 12 23 80 or %o0, 0x380, %o0 <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
2004f10: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
2004f14: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
2004f18: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
2004f1c: 40 00 93 5e call 2029c94 <vfprintf> <== NOT EXECUTED
2004f20: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
2004f24: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
ret = vfprintf (stdout, format, args);
2004f28: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
2004f2c: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2004f30: 40 00 70 d7 call 202128c <fputc> <== NOT EXECUTED
2004f34: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
2004f38: c2 07 63 00 ld [ %i5 + 0x300 ], %g1 <== NOT EXECUTED
2004f3c: 40 00 6f bc call 2020e2c <fflush> <== NOT EXECUTED
2004f40: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
2004f44: 81 c7 e0 08 ret <== NOT EXECUTED
2004f48: 81 e8 00 00 restore <== NOT EXECUTED
0200c304 <rtems_filesystem_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
200c304: 9d e3 bf a0 save %sp, -96, %sp
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = geteuid();
200c308: 7f ff ff 05 call 200bf1c <geteuid>
200c30c: b0 0e 20 07 and %i0, 7, %i0
if (task_uid == 0 || task_uid == node_uid) {
200c310: 91 2a 20 10 sll %o0, 0x10, %o0
200c314: 91 32 20 10 srl %o0, 0x10, %o0
200c318: 80 a2 00 1a cmp %o0, %i2
200c31c: 22 80 00 12 be,a 200c364 <rtems_filesystem_check_access+0x60>
200c320: b1 2e 20 06 sll %i0, 6, %i0
200c324: 80 a2 20 00 cmp %o0, 0
200c328: 12 80 00 04 bne 200c338 <rtems_filesystem_check_access+0x34>
200c32c: 01 00 00 00 nop
perm_flags <<= RTEMS_FS_USR_SHIFT;
200c330: 10 80 00 0d b 200c364 <rtems_filesystem_check_access+0x60>
200c334: b1 2e 20 06 sll %i0, 6, %i0
} else {
gid_t task_gid = getegid();
200c338: 7f ff fe f5 call 200bf0c <getegid>
200c33c: 01 00 00 00 nop
if (task_gid == 0 || task_gid == node_gid) {
200c340: 91 2a 20 10 sll %o0, 0x10, %o0
200c344: 91 32 20 10 srl %o0, 0x10, %o0
200c348: 80 a2 00 1b cmp %o0, %i3
200c34c: 22 80 00 06 be,a 200c364 <rtems_filesystem_check_access+0x60>
200c350: b1 2e 20 03 sll %i0, 3, %i0
200c354: 80 a2 20 00 cmp %o0, 0
200c358: 32 80 00 04 bne,a 200c368 <rtems_filesystem_check_access+0x64><== ALWAYS TAKEN
200c35c: b0 2e 00 19 andn %i0, %i1, %i0
perm_flags <<= RTEMS_FS_GRP_SHIFT;
200c360: b1 2e 20 03 sll %i0, 3, %i0 <== NOT EXECUTED
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
200c364: b0 2e 00 19 andn %i0, %i1, %i0
}
200c368: 80 a0 00 18 cmp %g0, %i0
200c36c: b0 60 3f ff subx %g0, -1, %i0
200c370: 81 c7 e0 08 ret
200c374: 81 e8 00 00 restore
02004b68 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
2004b68: 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 );
2004b6c: 3b 00 80 75 sethi %hi(0x201d400), %i5
2004b70: d0 07 60 4c ld [ %i5 + 0x4c ], %o0 ! 201d44c <rtems_libio_semaphore>
2004b74: 92 10 20 00 clr %o1
2004b78: 40 00 0a d3 call 20076c4 <rtems_semaphore_obtain>
2004b7c: 94 10 20 00 clr %o2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
2004b80: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
2004b84: c2 06 20 04 ld [ %i0 + 4 ], %g1
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2004b88: d0 07 60 4c ld [ %i5 + 0x4c ], %o0
next->previous = previous;
2004b8c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
2004b90: 40 00 0b 16 call 20077e8 <rtems_semaphore_release>
2004b94: 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);
2004b98: 40 00 00 4d call 2004ccc <rtems_filesystem_global_location_release>
2004b9c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
(*mt_entry->ops->fsunmount_me_h)(mt_entry);
2004ba0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2004ba4: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
2004ba8: 9f c0 40 00 call %g1
2004bac: 90 10 00 18 mov %i0, %o0
if (mt_entry->unmount_task != 0) {
2004bb0: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
2004bb4: 80 a2 20 00 cmp %o0, 0
2004bb8: 02 80 00 09 be 2004bdc <rtems_filesystem_do_unmount+0x74> <== NEVER TAKEN
2004bbc: 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 );
2004bc0: 40 00 0b 37 call 200789c <rtems_event_system_send>
2004bc4: 13 20 00 00 sethi %hi(0x80000000), %o1
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
2004bc8: 80 a2 20 00 cmp %o0, 0
2004bcc: 02 80 00 04 be 2004bdc <rtems_filesystem_do_unmount+0x74> <== ALWAYS TAKEN
2004bd0: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
2004bd4: 40 00 0c 99 call 2007e38 <rtems_fatal_error_occurred> <== NOT EXECUTED
2004bd8: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
}
}
free(mt_entry);
2004bdc: 7f ff fa 75 call 20035b0 <free>
2004be0: 81 e8 00 00 restore
0200c3b0 <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
)
{
200c3b0: 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);
200c3b4: 23 00 80 6e sethi %hi(0x201b800), %l1
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
200c3b8: 3b 00 80 6c sethi %hi(0x201b000), %i5
rtems_filesystem_eval_path_error(ctx, EINVAL);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
rtems_filesystem_location_info_t *currentloc =
200c3bc: a0 06 20 18 add %i0, 0x18, %l0
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
200c3c0: a2 14 60 28 or %l1, 0x28, %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);
200c3c4: ba 17 63 90 or %i5, 0x390, %i5
rtems_filesystem_eval_path_context_t *ctx,
const char **token,
size_t *tokenlen
)
{
rtems_filesystem_eval_path_next_token(ctx);
200c3c8: 40 00 00 99 call 200c62c <rtems_filesystem_eval_path_next_token>
200c3cc: 90 10 00 18 mov %i0, %o0
*token = ctx->token;
*tokenlen = ctx->tokenlen;
200c3d0: f8 06 20 0c ld [ %i0 + 0xc ], %i4
const char *token;
size_t tokenlen;
rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
if (tokenlen > 0) {
200c3d4: 80 a7 20 00 cmp %i4, 0
200c3d8: 02 80 00 54 be 200c528 <rtems_filesystem_eval_path_generic+0x178>
200c3dc: f6 06 20 08 ld [ %i0 + 8 ], %i3
if ((*config->is_directory)(ctx, arg)) {
200c3e0: c2 06 80 00 ld [ %i2 ], %g1
200c3e4: 90 10 00 18 mov %i0, %o0
200c3e8: 9f c0 40 00 call %g1
200c3ec: 92 10 00 19 mov %i1, %o1
200c3f0: 80 8a 20 ff btst 0xff, %o0
200c3f4: 02 80 00 75 be 200c5c8 <rtems_filesystem_eval_path_generic+0x218>
200c3f8: 80 a7 20 01 cmp %i4, 1
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
200c3fc: 12 80 00 06 bne 200c414 <rtems_filesystem_eval_path_generic+0x64>
200c400: 82 10 20 00 clr %g1
200c404: c2 4e c0 00 ldsb [ %i3 ], %g1
200c408: 82 18 60 2e xor %g1, 0x2e, %g1
200c40c: 80 a0 00 01 cmp %g0, %g1
200c410: 82 60 3f ff subx %g0, -1, %g1
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
200c414: 80 a0 60 00 cmp %g1, 0
200c418: 02 80 00 0f be 200c454 <rtems_filesystem_eval_path_generic+0xa4>
200c41c: 80 a7 20 02 cmp %i4, 2
if (rtems_filesystem_eval_path_has_path(ctx)) {
200c420: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c424: 80 a0 60 00 cmp %g1, 0
200c428: 22 80 00 04 be,a 200c438 <rtems_filesystem_eval_path_generic+0x88>
200c42c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
200c430: 10 80 00 40 b 200c530 <rtems_filesystem_eval_path_generic+0x180>
200c434: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (rtems_filesystem_eval_path_has_path(ctx)) {
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
200c438: 80 88 61 00 btst 0x100, %g1
200c43c: 32 80 00 04 bne,a 200c44c <rtems_filesystem_eval_path_generic+0x9c>
200c440: 90 10 00 18 mov %i0, %o0
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
200c444: 10 80 00 3b b 200c530 <rtems_filesystem_eval_path_generic+0x180>
200c448: c2 06 a0 04 ld [ %i2 + 4 ], %g1
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
rtems_filesystem_eval_path_error(ctx, EINVAL);
200c44c: 10 80 00 5b b 200c5b8 <rtems_filesystem_eval_path_generic+0x208>
200c450: 92 10 20 16 mov 0x16, %o1
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
200c454: 12 80 00 0a bne 200c47c <rtems_filesystem_eval_path_generic+0xcc>
200c458: 82 10 20 00 clr %g1
200c45c: c4 4e c0 00 ldsb [ %i3 ], %g2
200c460: 80 a0 a0 2e cmp %g2, 0x2e
200c464: 12 80 00 07 bne 200c480 <rtems_filesystem_eval_path_generic+0xd0>
200c468: 80 a0 60 00 cmp %g1, 0
200c46c: c2 4e e0 01 ldsb [ %i3 + 1 ], %g1
200c470: 82 18 60 2e xor %g1, 0x2e, %g1
200c474: 80 a0 00 01 cmp %g0, %g1
200c478: 82 60 3f ff subx %g0, -1, %g1
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
200c47c: 80 a0 60 00 cmp %g1, 0
200c480: 22 80 00 36 be,a 200c558 <rtems_filesystem_eval_path_generic+0x1a8>
200c484: c2 06 a0 04 ld [ %i2 + 4 ], %g1
const rtems_filesystem_eval_path_context_t *ctx,
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
200c488: 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;
200c48c: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
return mt_entry == rootloc->mt_entry
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
200c490: c4 02 60 14 ld [ %o1 + 0x14 ], %g2
200c494: 80 a0 40 02 cmp %g1, %g2
200c498: 12 80 00 07 bne 200c4b4 <rtems_filesystem_eval_path_generic+0x104>
200c49c: 90 10 20 00 clr %o0
200c4a0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
200c4a4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
200c4a8: 9f c0 40 00 call %g1
200c4ac: 90 10 00 10 mov %l0, %o0
200c4b0: 90 0a 20 ff and %o0, 0xff, %o0
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc( ctx );
if (is_eval_path_root(ctx, currentloc)) {
200c4b4: 80 8a 20 01 btst 1, %o0
200c4b8: 22 80 00 04 be,a 200c4c8 <rtems_filesystem_eval_path_generic+0x118>
200c4bc: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
200c4c0: 10 80 00 1c b 200c530 <rtems_filesystem_eval_path_generic+0x180>
200c4c4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *mt_fs_root =
&mt_entry->mt_fs_root->location;
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
200c4c8: 90 10 00 10 mov %l0, %o0
200c4cc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200c4d0: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
200c4d4: 9f c0 80 00 call %g2
200c4d8: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
rtems_filesystem_eval_path_get_currentloc( ctx );
if (is_eval_path_root(ctx, currentloc)) {
/* This prevents the escape from a chroot() environment */
status = (*config->eval_token)(ctx, arg, ".", 1);
} else if (is_fs_root(currentloc)) {
200c4dc: 80 8a 20 ff btst 0xff, %o0
200c4e0: 22 80 00 19 be,a 200c544 <rtems_filesystem_eval_path_generic+0x194>
200c4e4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (currentloc->mt_entry->mt_point_node != NULL) {
200c4e8: d2 06 20 2c ld [ %i0 + 0x2c ], %o1
200c4ec: c2 02 60 20 ld [ %o1 + 0x20 ], %g1
200c4f0: 80 a0 60 00 cmp %g1, 0
200c4f4: 22 80 00 0f be,a 200c530 <rtems_filesystem_eval_path_generic+0x180><== NEVER TAKEN
200c4f8: 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;
200c4fc: c2 06 20 0c ld [ %i0 + 0xc ], %g1
ctx->path -= tokenlen;
200c500: c4 06 00 00 ld [ %i0 ], %g2
ctx->pathlen += tokenlen;
ctx->tokenlen = 0;
200c504: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
200c508: 84 20 80 01 sub %g2, %g1, %g2
200c50c: c4 26 00 00 st %g2, [ %i0 ]
ctx->pathlen += tokenlen;
200c510: c4 06 20 04 ld [ %i0 + 4 ], %g2
rtems_filesystem_eval_path_put_back_token(ctx);
rtems_filesystem_eval_path_restart(
200c514: 90 10 00 18 mov %i0, %o0
200c518: 82 00 80 01 add %g2, %g1, %g1
200c51c: 92 02 60 20 add %o1, 0x20, %o1
200c520: 7f ff e1 1b call 200498c <rtems_filesystem_eval_path_restart>
200c524: c2 26 20 04 st %g1, [ %i0 + 4 ]
200c528: 81 c7 e0 08 ret
200c52c: 81 e8 00 00 restore
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
200c530: 90 10 00 18 mov %i0, %o0
200c534: 92 10 00 19 mov %i1, %o1
200c538: 94 10 00 1d mov %i5, %o2
200c53c: 10 80 00 0b b 200c568 <rtems_filesystem_eval_path_generic+0x1b8>
200c540: 96 10 20 01 mov 1, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
200c544: 90 10 00 18 mov %i0, %o0
200c548: 92 10 00 19 mov %i1, %o1
200c54c: 94 10 00 11 mov %l1, %o2
200c550: 10 80 00 06 b 200c568 <rtems_filesystem_eval_path_generic+0x1b8>
200c554: 96 10 20 02 mov 2, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
200c558: 90 10 00 18 mov %i0, %o0
200c55c: 92 10 00 19 mov %i1, %o1
200c560: 94 10 00 1b mov %i3, %o2
200c564: 96 10 00 1c mov %i4, %o3
200c568: 9f c0 40 00 call %g1
200c56c: 01 00 00 00 nop
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
200c570: 80 a2 20 02 cmp %o0, 2
200c574: 12 80 00 18 bne 200c5d4 <rtems_filesystem_eval_path_generic+0x224>
200c578: 80 a2 20 00 cmp %o0, 0
if (rtems_filesystem_eval_path_has_path(ctx)) {
200c57c: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c580: 80 a0 60 00 cmp %g1, 0
200c584: 02 80 00 16 be 200c5dc <rtems_filesystem_eval_path_generic+0x22c>
200c588: 01 00 00 00 nop
int eval_flags;
rtems_filesystem_eval_path_eat_delimiter(ctx);
200c58c: 40 00 00 16 call 200c5e4 <rtems_filesystem_eval_path_eat_delimiter>
200c590: 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
200c594: 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 (
200c598: 80 88 60 80 btst 0x80, %g1
200c59c: 02 80 00 06 be 200c5b4 <rtems_filesystem_eval_path_generic+0x204>
200c5a0: 90 10 00 18 mov %i0, %o0
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
|| rtems_filesystem_eval_path_has_path(ctx)
200c5a4: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c5a8: 80 a0 60 00 cmp %g1, 0
200c5ac: 02 80 00 0c be 200c5dc <rtems_filesystem_eval_path_generic+0x22c>
200c5b0: 01 00 00 00 nop
) {
rtems_filesystem_eval_path_error(ctx, ENOENT);
200c5b4: 92 10 20 02 mov 2, %o1 ! 2 <PROM_START+0x2>
200c5b8: 7f ff e0 10 call 20045f8 <rtems_filesystem_eval_path_error>
200c5bc: 01 00 00 00 nop
200c5c0: 81 c7 e0 08 ret
200c5c4: 81 e8 00 00 restore
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
200c5c8: 90 10 00 18 mov %i0, %o0
200c5cc: 10 bf ff fb b 200c5b8 <rtems_filesystem_eval_path_generic+0x208>
200c5d0: 92 10 20 14 mov 0x14, %o1
)
{
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
200c5d4: 02 bf ff 7d be 200c3c8 <rtems_filesystem_eval_path_generic+0x18>
200c5d8: 01 00 00 00 nop
200c5dc: 81 c7 e0 08 ret
200c5e0: 81 e8 00 00 restore
020049f0 <rtems_filesystem_eval_path_recursive>:
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
20049f0: 9d e3 bf a0 save %sp, -96, %sp
if (pathlen > 0) {
20049f4: 80 a6 a0 00 cmp %i2, 0
20049f8: 02 80 00 26 be 2004a90 <rtems_filesystem_eval_path_recursive+0xa0><== NEVER TAKEN
20049fc: ba 10 00 18 mov %i0, %i5
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
2004a00: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2004a04: 80 a0 60 1f cmp %g1, 0x1f
2004a08: 34 80 00 23 bg,a 2004a94 <rtems_filesystem_eval_path_recursive+0xa4>
2004a0c: b2 10 20 5c mov 0x5c, %i1
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
2004a10: c2 4e 40 00 ldsb [ %i1 ], %g1
const char *saved_path = ctx->path;
2004a14: f6 06 00 00 ld [ %i0 ], %i3
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
2004a18: 80 a0 60 5c cmp %g1, 0x5c
2004a1c: 02 80 00 05 be 2004a30 <rtems_filesystem_eval_path_recursive+0x40><== NEVER TAKEN
2004a20: f8 06 20 04 ld [ %i0 + 4 ], %i4
2004a24: 80 a0 60 2f cmp %g1, 0x2f
2004a28: 32 80 00 06 bne,a 2004a40 <rtems_filesystem_eval_path_recursive+0x50>
2004a2c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
2004a30: 90 10 00 1d mov %i5, %o0
2004a34: 7f ff ff d6 call 200498c <rtems_filesystem_eval_path_restart>
2004a38: 92 07 60 30 add %i5, 0x30, %o1
}
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
2004a3c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
}
ctx->path = path;
2004a40: f2 27 40 00 st %i1, [ %i5 ]
ctx->pathlen = pathlen;
++ctx->recursionlevel;
2004a44: 82 00 60 01 inc %g1
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
}
ctx->path = path;
ctx->pathlen = pathlen;
2004a48: f4 27 60 04 st %i2, [ %i5 + 4 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
2004a4c: 10 80 00 06 b 2004a64 <rtems_filesystem_eval_path_recursive+0x74>
2004a50: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
2004a54: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2004a58: c2 00 60 08 ld [ %g1 + 8 ], %g1
2004a5c: 9f c0 40 00 call %g1
2004a60: 90 10 00 1d mov %i5, %o0
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
2004a64: c2 07 60 04 ld [ %i5 + 4 ], %g1
2004a68: 80 a0 60 00 cmp %g1, 0
2004a6c: 32 bf ff fa bne,a 2004a54 <rtems_filesystem_eval_path_recursive+0x64>
2004a70: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
2004a74: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
ctx->path = saved_path;
2004a78: f6 27 40 00 st %i3, [ %i5 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
2004a7c: 82 00 7f ff add %g1, -1, %g1
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
2004a80: 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;
2004a84: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
2004a88: 81 c7 e0 08 ret
2004a8c: 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);
2004a90: b2 10 20 02 mov 2, %i1 <== NOT EXECUTED
2004a94: 7f ff fe d9 call 20045f8 <rtems_filesystem_eval_path_error>
2004a98: 81 e8 00 00 restore
02004868 <rtems_filesystem_eval_path_start_with_parent>:
const char *path,
int eval_flags,
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
2004868: 9d e3 bf a0 save %sp, -96, %sp
size_t pathlen = strlen(path);
200486c: 40 00 31 07 call 2010c88 <strlen>
2004870: 90 10 00 19 mov %i1, %o0
2004874: 10 80 00 09 b 2004898 <rtems_filesystem_eval_path_start_with_parent+0x30>
2004878: 94 10 00 08 mov %o0, %o2
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
200487c: c4 4e 40 01 ldsb [ %i1 + %g1 ], %g2
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
size_t i = pathlen - 1;
if (rtems_filesystem_is_delimiter(path [i])) {
2004880: 80 a0 a0 5c cmp %g2, 0x5c
2004884: 02 80 00 28 be 2004924 <rtems_filesystem_eval_path_start_with_parent+0xbc><== NEVER TAKEN
2004888: 80 a0 a0 2f cmp %g2, 0x2f
200488c: 02 80 00 27 be 2004928 <rtems_filesystem_eval_path_start_with_parent+0xc0>
2004890: 80 a2 20 00 cmp %o0, 0
return pathlen;
}
pathlen = i;
2004894: 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) {
2004898: 80 a2 a0 00 cmp %o2, 0
200489c: 12 bf ff f8 bne 200487c <rtems_filesystem_eval_path_start_with_parent+0x14>
20048a0: 82 02 bf ff add %o2, -1, %g1
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
20048a4: 80 a2 20 00 cmp %o0, 0
20048a8: 02 80 00 0a be 20048d0 <rtems_filesystem_eval_path_start_with_parent+0x68>
20048ac: ba 10 00 19 mov %i1, %i5
20048b0: a0 10 00 08 mov %o0, %l0
if (parentpathlen == 0) {
parentpath = ".";
20048b4: 33 00 80 6c sethi %hi(0x201b000), %i1
parentpathlen = 1;
20048b8: 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 = ".";
20048bc: 10 80 00 09 b 20048e0 <rtems_filesystem_eval_path_start_with_parent+0x78>
20048c0: 92 16 63 90 or %i1, 0x390, %o1
parentpathlen = 1;
name = path;
namelen = pathlen;
} else {
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
20048c4: a0 22 00 0a sub %o0, %o2, %l0
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
size_t pathlen = strlen(path);
const char *parentpath = path;
20048c8: 10 80 00 06 b 20048e0 <rtems_filesystem_eval_path_start_with_parent+0x78>
20048cc: 92 10 00 19 mov %i1, %o1
20048d0: 92 10 00 19 mov %i1, %o1
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
20048d4: 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;
20048d8: ba 10 20 00 clr %i5
}
pathlen = i;
}
return 0;
20048dc: 94 10 20 00 clr %o2
currentloc = eval_path_start(
ctx,
parentpath,
parentpathlen,
parent_eval_flags,
&rtems_filesystem_root,
20048e0: 03 00 80 72 sethi %hi(0x201c800), %g1
20048e4: da 00 62 e8 ld [ %g1 + 0x2e8 ], %o5 ! 201cae8 <rtems_current_user_env>
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
}
}
currentloc = eval_path_start(
20048e8: 96 10 00 1c mov %i4, %o3
20048ec: 98 03 60 04 add %o5, 4, %o4
20048f0: 7f ff ff 94 call 2004740 <eval_path_start>
20048f4: 90 10 00 18 mov %i0, %o0
20048f8: 92 10 00 08 mov %o0, %o1
parent_eval_flags,
&rtems_filesystem_root,
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
20048fc: 40 00 1d 3b call 200bde8 <rtems_filesystem_location_clone>
2004900: 90 10 00 1b mov %i3, %o0
ctx->path = name;
ctx->pathlen = namelen;
ctx->flags = eval_flags;
rtems_filesystem_eval_path_continue(ctx);
2004904: 90 10 00 18 mov %i0, %o0
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
ctx->path = name;
2004908: fa 26 00 00 st %i5, [ %i0 ]
ctx->pathlen = namelen;
200490c: e0 26 20 04 st %l0, [ %i0 + 4 ]
ctx->flags = eval_flags;
2004910: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
rtems_filesystem_eval_path_continue(ctx);
2004914: 7f ff ff 71 call 20046d8 <rtems_filesystem_eval_path_continue>
2004918: b0 06 20 18 add %i0, 0x18, %i0
200491c: 81 c7 e0 08 ret
2004920: 81 e8 00 00 restore
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
2004924: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004928: 32 bf ff e7 bne,a 20048c4 <rtems_filesystem_eval_path_start_with_parent+0x5c><== ALWAYS TAKEN
200492c: 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;
2004930: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
2004934: a0 10 20 00 clr %l0 <== NOT EXECUTED
)
{
size_t pathlen = strlen(path);
const char *parentpath = path;
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
2004938: 10 bf ff ea b 20048e0 <rtems_filesystem_eval_path_start_with_parent+0x78><== NOT EXECUTED
200493c: ba 10 20 00 clr %i5 <== NOT EXECUTED
0200c16c <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
200c16c: 9d e3 bf 98 save %sp, -104, %sp
find_arg fa = {
200c170: f0 27 bf f8 st %i0, [ %fp + -8 ]
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
200c174: 80 a6 20 00 cmp %i0, 0
200c178: 02 80 00 06 be 200c190 <rtems_filesystem_get_mount_handler+0x24><== NEVER TAKEN
200c17c: c0 27 bf fc clr [ %fp + -4 ]
rtems_filesystem_iterate( find_handler, &fa );
200c180: 11 00 80 30 sethi %hi(0x200c000), %o0
200c184: 92 07 bf f8 add %fp, -8, %o1
200c188: 7f ff ff ce call 200c0c0 <rtems_filesystem_iterate>
200c18c: 90 12 20 5c or %o0, 0x5c, %o0
}
return fa.mount_h;
}
200c190: f0 07 bf fc ld [ %fp + -4 ], %i0
200c194: 81 c7 e0 08 ret
200c198: 81 e8 00 00 restore
0200327c <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
200327c: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
2003280: 05 00 80 69 sethi %hi(0x201a400), %g2
2003284: 82 10 a3 c4 or %g2, 0x3c4, %g1 ! 201a7c4 <rtems_filesystem_root_configuration>
2003288: d0 00 a3 c4 ld [ %g2 + 0x3c4 ], %o0
200328c: d2 00 60 04 ld [ %g1 + 4 ], %o1
2003290: d4 00 60 08 ld [ %g1 + 8 ], %o2
2003294: d6 00 60 0c ld [ %g1 + 0xc ], %o3
2003298: 40 00 02 21 call 2003b1c <mount>
200329c: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
20032a0: 80 a2 20 00 cmp %o0, 0
20032a4: 22 80 00 05 be,a 20032b8 <rtems_filesystem_initialize+0x3c><== ALWAYS TAKEN
20032a8: 11 00 80 6b sethi %hi(0x201ac00), %o0
rtems_fatal_error_occurred( 0xABCD0002 );
20032ac: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
20032b0: 10 80 00 09 b 20032d4 <rtems_filesystem_initialize+0x58> <== NOT EXECUTED
20032b4: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <RAM_END+0xa98d0002><== NOT EXECUTED
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
rv = mkdir( "/dev", 0777);
20032b8: 92 10 21 ff mov 0x1ff, %o1
20032bc: 40 00 01 d0 call 20039fc <mkdir>
20032c0: 90 12 22 18 or %o0, 0x218, %o0
if ( rv != 0 )
20032c4: 80 a2 20 00 cmp %o0, 0
20032c8: 02 80 00 05 be 20032dc <rtems_filesystem_initialize+0x60> <== ALWAYS TAKEN
20032cc: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
rtems_fatal_error_occurred( 0xABCD0003 );
20032d0: 90 12 20 03 or %o0, 3, %o0 ! abcd0003 <RAM_END+0xa98d0003><== NOT EXECUTED
20032d4: 40 00 12 d9 call 2007e38 <rtems_fatal_error_occurred> <== NOT EXECUTED
20032d8: 01 00 00 00 nop <== NOT EXECUTED
20032dc: 81 c7 e0 08 ret
20032e0: 81 e8 00 00 restore
0200c0c0 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
200c0c0: 9d e3 bf a0 save %sp, -96, %sp
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
200c0c4: 39 00 80 69 sethi %hi(0x201a400), %i4
rtems_chain_node *node = NULL;
bool stop = false;
200c0c8: ba 10 20 00 clr %i5
while ( table_entry->type && !stop ) {
200c0cc: 10 80 00 06 b 200c0e4 <rtems_filesystem_iterate+0x24>
200c0d0: b8 17 23 d8 or %i4, 0x3d8, %i4
stop = (*routine)( table_entry, routine_arg );
200c0d4: 92 10 00 19 mov %i1, %o1
200c0d8: 9f c6 00 00 call %i0
200c0dc: b8 07 20 08 add %i4, 8, %i4
200c0e0: ba 10 00 08 mov %o0, %i5
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
200c0e4: c2 07 00 00 ld [ %i4 ], %g1
200c0e8: 80 a0 60 00 cmp %g1, 0
200c0ec: 02 80 00 08 be 200c10c <rtems_filesystem_iterate+0x4c>
200c0f0: 82 0f 60 ff and %i5, 0xff, %g1
200c0f4: 80 a0 60 00 cmp %g1, 0
200c0f8: 02 bf ff f7 be 200c0d4 <rtems_filesystem_iterate+0x14>
200c0fc: 90 10 00 1c mov %i4, %o0
200c100: b0 0f 60 ff and %i5, 0xff, %i0
200c104: 81 c7 e0 08 ret
200c108: 81 e8 00 00 restore
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
200c10c: 80 a0 60 00 cmp %g1, 0
200c110: 32 80 00 15 bne,a 200c164 <rtems_filesystem_iterate+0xa4>
200c114: b0 0f 60 ff and %i5, 0xff, %i0
rtems_libio_lock();
200c118: 7f ff ff de call 200c090 <rtems_libio_lock>
200c11c: 37 00 80 72 sethi %hi(0x201c800), %i3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200c120: 03 00 80 72 sethi %hi(0x201c800), %g1
200c124: f8 00 63 98 ld [ %g1 + 0x398 ], %i4 ! 201cb98 <filesystem_chain>
for (
200c128: 10 80 00 06 b 200c140 <rtems_filesystem_iterate+0x80>
200c12c: b6 16 e3 9c or %i3, 0x39c, %i3
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
200c130: 9f c6 00 00 call %i0
200c134: 92 10 00 19 mov %i1, %o1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200c138: f8 07 00 00 ld [ %i4 ], %i4
200c13c: ba 10 00 08 mov %o0, %i5
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
200c140: 80 a7 00 1b cmp %i4, %i3
200c144: 12 80 00 05 bne 200c158 <rtems_filesystem_iterate+0x98>
200c148: 80 8f 60 ff btst 0xff, %i5
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
200c14c: 7f ff ff d8 call 200c0ac <rtems_libio_unlock>
200c150: b0 0f 60 ff and %i5, 0xff, %i0
200c154: 30 80 00 04 b,a 200c164 <rtems_filesystem_iterate+0xa4>
if ( !stop ) {
rtems_libio_lock();
for (
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
200c158: 02 bf ff f6 be 200c130 <rtems_filesystem_iterate+0x70> <== ALWAYS TAKEN
200c15c: 90 07 20 08 add %i4, 8, %o0
200c160: 30 bf ff fb b,a 200c14c <rtems_filesystem_iterate+0x8c> <== NOT EXECUTED
}
rtems_libio_unlock();
}
return stop;
}
200c164: 81 c7 e0 08 ret
200c168: 81 e8 00 00 restore
02004be4 <rtems_filesystem_location_remove_from_mt_entry>:
}
void rtems_filesystem_location_remove_from_mt_entry(
rtems_filesystem_location_info_t *loc
)
{
2004be4: 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);
2004be8: 7f ff f6 77 call 20025c4 <sparc_disable_interrupts>
2004bec: 01 00 00 00 nop
2004bf0: b8 10 00 08 mov %o0, %i4
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
2004bf4: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
2004bf8: c2 06 20 04 ld [ %i0 + 4 ], %g1
rtems_chain_extract_unprotected(&loc->mt_entry_node);
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
2004bfc: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
next->previous = previous;
2004c00: c2 20 a0 04 st %g1, [ %g2 + 4 ]
2004c04: 7f ff ff a6 call 2004a9c <rtems_filesystem_is_ready_for_unmount>
2004c08: c4 20 40 00 st %g2, [ %g1 ]
2004c0c: ba 10 00 08 mov %o0, %i5
rtems_filesystem_mt_entry_unlock(lock_context);
2004c10: 7f ff f6 71 call 20025d4 <sparc_enable_interrupts>
2004c14: 90 10 00 1c mov %i4, %o0
if (do_unmount) {
2004c18: 80 8f 60 ff btst 0xff, %i5
2004c1c: 02 80 00 05 be 2004c30 <rtems_filesystem_location_remove_from_mt_entry+0x4c><== ALWAYS TAKEN
2004c20: 01 00 00 00 nop
rtems_filesystem_do_unmount(loc->mt_entry);
2004c24: f0 06 20 14 ld [ %i0 + 0x14 ], %i0 <== NOT EXECUTED
2004c28: 7f ff ff d0 call 2004b68 <rtems_filesystem_do_unmount> <== NOT EXECUTED
2004c2c: 81 e8 00 00 restore <== NOT EXECUTED
2004c30: 81 c7 e0 08 ret
2004c34: 81 e8 00 00 restore
02004e18 <rtems_filesystem_location_transform_to_global>:
}
rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global(
rtems_filesystem_location_info_t *loc
)
{
2004e18: 9d e3 bf 98 save %sp, -104, %sp
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
2004e1c: 7f ff fa b9 call 2003900 <malloc>
2004e20: 90 10 20 24 mov 0x24, %o0
if (global_loc != NULL) {
2004e24: ba 92 20 00 orcc %o0, 0, %i5
2004e28: 02 80 00 0b be 2004e54 <rtems_filesystem_location_transform_to_global+0x3c><== NEVER TAKEN
2004e2c: 82 10 20 01 mov 1, %g1
global_loc->reference_count = 1;
global_loc->deferred_released_next = NULL;
2004e30: c0 27 60 1c clr [ %i5 + 0x1c ]
)
{
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
if (global_loc != NULL) {
global_loc->reference_count = 1;
2004e34: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
2004e38: c0 27 60 20 clr [ %i5 + 0x20 ]
rtems_filesystem_location_copy(&global_loc->location, loc);
2004e3c: 7f ff ff 2f call 2004af8 <rtems_filesystem_location_copy>
2004e40: 92 10 00 18 mov %i0, %o1
rtems_filesystem_location_remove_from_mt_entry(loc);
2004e44: 7f ff ff 68 call 2004be4 <rtems_filesystem_location_remove_from_mt_entry>
2004e48: 90 10 00 18 mov %i0, %o0
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
}
return global_loc;
}
2004e4c: 81 c7 e0 08 ret
2004e50: 91 e8 00 1d restore %g0, %i5, %o0
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
rtems_filesystem_location_copy(&global_loc->location, loc);
rtems_filesystem_location_remove_from_mt_entry(loc);
} else {
rtems_filesystem_location_free(loc);
2004e54: 40 00 1b f7 call 200be30 <rtems_filesystem_location_free> <== NOT EXECUTED
2004e58: 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 );
2004e5c: 90 07 bf fc add %fp, -4, %o0 <== NOT EXECUTED
2004e60: 7f ff ff bc call 2004d50 <rtems_filesystem_global_location_obtain><== NOT EXECUTED
2004e64: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
2004e68: 40 00 2a 01 call 200f66c <__errno> <== NOT EXECUTED
2004e6c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
2004e70: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
2004e74: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return global_loc;
}
2004e78: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
2004e7c: 81 c7 e0 08 ret <== NOT EXECUTED
2004e80: 81 e8 00 00 restore <== NOT EXECUTED
02003d94 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
2003d94: 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 ) );
2003d98: 40 00 01 05 call 20041ac <malloc>
2003d9c: 90 10 20 08 mov 8, %o0
*key = new_key;
2003da0: 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 ) );
2003da4: ba 10 00 08 mov %o0, %i5
*key = new_key;
new_key->val = NULL;
2003da8: c0 22 00 00 clr [ %o0 ]
new_key->dtor = dtor;
2003dac: 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 );
2003db0: 92 10 00 1d mov %i5, %o1
2003db4: 90 10 20 00 clr %o0
2003db8: 94 10 00 19 mov %i1, %o2
2003dbc: 40 00 11 ff call 20085b8 <rtems_task_variable_add>
2003dc0: b0 10 20 00 clr %i0
if ( status == RTEMS_SUCCESSFUL )
2003dc4: 80 a2 20 00 cmp %o0, 0
2003dc8: 02 80 00 04 be 2003dd8 <rtems_gxx_key_create+0x44> <== ALWAYS TAKEN
2003dcc: 90 10 00 1d mov %i5, %o0
return 0;
free( new_key );
2003dd0: 7f ff ff 85 call 2003be4 <free> <== NOT EXECUTED
2003dd4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
}
2003dd8: 81 c7 e0 08 ret
2003ddc: 81 e8 00 00 restore
02003dec <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
2003dec: 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 );
2003df0: 90 10 20 00 clr %o0
2003df4: 40 00 12 1c call 2008664 <rtems_task_variable_delete>
2003df8: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
2003dfc: 80 a2 20 00 cmp %o0, 0
2003e00: 12 80 00 06 bne 2003e18 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
2003e04: 80 a6 20 00 cmp %i0, 0
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
2003e08: 02 80 00 04 be 2003e18 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
2003e0c: 01 00 00 00 nop
2003e10: 7f ff ff 75 call 2003be4 <free>
2003e14: d0 06 00 00 ld [ %i0 ], %o0
return 0;
}
key = NULL;
return 0;
}
2003e18: 81 c7 e0 08 ret
2003e1c: 91 e8 20 00 restore %g0, 0, %o0
02003d30 <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))
{
2003d30: 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 ) {
2003d34: c2 06 00 00 ld [ %i0 ], %g1
2003d38: 80 a0 60 00 cmp %g1, 0
2003d3c: 12 80 00 14 bne 2003d8c <rtems_gxx_once+0x5c>
2003d40: 90 10 21 00 mov 0x100, %o0
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
2003d44: 92 10 21 00 mov 0x100, %o1
2003d48: 40 00 11 a2 call 20083d0 <rtems_task_mode>
2003d4c: 94 07 bf fc add %fp, -4, %o2
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
2003d50: fa 06 00 00 ld [ %i0 ], %i5
2003d54: 80 a7 60 00 cmp %i5, 0
2003d58: 12 80 00 05 bne 2003d6c <rtems_gxx_once+0x3c> <== NEVER TAKEN
2003d5c: d0 07 bf fc ld [ %fp + -4 ], %o0
*(volatile __gthread_once_t *)once = 1;
2003d60: 82 10 20 01 mov 1, %g1
2003d64: c2 26 00 00 st %g1, [ %i0 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2003d68: d0 07 bf fc ld [ %fp + -4 ], %o0
2003d6c: 92 10 21 00 mov 0x100, %o1
2003d70: 40 00 11 98 call 20083d0 <rtems_task_mode>
2003d74: 94 07 bf fc add %fp, -4, %o2
if ( o == 0 )
2003d78: 80 a7 60 00 cmp %i5, 0
2003d7c: 12 80 00 04 bne 2003d8c <rtems_gxx_once+0x5c> <== NEVER TAKEN
2003d80: 01 00 00 00 nop
(*func)();
2003d84: 9f c6 40 00 call %i1
2003d88: 01 00 00 00 nop
}
return 0;
}
2003d8c: 81 c7 e0 08 ret
2003d90: 91 e8 20 00 restore %g0, 0, %o0
02003e84 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
2003e84: 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 );
2003e88: d4 06 20 04 ld [ %i0 + 4 ], %o2
2003e8c: 90 10 20 00 clr %o0
2003e90: 40 00 11 ca call 20085b8 <rtems_task_variable_add>
2003e94: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
2003e98: 80 a2 20 00 cmp %o0, 0
2003e9c: 12 80 00 05 bne 2003eb0 <rtems_gxx_setspecific+0x2c> <== NEVER TAKEN
2003ea0: 01 00 00 00 nop
/* now let's set the proper value */
key->val = (void *)ptr;
2003ea4: f2 26 00 00 st %i1, [ %i0 ]
return 0;
2003ea8: 81 c7 e0 08 ret
2003eac: 91 e8 20 00 restore %g0, 0, %o0
}
return -1;
}
2003eb0: 81 c7 e0 08 ret <== NOT EXECUTED
2003eb4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02007ca8 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
2007ca8: 9d e3 bf a0 save %sp, -96, %sp
if (
2007cac: 03 00 80 92 sethi %hi(0x2024800), %g1
2007cb0: c2 00 60 98 ld [ %g1 + 0x98 ], %g1 ! 2024898 <_System_state_Current>
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
2007cb4: ba 10 00 18 mov %i0, %i5
2007cb8: b8 10 00 19 mov %i1, %i4
if (
2007cbc: 80 a0 60 03 cmp %g1, 3
2007cc0: 02 80 00 08 be 2007ce0 <rtems_heap_allocate_aligned_with_boundary+0x38><== ALWAYS TAKEN
2007cc4: b6 10 00 1a mov %i2, %i3
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
2007cc8: 7f ff fb ef call 2006c84 <malloc_deferred_frees_process>
2007ccc: b2 10 00 1d mov %i5, %i1
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
2007cd0: 03 00 80 8b sethi %hi(0x2022c00), %g1
2007cd4: f0 00 62 84 ld [ %g1 + 0x284 ], %i0 ! 2022e84 <RTEMS_Malloc_Heap>
2007cd8: 40 00 17 b9 call 200dbbc <_Protected_heap_Allocate_aligned_with_boundary>
2007cdc: 95 e8 00 1c restore %g0, %i4, %o2
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
2007ce0: 7f ff fb dd call 2006c54 <malloc_is_system_state_OK>
2007ce4: 01 00 00 00 nop
2007ce8: 80 8a 20 ff btst 0xff, %o0
2007cec: 12 bf ff f7 bne 2007cc8 <rtems_heap_allocate_aligned_with_boundary+0x20>
2007cf0: b0 10 20 00 clr %i0
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
2007cf4: 81 c7 e0 08 ret
2007cf8: 81 e8 00 00 restore
020044f0 <rtems_heap_extend_via_sbrk>:
void *rtems_heap_extend_via_sbrk(
Heap_Control *heap,
size_t alloc_size
)
{
20044f0: 9d e3 bf a0 save %sp, -96, %sp
ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;
20044f4: 03 00 80 75 sethi %hi(0x201d400), %g1
20044f8: f8 00 63 40 ld [ %g1 + 0x340 ], %i4 ! 201d740 <RTEMS_Malloc_Sbrk_amount>
ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;
ptrdiff_t misaligned = sbrk_size % sbrk_amount;
20044fc: 90 10 00 19 mov %i1, %o0
2004500: 92 10 00 1c mov %i4, %o1
2004504: 40 00 51 41 call 2018a08 <.rem>
2004508: ba 10 00 19 mov %i1, %i5
void *return_this = NULL;
if ( misaligned != 0 ) {
200450c: 80 a2 20 00 cmp %o0, 0
2004510: 02 80 00 05 be 2004524 <rtems_heap_extend_via_sbrk+0x34>
2004514: 80 a7 60 00 cmp %i5, 0
sbrk_size += sbrk_amount - misaligned;
2004518: ba 27 00 08 sub %i4, %o0, %i5
200451c: ba 06 40 1d add %i1, %i5, %i5
}
if ( sbrk_size > 0 && sbrk_amount > 0 ) {
2004520: 80 a7 60 00 cmp %i5, 0
2004524: 04 80 00 17 ble 2004580 <rtems_heap_extend_via_sbrk+0x90> <== NEVER TAKEN
2004528: 80 a7 20 00 cmp %i4, 0
200452c: 04 80 00 15 ble 2004580 <rtems_heap_extend_via_sbrk+0x90> <== NEVER TAKEN
2004530: 01 00 00 00 nop
void *area_begin = sbrk( sbrk_size );
2004534: 7f ff f3 e8 call 20014d4 <sbrk>
2004538: 90 10 00 1d mov %i5, %o0
if ( area_begin != (void *) -1 ) {
200453c: 80 a2 3f ff cmp %o0, -1
2004540: 02 80 00 10 be 2004580 <rtems_heap_extend_via_sbrk+0x90>
2004544: 92 10 00 08 mov %o0, %o1
bool ok = _Protected_heap_Extend( heap, area_begin, sbrk_size );
2004548: 90 10 00 18 mov %i0, %o0
200454c: 40 00 13 74 call 200931c <_Protected_heap_Extend>
2004550: 94 10 00 1d mov %i5, %o2
if ( ok ) {
2004554: 80 8a 20 ff btst 0xff, %o0
2004558: 02 80 00 08 be 2004578 <rtems_heap_extend_via_sbrk+0x88>
200455c: 03 00 80 75 sethi %hi(0x201d400), %g1
MSBUMP( space_available, sbrk_size );
2004560: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 201d710 <rtems_malloc_statistics>
2004564: b4 10 20 00 clr %i2
2004568: ba 07 40 02 add %i5, %g2, %i5
200456c: fa 20 63 10 st %i5, [ %g1 + 0x310 ]
2004570: 40 00 13 5d call 20092e4 <_Protected_heap_Allocate_aligned_with_boundary>
2004574: 97 e8 20 00 restore %g0, 0, %o3
return_this = _Protected_heap_Allocate( heap, alloc_size );
} else {
sbrk( -sbrk_size );
2004578: 7f ff f3 d7 call 20014d4 <sbrk>
200457c: 90 20 00 1d neg %i5, %o0
}
}
}
return return_this;
}
2004580: 81 c7 e0 08 ret
2004584: 91 e8 20 00 restore %g0, 0, %o0
0200454c <rtems_heap_null_extend>:
Heap_Control *heap __attribute__((unused)),
size_t alloc_size __attribute__((unused))
)
{
return NULL;
}
200454c: 81 c3 e0 08 retl
2004550: 90 10 20 00 clr %o0
02004d40 <rtems_ide_part_table_free>:
* N/A
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
{
partition_table_free( disk_desc );
2004d40: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2004d44: 7f ff fe d1 call 2004888 <partition_table_free> <== NOT EXECUTED
2004d48: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02004d4c <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 );
2004d4c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2004d50: 7f ff ff 87 call 2004b6c <partition_table_get> <== NOT EXECUTED
2004d54: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02004d58 <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)
{
2004d58: 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));
2004d5c: 90 10 20 01 mov 1, %o0
2004d60: 92 10 21 28 mov 0x128, %o1
2004d64: 40 00 01 f5 call 2005538 <calloc>
2004d68: b6 10 20 1a mov 0x1a, %i3
if (disk_desc == NULL)
2004d6c: 80 a2 20 00 cmp %o0, 0
2004d70: 02 80 00 34 be 2004e40 <rtems_ide_part_table_initialize+0xe8><== NEVER TAKEN
2004d74: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
2004d78: 90 10 00 18 mov %i0, %o0
2004d7c: 7f ff ff 7c call 2004b6c <partition_table_get>
2004d80: 92 10 00 1d mov %i5, %o1
if (rc != RTEMS_SUCCESSFUL)
2004d84: b6 92 20 00 orcc %o0, 0, %i3
2004d88: 02 80 00 06 be 2004da0 <rtems_ide_part_table_initialize+0x48><== ALWAYS TAKEN
2004d8c: 23 00 80 90 sethi %hi(0x2024000), %l1
{
free(disk_desc);
2004d90: 40 00 02 be call 2005888 <free> <== NOT EXECUTED
2004d94: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
}
partition_table_free(disk_desc);
return RTEMS_SUCCESSFUL;
}
2004d98: 81 c7 e0 08 ret <== NOT EXECUTED
2004d9c: 91 e8 00 1b restore %g0, %i3, %o0 <== NOT EXECUTED
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
2004da0: 27 00 80 90 sethi %hi(0x2024000), %l3
/* To avoid device numbers conflicts we have to use for logic disk the same
* device major number as ATA device has, and minor number that equals to
* sum of logic disk partition number and the minor number of physical disk
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
2004da4: f2 07 40 00 ld [ %i5 ], %i1
2004da8: e0 07 60 04 ld [ %i5 + 4 ], %l0
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
2004dac: b8 10 20 00 clr %i4
{
sprintf(name, "%s%d", dev_name, part_num + 1);
2004db0: b4 07 bf f0 add %fp, -16, %i2
2004db4: a2 14 63 08 or %l1, 0x308, %l1
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
2004db8: 25 00 80 98 sethi %hi(0x2026000), %l2
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
2004dbc: 10 80 00 1b b 2004e28 <rtems_ide_part_table_initialize+0xd0>
2004dc0: a6 14 e3 10 or %l3, 0x310, %l3
{
sprintf(name, "%s%d", dev_name, part_num + 1);
2004dc4: 92 10 00 11 mov %l1, %o1
2004dc8: 90 10 00 1a mov %i2, %o0
2004dcc: 94 10 00 18 mov %i0, %o2
2004dd0: 40 00 43 f6 call 2015da8 <sprintf>
2004dd4: 96 10 00 1c mov %i4, %o3
* RTEMS_SUCCESSFUL if success,
* RTEMS_NO_MEMOTY if cannot have not enough memory,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
rtems_status_code
rtems_ide_part_table_initialize(const char *dev_name)
2004dd8: 83 2f 20 02 sll %i4, 2, %g1
2004ddc: 82 07 40 01 add %i5, %g1, %g1
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
{
sprintf(name, "%s%d", dev_name, part_num + 1);
dev = rtems_filesystem_make_dev_t(major, ++minor);
part_desc = disk_desc->partitions[part_num];
2004de0: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
if (part_desc == NULL)
2004de4: 80 a0 60 00 cmp %g1, 0
2004de8: 02 80 00 10 be 2004e28 <rtems_ide_part_table_initialize+0xd0>
2004dec: 92 07 00 10 add %i4, %l0, %o1
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
2004df0: d4 1f 40 00 ldd [ %i5 ], %o2
2004df4: d8 00 60 04 ld [ %g1 + 4 ], %o4
2004df8: da 00 60 08 ld [ %g1 + 8 ], %o5
2004dfc: 90 10 00 19 mov %i1, %o0
2004e00: 7f ff fd 63 call 200438c <rtems_disk_create_log>
2004e04: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
2004e08: 96 92 20 00 orcc %o0, 0, %o3
2004e0c: 22 80 00 08 be,a 2004e2c <rtems_ide_part_table_initialize+0xd4><== ALWAYS TAKEN
2004e10: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
2004e14: c2 04 a2 c8 ld [ %l2 + 0x2c8 ], %g1 <== NOT EXECUTED
2004e18: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
2004e1c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
2004e20: 40 00 41 54 call 2015370 <fprintf> <== NOT EXECUTED
2004e24: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
2004e28: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
2004e2c: 80 a7 00 01 cmp %i4, %g1
2004e30: 26 bf ff e5 bl,a 2004dc4 <rtems_ide_part_table_initialize+0x6c>
2004e34: b8 07 20 01 inc %i4
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
continue;
}
}
partition_table_free(disk_desc);
2004e38: 7f ff fe 94 call 2004888 <partition_table_free>
2004e3c: 90 10 00 1d mov %i5, %o0
return RTEMS_SUCCESSFUL;
}
2004e40: b0 10 00 1b mov %i3, %i0
2004e44: 81 c7 e0 08 ret
2004e48: 81 e8 00 00 restore
0200a3b8 <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)
{
200a3b8: 9d e3 bf a0 save %sp, -96, %sp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
200a3bc: ba 10 20 01 mov 1, %i5
200a3c0: 80 a6 20 00 cmp %i0, 0
200a3c4: 02 80 00 0d be 200a3f8 <rtems_iterate_over_all_threads+0x40><== NEVER TAKEN
200a3c8: 35 00 80 80 sethi %hi(0x2020000), %i2
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
200a3cc: 83 2f 60 02 sll %i5, 2, %g1
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
200a3d0: 84 16 a1 74 or %i2, 0x174, %g2
200a3d4: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200a3d8: f6 00 60 04 ld [ %g1 + 4 ], %i3
if ( !information )
200a3dc: 80 a6 e0 00 cmp %i3, 0
200a3e0: 12 80 00 0f bne 200a41c <rtems_iterate_over_all_threads+0x64>
200a3e4: b8 10 20 01 mov 1, %i4
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
200a3e8: ba 07 60 01 inc %i5
200a3ec: 80 a7 60 04 cmp %i5, 4
200a3f0: 12 bf ff f8 bne 200a3d0 <rtems_iterate_over_all_threads+0x18>
200a3f4: 83 2f 60 02 sll %i5, 2, %g1
200a3f8: 81 c7 e0 08 ret
200a3fc: 81 e8 00 00 restore
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
200a400: 83 2f 20 02 sll %i4, 2, %g1
200a404: d0 00 80 01 ld [ %g2 + %g1 ], %o0
if ( !the_thread )
200a408: 80 a2 20 00 cmp %o0, 0
200a40c: 02 80 00 04 be 200a41c <rtems_iterate_over_all_threads+0x64>
200a410: b8 07 20 01 inc %i4
continue;
(*routine)(the_thread);
200a414: 9f c6 00 00 call %i0
200a418: 01 00 00 00 nop
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
200a41c: c2 16 e0 10 lduh [ %i3 + 0x10 ], %g1
200a420: 80 a7 00 01 cmp %i4, %g1
200a424: 28 bf ff f7 bleu,a 200a400 <rtems_iterate_over_all_threads+0x48>
200a428: c4 06 e0 1c ld [ %i3 + 0x1c ], %g2
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
200a42c: 10 bf ff f0 b 200a3ec <rtems_iterate_over_all_threads+0x34>
200a430: ba 07 60 01 inc %i5
020036fc <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 )
{
20036fc: 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)
2003700: 03 00 80 72 sethi %hi(0x201c800), %g1
2003704: fa 00 61 f4 ld [ %g1 + 0x1f4 ], %i5 ! 201c9f4 <rtems_libio_number_iops>
2003708: 80 a7 60 00 cmp %i5, 0
200370c: 02 80 00 1b be 2003778 <rtems_libio_init+0x7c> <== NEVER TAKEN
2003710: 11 13 10 92 sethi %hi(0x4c424800), %o0
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
2003714: 90 10 00 1d mov %i5, %o0
2003718: 7f ff fe f3 call 20032e4 <calloc>
200371c: 92 10 20 38 mov 0x38, %o1
2003720: 03 00 80 75 sethi %hi(0x201d400), %g1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
2003724: 80 a2 20 00 cmp %o0, 0
2003728: 12 80 00 04 bne 2003738 <rtems_libio_init+0x3c>
200372c: d0 20 60 44 st %o0, [ %g1 + 0x44 ]
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
2003730: 10 80 00 1c b 20037a0 <rtems_libio_init+0xa4>
2003734: 90 10 20 1a mov 0x1a, %o0
iop = rtems_libio_iop_freelist = rtems_libio_iops;
2003738: 03 00 80 75 sethi %hi(0x201d400), %g1
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
200373c: 84 10 00 08 mov %o0, %g2
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
2003740: d0 20 60 48 st %o0, [ %g1 + 0x48 ]
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
2003744: 10 80 00 03 b 2003750 <rtems_libio_init+0x54>
2003748: 82 10 20 00 clr %g1
iop->data1 = iop + 1;
200374c: c4 20 bf f8 st %g2, [ %g2 + -8 ]
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
2003750: 82 00 60 01 inc %g1
2003754: 80 a0 40 1d cmp %g1, %i5
2003758: 12 bf ff fd bne 200374c <rtems_libio_init+0x50>
200375c: 84 00 a0 38 add %g2, 0x38, %g2
iop->data1 = iop + 1;
iop->data1 = NULL;
2003760: 85 28 60 03 sll %g1, 3, %g2
2003764: 83 28 60 06 sll %g1, 6, %g1
2003768: 82 20 40 02 sub %g1, %g2, %g1
200376c: 90 02 00 01 add %o0, %g1, %o0
2003770: c0 22 3f f8 clr [ %o0 + -8 ]
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
2003774: 11 13 10 92 sethi %hi(0x4c424800), %o0
2003778: 92 10 20 01 mov 1, %o1
200377c: 90 12 21 4f or %o0, 0x14f, %o0
2003780: 94 10 20 54 mov 0x54, %o2
2003784: 96 10 20 00 clr %o3
2003788: 19 00 80 75 sethi %hi(0x201d400), %o4
200378c: 40 00 0f 31 call 2007450 <rtems_semaphore_create>
2003790: 98 13 20 4c or %o4, 0x4c, %o4 ! 201d44c <rtems_libio_semaphore>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
2003794: 80 a2 20 00 cmp %o0, 0
2003798: 02 80 00 04 be 20037a8 <rtems_libio_init+0xac> <== ALWAYS TAKEN
200379c: 03 00 80 72 sethi %hi(0x201c800), %g1
rtems_fatal_error_occurred( rc );
20037a0: 40 00 11 a6 call 2007e38 <rtems_fatal_error_occurred>
20037a4: 01 00 00 00 nop
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
20037a8: c2 00 61 f8 ld [ %g1 + 0x1f8 ], %g1
20037ac: 80 a0 60 00 cmp %g1, 0
20037b0: 02 80 00 04 be 20037c0 <rtems_libio_init+0xc4>
20037b4: 01 00 00 00 nop
(* rtems_fs_init_helper)();
20037b8: 9f c0 40 00 call %g1
20037bc: 01 00 00 00 nop
20037c0: 81 c7 e0 08 ret
20037c4: 81 e8 00 00 restore
02004678 <rtems_libio_set_private_env>:
}
rtems_status_code rtems_libio_set_private_env(void)
{
2004678: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
200467c: 40 00 05 d9 call 2005de0 <rtems_task_self>
2004680: 01 00 00 00 nop
rtems_user_env_t *old_env = rtems_current_user_env;
2004684: 03 00 80 48 sethi %hi(0x2012000), %g1
2004688: f8 00 61 dc ld [ %g1 + 0x1dc ], %i4 ! 20121dc <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;
200468c: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
if (uses_global_env || uses_shared_env) {
2004690: 80 a0 40 08 cmp %g1, %o0
2004694: 12 80 00 07 bne 20046b0 <rtems_libio_set_private_env+0x38>
2004698: b6 10 00 08 mov %o0, %i3
200469c: 03 00 80 48 sethi %hi(0x2012000), %g1
20046a0: 82 10 61 e0 or %g1, 0x1e0, %g1 ! 20121e0 <rtems_global_user_env>
20046a4: 80 a7 00 01 cmp %i4, %g1
20046a8: 12 80 00 2b bne 2004754 <rtems_libio_set_private_env+0xdc><== ALWAYS TAKEN
20046ac: b0 10 20 00 clr %i0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
20046b0: 90 10 20 01 mov 1, %o0
20046b4: 92 10 20 2c mov 0x2c, %o1
20046b8: 40 00 13 7e call 20094b0 <calloc>
20046bc: b0 10 20 1a mov 0x1a, %i0
if (new_env != NULL) {
20046c0: 80 a2 20 00 cmp %o0, 0
20046c4: 02 80 00 24 be 2004754 <rtems_libio_set_private_env+0xdc>
20046c8: ba 10 00 08 mov %o0, %i5
*new_env = *old_env;
20046cc: 92 10 00 1c mov %i4, %o1
20046d0: 40 00 1f 0a call 200c2f8 <memcpy>
20046d4: 94 10 20 2c mov 0x2c, %o2
new_env->reference_count = 1;
20046d8: 82 10 20 01 mov 1, %g1
new_env->task_id = self_task_id;
20046dc: f6 27 60 24 st %i3, [ %i5 + 0x24 ]
if (uses_global_env || uses_shared_env) {
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
if (new_env != NULL) {
*new_env = *old_env;
new_env->reference_count = 1;
20046e0: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
new_env->task_id = self_task_id;
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
20046e4: 40 00 02 d4 call 2005234 <rtems_filesystem_global_location_obtain>
20046e8: 90 07 20 04 add %i4, 4, %o0
if (new_env != NULL) {
*new_env = *old_env;
new_env->reference_count = 1;
new_env->task_id = self_task_id;
new_env->root_directory =
20046ec: d0 27 60 04 st %o0, [ %i5 + 4 ]
rtems_filesystem_global_location_obtain(&old_env->root_directory);
new_env->current_directory =
rtems_filesystem_global_location_obtain(&old_env->current_directory);
20046f0: 40 00 02 d1 call 2005234 <rtems_filesystem_global_location_obtain>
20046f4: 90 10 00 1c mov %i4, %o0
static inline bool rtems_filesystem_location_is_null(
const rtems_filesystem_location_info_t *loc
)
{
return loc->handlers == &rtems_filesystem_null_handlers;
20046f8: c2 07 60 04 ld [ %i5 + 4 ], %g1
*new_env = *old_env;
new_env->reference_count = 1;
new_env->task_id = self_task_id;
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
new_env->current_directory =
20046fc: d0 27 40 00 st %o0, [ %i5 ]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
if (
2004700: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
2004704: 03 00 80 46 sethi %hi(0x2011800), %g1
2004708: 82 10 62 b4 or %g1, 0x2b4, %g1 ! 2011ab4 <rtems_filesystem_null_handlers>
200470c: 80 a0 80 01 cmp %g2, %g1
2004710: 22 80 00 14 be,a 2004760 <rtems_libio_set_private_env+0xe8>
2004714: 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)
2004718: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
200471c: 80 a0 80 01 cmp %g2, %g1
2004720: 02 80 00 0f be 200475c <rtems_libio_set_private_env+0xe4> <== NEVER TAKEN
2004724: 90 10 20 00 clr %o0
) {
sc = rtems_task_variable_add(
2004728: 37 00 80 48 sethi %hi(0x2012000), %i3
200472c: 15 00 80 11 sethi %hi(0x2004400), %o2
2004730: 92 16 e1 dc or %i3, 0x1dc, %o1
2004734: 40 00 05 cb call 2005e60 <rtems_task_variable_add>
2004738: 94 12 a2 08 or %o2, 0x208, %o2
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
200473c: b0 92 20 00 orcc %o0, 0, %i0
2004740: 32 80 00 08 bne,a 2004760 <rtems_libio_set_private_env+0xe8>
2004744: b0 10 20 05 mov 5, %i0
free_user_env_protected(old_env);
2004748: 7f ff ff c3 call 2004654 <free_user_env_protected>
200474c: 90 10 00 1c mov %i4, %o0
rtems_current_user_env = new_env;
2004750: fa 26 e1 dc st %i5, [ %i3 + 0x1dc ]
2004754: 81 c7 e0 08 ret
2004758: 81 e8 00 00 restore
200475c: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
} else {
sc = RTEMS_UNSATISFIED;
}
if (sc != RTEMS_SUCCESSFUL) {
free_user_env(new_env);
2004760: 7f ff ff aa call 2004608 <free_user_env>
2004764: 90 10 00 1d mov %i5, %o0
sc = RTEMS_NO_MEMORY;
}
}
return sc;
}
2004768: 81 c7 e0 08 ret
200476c: 81 e8 00 00 restore
02004770 <rtems_libio_share_private_env>:
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
2004770: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
2004774: 40 00 05 9b call 2005de0 <rtems_task_self>
2004778: 01 00 00 00 nop
if (task_id != RTEMS_SELF && self_task_id != task_id) {
200477c: 80 a2 00 18 cmp %o0, %i0
2004780: 22 80 00 26 be,a 2004818 <rtems_libio_share_private_env+0xa8>
2004784: b0 10 20 00 clr %i0
2004788: 80 a6 20 00 cmp %i0, 0
200478c: 22 80 00 23 be,a 2004818 <rtems_libio_share_private_env+0xa8>
2004790: b0 10 20 00 clr %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;
2004794: 03 00 80 4a sethi %hi(0x2012800), %g1
2004798: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 ! 2012b30 <_Thread_Dispatch_disable_level>
++level;
200479c: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
20047a0: c4 20 63 30 st %g2, [ %g1 + 0x330 ]
/*
* We have to disable the thread dispatching to prevent deletion of the
* environment in the meantime.
*/
_Thread_Disable_dispatch();
sc = rtems_task_variable_get(
20047a4: 13 00 80 48 sethi %hi(0x2012000), %o1
20047a8: 90 10 00 18 mov %i0, %o0
20047ac: 92 12 61 dc or %o1, 0x1dc, %o1
20047b0: 40 00 05 fc call 2005fa0 <rtems_task_variable_get>
20047b4: 94 07 bf fc add %fp, -4, %o2
task_id,
(void *) &rtems_current_user_env,
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
20047b8: b0 92 20 00 orcc %o0, 0, %i0
20047bc: 32 80 00 06 bne,a 20047d4 <rtems_libio_share_private_env+0x64>
20047c0: b0 10 20 0d mov 0xd, %i0
++env->reference_count;
20047c4: c2 07 bf fc ld [ %fp + -4 ], %g1
20047c8: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
20047cc: 84 00 a0 01 inc %g2
20047d0: c4 20 60 28 st %g2, [ %g1 + 0x28 ]
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
20047d4: 40 00 0d fa call 2007fbc <_Thread_Enable_dispatch>
20047d8: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
20047dc: 80 a6 20 00 cmp %i0, 0
20047e0: 12 80 00 0e bne 2004818 <rtems_libio_share_private_env+0xa8>
20047e4: 90 10 20 00 clr %o0
sc = rtems_task_variable_add(
20047e8: 3b 00 80 48 sethi %hi(0x2012000), %i5
20047ec: 15 00 80 11 sethi %hi(0x2004400), %o2
20047f0: 92 17 61 dc or %i5, 0x1dc, %o1
20047f4: 40 00 05 9b call 2005e60 <rtems_task_variable_add>
20047f8: 94 12 a2 08 or %o2, 0x208, %o2
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
20047fc: b0 92 20 00 orcc %o0, 0, %i0
2004800: 12 80 00 08 bne 2004820 <rtems_libio_share_private_env+0xb0><== NEVER TAKEN
2004804: d0 07 bf fc ld [ %fp + -4 ], %o0
free_user_env_protected(rtems_current_user_env);
2004808: 7f ff ff 93 call 2004654 <free_user_env_protected>
200480c: d0 07 61 dc ld [ %i5 + 0x1dc ], %o0
rtems_current_user_env = env;
2004810: c2 07 bf fc ld [ %fp + -4 ], %g1
2004814: c2 27 61 dc st %g1, [ %i5 + 0x1dc ]
2004818: 81 c7 e0 08 ret
200481c: 81 e8 00 00 restore
} else {
free_user_env_protected(env);
2004820: 7f ff ff 8d call 2004654 <free_user_env_protected> <== NOT EXECUTED
2004824: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2004828: 81 c7 e0 08 ret <== NOT EXECUTED
200482c: 81 e8 00 00 restore <== NOT EXECUTED
0200bf60 <rtems_libio_to_fcntl_flags>:
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
200bf60: 84 0a 20 06 and %o0, 6, %g2
return flags;
}
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
200bf64: 82 10 00 08 mov %o0, %g1
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
200bf68: 80 a0 a0 06 cmp %g2, 6
200bf6c: 02 80 00 07 be 200bf88 <rtems_libio_to_fcntl_flags+0x28>
200bf70: 90 10 20 02 mov 2, %o0
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
200bf74: 80 88 60 02 btst 2, %g1
200bf78: 12 80 00 04 bne 200bf88 <rtems_libio_to_fcntl_flags+0x28> <== ALWAYS TAKEN
200bf7c: 90 10 20 00 clr %o0
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
200bf80: 91 30 60 02 srl %g1, 2, %o0 <== NOT EXECUTED
200bf84: 90 0a 20 01 and %o0, 1, %o0 <== NOT EXECUTED
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
200bf88: 80 88 60 01 btst 1, %g1
200bf8c: 02 80 00 04 be 200bf9c <rtems_libio_to_fcntl_flags+0x3c>
200bf90: 80 88 62 00 btst 0x200, %g1
fcntl_flags |= O_NONBLOCK;
200bf94: 05 00 00 10 sethi %hi(0x4000), %g2
200bf98: 90 12 00 02 or %o0, %g2, %o0
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
200bf9c: 32 80 00 02 bne,a 200bfa4 <rtems_libio_to_fcntl_flags+0x44>
200bfa0: 90 12 20 08 or %o0, 8, %o0
fcntl_flags |= O_APPEND;
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
200bfa4: 80 88 64 00 btst 0x400, %g1
200bfa8: 32 80 00 02 bne,a 200bfb0 <rtems_libio_to_fcntl_flags+0x50>
200bfac: 90 12 22 00 or %o0, 0x200, %o0
fcntl_flags |= O_CREAT;
}
return fcntl_flags;
}
200bfb0: 81 c3 e0 08 retl
02004830 <rtems_libio_use_global_env>:
return sc;
}
void rtems_libio_use_global_env(void)
{
2004830: 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) {
2004834: 3b 00 80 48 sethi %hi(0x2012000), %i5
2004838: c2 07 61 dc ld [ %i5 + 0x1dc ], %g1 ! 20121dc <rtems_current_user_env>
200483c: 39 00 80 48 sethi %hi(0x2012000), %i4
2004840: b8 17 21 e0 or %i4, 0x1e0, %i4 ! 20121e0 <rtems_global_user_env>
2004844: 80 a0 40 1c cmp %g1, %i4
2004848: 02 80 00 0a be 2004870 <rtems_libio_use_global_env+0x40>
200484c: 92 17 61 dc or %i5, 0x1dc, %o1
sc = rtems_task_variable_delete(
2004850: 40 00 05 af call 2005f0c <rtems_task_variable_delete>
2004854: 90 10 20 00 clr %o0
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
2004858: 80 a2 20 00 cmp %o0, 0
200485c: 22 80 00 05 be,a 2004870 <rtems_libio_use_global_env+0x40><== ALWAYS TAKEN
2004860: f8 27 61 dc st %i4, [ %i5 + 0x1dc ]
rtems_fatal_error_occurred(0xdeadbeef);
2004864: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
2004868: 40 00 06 5d call 20061dc <rtems_fatal_error_occurred> <== NOT EXECUTED
200486c: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
2004870: 81 c7 e0 08 ret
2004874: 81 e8 00 00 restore
02006fec <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
2006fec: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
2006ff0: 03 00 80 8b sethi %hi(0x2022c00), %g1
2006ff4: d0 00 62 84 ld [ %g1 + 0x284 ], %o0 ! 2022e84 <RTEMS_Malloc_Heap>
2006ff8: 92 10 00 18 mov %i0, %o1
2006ffc: 40 00 1b 1b call 200dc68 <_Protected_heap_Get_block_size>
2007000: 94 07 bf fc add %fp, -4, %o2
2007004: 80 8a 20 ff btst 0xff, %o0
2007008: 02 80 00 08 be 2007028 <rtems_malloc_statistics_at_free+0x3c><== NEVER TAKEN
200700c: 03 00 80 90 sethi %hi(0x2024000), %g1
MSBUMP(lifetime_freed, size);
2007010: c8 07 bf fc ld [ %fp + -4 ], %g4
2007014: 82 10 62 00 or %g1, 0x200, %g1
2007018: c4 18 60 28 ldd [ %g1 + 0x28 ], %g2
200701c: 86 80 c0 04 addcc %g3, %g4, %g3
2007020: 84 40 a0 00 addx %g2, 0, %g2
2007024: c4 38 60 28 std %g2, [ %g1 + 0x28 ]
2007028: 81 c7 e0 08 ret
200702c: 81 e8 00 00 restore
02007030 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
2007030: 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 )
2007034: 80 a6 20 00 cmp %i0, 0
2007038: 02 80 00 14 be 2007088 <rtems_malloc_statistics_at_malloc+0x58><== NEVER TAKEN
200703c: c0 27 bf fc clr [ %fp + -4 ]
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
2007040: 03 00 80 8b sethi %hi(0x2022c00), %g1
2007044: d0 00 62 84 ld [ %g1 + 0x284 ], %o0 ! 2022e84 <RTEMS_Malloc_Heap>
2007048: 92 10 00 18 mov %i0, %o1
200704c: 40 00 1b 07 call 200dc68 <_Protected_heap_Get_block_size>
2007050: 94 07 bf fc add %fp, -4, %o2
MSBUMP(lifetime_allocated, actual_size);
2007054: 03 00 80 90 sethi %hi(0x2024000), %g1
2007058: c8 07 bf fc ld [ %fp + -4 ], %g4
200705c: 82 10 62 00 or %g1, 0x200, %g1
2007060: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
2007064: 86 80 c0 04 addcc %g3, %g4, %g3
2007068: 84 40 a0 00 addx %g2, 0, %g2
200706c: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
2007070: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
2007074: 84 20 c0 02 sub %g3, %g2, %g2
if (current_depth > s->max_depth)
2007078: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
200707c: 80 a0 80 03 cmp %g2, %g3
2007080: 38 80 00 02 bgu,a 2007088 <rtems_malloc_statistics_at_malloc+0x58>
2007084: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
2007088: 81 c7 e0 08 ret
200708c: 81 e8 00 00 restore
020102ac <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
20102ac: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
20102b0: ba 96 20 00 orcc %i0, 0, %i5
20102b4: 12 80 00 04 bne 20102c4 <rtems_memalign+0x18>
20102b8: 03 00 80 87 sethi %hi(0x2021c00), %g1
return EINVAL;
20102bc: 81 c7 e0 08 ret
20102c0: 91 e8 20 16 restore %g0, 0x16, %o0
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
20102c4: c2 00 63 08 ld [ %g1 + 0x308 ], %g1
20102c8: 80 a0 60 03 cmp %g1, 3
20102cc: 02 80 00 0f be 2010308 <rtems_memalign+0x5c>
20102d0: c0 27 40 00 clr [ %i5 ]
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
20102d4: 7f ff d2 51 call 2004c18 <malloc_deferred_frees_process>
20102d8: b0 10 20 0c mov 0xc, %i0
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
20102dc: 03 00 80 83 sethi %hi(0x2020c00), %g1
20102e0: d0 00 61 28 ld [ %g1 + 0x128 ], %o0 ! 2020d28 <RTEMS_Malloc_Heap>
20102e4: 92 10 00 1a mov %i2, %o1
20102e8: 94 10 00 19 mov %i1, %o2
20102ec: 7f ff e9 58 call 200a84c <_Protected_heap_Allocate_aligned_with_boundary>
20102f0: 96 10 20 00 clr %o3
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
20102f4: 80 a2 20 00 cmp %o0, 0
20102f8: 12 80 00 0a bne 2010320 <rtems_memalign+0x74>
20102fc: b8 10 00 08 mov %o0, %i4
2010300: 81 c7 e0 08 ret
2010304: 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() )
2010308: 7f ff d2 38 call 2004be8 <malloc_is_system_state_OK>
201030c: 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()) &&
2010310: 80 8a 20 ff btst 0xff, %o0
2010314: 02 bf ff ea be 20102bc <rtems_memalign+0x10> <== NEVER TAKEN
2010318: 01 00 00 00 nop
201031c: 30 bf ff ee b,a 20102d4 <rtems_memalign+0x28>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
2010320: 03 00 80 85 sethi %hi(0x2021400), %g1
2010324: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 2021500 <rtems_malloc_statistics_helpers>
2010328: 80 a0 60 00 cmp %g1, 0
201032c: 22 80 00 06 be,a 2010344 <rtems_memalign+0x98>
2010330: f8 27 40 00 st %i4, [ %i5 ]
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
2010334: c2 00 60 04 ld [ %g1 + 4 ], %g1
2010338: 9f c0 40 00 call %g1
201033c: 90 10 00 1d mov %i5, %o0
*pointer = return_this;
2010340: f8 27 40 00 st %i4, [ %i5 ]
return 0;
}
2010344: 81 c7 e0 08 ret
2010348: 91 e8 20 00 restore %g0, 0, %o0
02009418 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
2009418: 9d e3 bf 58 save %sp, -168, %sp
int success = 0;
char *dup_path = strdup(path);
200941c: 40 00 65 ae call 2022ad4 <strdup>
2009420: 90 10 00 18 mov %i0, %o0
if (dup_path != NULL) {
2009424: b6 92 20 00 orcc %o0, 0, %i3
2009428: 32 80 00 04 bne,a 2009438 <rtems_mkdir+0x20>
200942c: c2 4e c0 00 ldsb [ %i3 ], %g1
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
2009430: 81 c7 e0 08 ret
2009434: 91 e8 3f ff restore %g0, -1, %o0
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
2009438: b8 10 20 01 mov 1, %i4
++p;
200943c: 82 18 60 2f xor %g1, 0x2f, %g1
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
2009440: b0 10 20 00 clr %i0
++p;
2009444: 80 a0 00 01 cmp %g0, %g1
retval = 0;
break;
}
}
if (!last)
*p = '/';
2009448: a0 10 20 2f mov 0x2f, %l0
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
200944c: b4 66 ff ff subx %i3, -1, %i2
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
2009450: 82 10 20 01 mov 1, %g1
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
2009454: 23 00 00 3c sethi %hi(0xf000), %l1
2009458: 25 00 00 10 sethi %hi(0x4000), %l2
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
200945c: c6 4e 80 00 ldsb [ %i2 ], %g3
2009460: 80 a0 e0 00 cmp %g3, 0
2009464: 22 80 00 07 be,a 2009480 <rtems_mkdir+0x68>
2009468: 84 10 20 01 mov 1, %g2
last = 1;
else if (p[0] != '/')
200946c: 80 a0 e0 2f cmp %g3, 0x2f
2009470: 12 80 00 4f bne 20095ac <rtems_mkdir+0x194>
2009474: 84 10 20 00 clr %g2
continue;
*p = '\0';
2009478: 10 80 00 03 b 2009484 <rtems_mkdir+0x6c>
200947c: c0 2e 80 00 clrb [ %i2 ]
2009480: c0 2e 80 00 clrb [ %i2 ]
if (!last && p[1] == '\0')
2009484: 80 a0 a0 00 cmp %g2, 0
2009488: 12 80 00 05 bne 200949c <rtems_mkdir+0x84>
200948c: ba 10 20 01 mov 1, %i5
2009490: c4 4e a0 01 ldsb [ %i2 + 1 ], %g2
2009494: 80 a0 00 02 cmp %g0, %g2
2009498: ba 60 3f ff subx %g0, -1, %i5
last = 1;
if (first) {
200949c: 80 a0 60 00 cmp %g1, 0
20094a0: 02 80 00 08 be 20094c0 <rtems_mkdir+0xa8>
20094a4: 80 a7 60 00 cmp %i5, 0
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
20094a8: 40 00 0a 28 call 200bd48 <umask>
20094ac: 90 10 20 00 clr %o0
20094b0: b0 10 00 08 mov %o0, %i0
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
20094b4: 40 00 0a 25 call 200bd48 <umask>
20094b8: 90 0a 3f 3f and %o0, -193, %o0
first = 0;
}
if (last)
20094bc: 80 a7 60 00 cmp %i5, 0
20094c0: 02 80 00 05 be 20094d4 <rtems_mkdir+0xbc>
20094c4: 92 10 21 ff mov 0x1ff, %o1
(void)umask(oumask);
20094c8: 40 00 0a 20 call 200bd48 <umask>
20094cc: 90 10 00 18 mov %i0, %o0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
20094d0: 92 10 00 19 mov %i1, %o1
20094d4: 7f ff fc 94 call 2008724 <mkdir>
20094d8: 90 10 00 1b mov %i3, %o0
20094dc: 80 a2 20 00 cmp %o0, 0
20094e0: 16 80 00 2d bge 2009594 <rtems_mkdir+0x17c>
20094e4: 80 a7 60 00 cmp %i5, 0
if (errno == EEXIST || errno == EISDIR) {
20094e8: 40 00 5d 4e call 2020a20 <__errno>
20094ec: 01 00 00 00 nop
20094f0: c2 02 00 00 ld [ %o0 ], %g1
20094f4: 80 a0 60 11 cmp %g1, 0x11
20094f8: 12 80 00 09 bne 200951c <rtems_mkdir+0x104>
20094fc: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
2009500: 40 00 00 3d call 20095f4 <stat>
2009504: 92 07 bf b8 add %fp, -72, %o1
2009508: 80 a2 20 00 cmp %o0, 0
200950c: 16 80 00 0c bge 200953c <rtems_mkdir+0x124> <== ALWAYS TAKEN
2009510: c2 07 bf c4 ld [ %fp + -60 ], %g1
retval = 0;
2009514: 10 80 00 2b b 20095c0 <rtems_mkdir+0x1a8> <== NOT EXECUTED
2009518: b8 10 20 00 clr %i4 <== NOT EXECUTED
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
200951c: 40 00 5d 41 call 2020a20 <__errno>
2009520: 01 00 00 00 nop
2009524: c2 02 00 00 ld [ %o0 ], %g1
2009528: 80 a0 60 15 cmp %g1, 0x15
200952c: 02 bf ff f5 be 2009500 <rtems_mkdir+0xe8> <== NEVER TAKEN
2009530: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
retval = 0;
2009534: 10 80 00 23 b 20095c0 <rtems_mkdir+0x1a8>
2009538: b8 10 20 00 clr %i4
break;
} else if (!S_ISDIR(sb.st_mode)) {
200953c: 82 08 40 11 and %g1, %l1, %g1
2009540: 80 a0 40 12 cmp %g1, %l2
2009544: 02 80 00 0f be 2009580 <rtems_mkdir+0x168>
2009548: 80 a7 60 00 cmp %i5, 0
if (last)
200954c: 02 80 00 08 be 200956c <rtems_mkdir+0x154>
2009550: 01 00 00 00 nop
errno = EEXIST;
2009554: 40 00 5d 33 call 2020a20 <__errno>
2009558: b8 10 20 00 clr %i4 ! 0 <PROM_START>
200955c: 82 10 20 11 mov 0x11, %g1
2009560: c2 22 00 00 st %g1, [ %o0 ]
2009564: 10 80 00 17 b 20095c0 <rtems_mkdir+0x1a8>
2009568: ba 10 20 01 mov 1, %i5
else
errno = ENOTDIR;
200956c: 40 00 5d 2d call 2020a20 <__errno>
2009570: b8 10 20 00 clr %i4
2009574: 82 10 20 14 mov 0x14, %g1
2009578: 10 80 00 12 b 20095c0 <rtems_mkdir+0x1a8>
200957c: c2 22 00 00 st %g1, [ %o0 ]
retval = 0;
break;
}
if (last)
2009580: 32 80 00 09 bne,a 20095a4 <rtems_mkdir+0x18c>
2009584: b8 10 20 02 mov 2, %i4
retval = 0;
break;
}
}
if (!last)
*p = '/';
2009588: e0 2e 80 00 stb %l0, [ %i2 ]
200958c: 10 80 00 07 b 20095a8 <rtems_mkdir+0x190>
2009590: 84 10 20 00 clr %g2
} else {
retval = 0;
break;
}
}
if (!last)
2009594: 22 bf ff fe be,a 200958c <rtems_mkdir+0x174>
2009598: e0 2e 80 00 stb %l0, [ %i2 ]
else
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
200959c: 10 80 00 03 b 20095a8 <rtems_mkdir+0x190>
20095a0: 84 10 20 01 mov 1, %g2
20095a4: 84 10 20 01 mov 1, %g2
20095a8: 82 10 20 00 clr %g1
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
20095ac: 80 a0 a0 00 cmp %g2, 0
20095b0: 02 bf ff ab be 200945c <rtems_mkdir+0x44>
20095b4: b4 06 a0 01 inc %i2
20095b8: 10 80 00 03 b 20095c4 <rtems_mkdir+0x1ac>
20095bc: ba 10 20 01 mov 1, %i5
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
20095c0: 82 10 20 00 clr %g1
}
}
if (!last)
*p = '/';
}
if (!first && !last)
20095c4: 80 97 40 01 orcc %i5, %g1, %g0
20095c8: 12 80 00 04 bne 20095d8 <rtems_mkdir+0x1c0>
20095cc: 01 00 00 00 nop
(void)umask(oumask);
20095d0: 40 00 09 de call 200bd48 <umask>
20095d4: 90 10 00 18 mov %i0, %o0
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
20095d8: 7f ff fa 83 call 2007fe4 <free>
20095dc: 90 10 00 1b mov %i3, %o0
}
return success != 0 ? 0 : -1;
20095e0: 80 a7 20 00 cmp %i4, 0
20095e4: 02 bf ff 93 be 2009430 <rtems_mkdir+0x18>
20095e8: 01 00 00 00 nop
}
20095ec: 81 c7 e0 08 ret
20095f0: 91 e8 20 00 restore %g0, 0, %o0
02008b84 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
2008b84: 9d e3 bf a0 save %sp, -96, %sp
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
2008b88: 80 a6 20 00 cmp %i0, 0
2008b8c: 02 80 00 38 be 2008c6c <rtems_partition_create+0xe8>
2008b90: 82 10 20 03 mov 3, %g1
return RTEMS_INVALID_NAME;
if ( !starting_address )
2008b94: 80 a6 60 00 cmp %i1, 0
2008b98: 02 80 00 35 be 2008c6c <rtems_partition_create+0xe8>
2008b9c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !id )
2008ba0: 80 a7 60 00 cmp %i5, 0
2008ba4: 02 80 00 32 be 2008c6c <rtems_partition_create+0xe8> <== NEVER TAKEN
2008ba8: 80 a6 e0 00 cmp %i3, 0
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
2008bac: 02 80 00 30 be 2008c6c <rtems_partition_create+0xe8>
2008bb0: 82 10 20 08 mov 8, %g1
2008bb4: 80 a6 a0 00 cmp %i2, 0
2008bb8: 02 80 00 2d be 2008c6c <rtems_partition_create+0xe8>
2008bbc: 80 a6 80 1b cmp %i2, %i3
2008bc0: 0a 80 00 2b bcs 2008c6c <rtems_partition_create+0xe8>
2008bc4: 80 8e e0 07 btst 7, %i3
2008bc8: 12 80 00 29 bne 2008c6c <rtems_partition_create+0xe8>
2008bcc: 80 8e 60 07 btst 7, %i1
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
2008bd0: 12 80 00 27 bne 2008c6c <rtems_partition_create+0xe8>
2008bd4: 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;
2008bd8: 03 00 80 88 sethi %hi(0x2022000), %g1
2008bdc: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2022090 <_Thread_Dispatch_disable_level>
++level;
2008be0: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2008be4: c4 20 60 90 st %g2, [ %g1 + 0x90 ]
* 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 );
2008be8: 23 00 80 87 sethi %hi(0x2021c00), %l1
2008bec: 40 00 07 08 call 200a80c <_Objects_Allocate>
2008bf0: 90 14 62 8c or %l1, 0x28c, %o0 ! 2021e8c <_Partition_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
2008bf4: a0 92 20 00 orcc %o0, 0, %l0
2008bf8: 32 80 00 06 bne,a 2008c10 <rtems_partition_create+0x8c>
2008bfc: f8 24 20 1c st %i4, [ %l0 + 0x1c ]
_Thread_Enable_dispatch();
2008c00: 40 00 0c 3a call 200bce8 <_Thread_Enable_dispatch>
2008c04: 01 00 00 00 nop
return RTEMS_TOO_MANY;
2008c08: 10 80 00 19 b 2008c6c <rtems_partition_create+0xe8>
2008c0c: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5>
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
2008c10: 92 10 00 1b mov %i3, %o1
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
2008c14: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
the_partition->length = length;
2008c18: f4 24 20 14 st %i2, [ %l0 + 0x14 ]
the_partition->buffer_size = buffer_size;
2008c1c: f6 24 20 18 st %i3, [ %l0 + 0x18 ]
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
2008c20: c0 24 20 20 clr [ %l0 + 0x20 ]
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
2008c24: 40 00 46 0e call 201a45c <.udiv>
2008c28: 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,
2008c2c: 92 10 00 19 mov %i1, %o1
length / buffer_size, buffer_size );
2008c30: 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,
2008c34: 96 10 00 1b mov %i3, %o3
2008c38: b8 04 20 24 add %l0, 0x24, %i4
2008c3c: 40 00 04 74 call 2009e0c <_Chain_Initialize>
2008c40: 90 10 00 1c mov %i4, %o0
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
2008c44: c4 14 20 0a lduh [ %l0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008c48: a2 14 62 8c or %l1, 0x28c, %l1
2008c4c: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
2008c50: c2 04 20 08 ld [ %l0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008c54: 85 28 a0 02 sll %g2, 2, %g2
2008c58: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
2008c5c: f0 24 20 0c st %i0, [ %l0 + 0xc ]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
2008c60: 40 00 0c 22 call 200bce8 <_Thread_Enable_dispatch>
2008c64: c2 27 40 00 st %g1, [ %i5 ]
return RTEMS_SUCCESSFUL;
2008c68: 82 10 20 00 clr %g1
}
2008c6c: 81 c7 e0 08 ret
2008c70: 91 e8 00 01 restore %g0, %g1, %o0
02016364 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
2016364: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
2016368: 11 00 80 f1 sethi %hi(0x203c400), %o0
201636c: 92 10 00 18 mov %i0, %o1
2016370: 90 12 23 ac or %o0, 0x3ac, %o0
2016374: 40 00 14 2b call 201b420 <_Objects_Get>
2016378: 94 07 bf fc add %fp, -4, %o2
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
201637c: c2 07 bf fc ld [ %fp + -4 ], %g1
2016380: 80 a0 60 00 cmp %g1, 0
2016384: 12 80 00 21 bne 2016408 <rtems_partition_return_buffer+0xa4>
2016388: ba 10 00 08 mov %o0, %i5
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
201638c: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
2016390: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2016394: 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 ) &&
2016398: 80 a6 40 01 cmp %i1, %g1
201639c: 18 80 00 0b bgu 20163c8 <rtems_partition_return_buffer+0x64><== NEVER TAKEN
20163a0: 82 10 20 00 clr %g1
20163a4: 80 a6 40 08 cmp %i1, %o0
20163a8: 0a 80 00 09 bcs 20163cc <rtems_partition_return_buffer+0x68>
20163ac: 80 a0 60 00 cmp %g1, 0
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
20163b0: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
20163b4: 40 00 58 13 call 202c400 <.urem>
20163b8: 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 ) &&
20163bc: 80 a0 00 08 cmp %g0, %o0
20163c0: 10 80 00 02 b 20163c8 <rtems_partition_return_buffer+0x64>
20163c4: 82 60 3f ff subx %g0, -1, %g1
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
20163c8: 80 a0 60 00 cmp %g1, 0
20163cc: 02 80 00 0b be 20163f8 <rtems_partition_return_buffer+0x94>
20163d0: 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 );
20163d4: 40 00 0c 98 call 2019634 <_Chain_Append>
20163d8: 92 10 00 19 mov %i1, %o1
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
20163dc: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
20163e0: 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;
20163e4: 82 00 7f ff add %g1, -1, %g1
_Thread_Enable_dispatch();
20163e8: 40 00 17 f0 call 201c3a8 <_Thread_Enable_dispatch>
20163ec: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
20163f0: 81 c7 e0 08 ret
20163f4: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
20163f8: 40 00 17 ec call 201c3a8 <_Thread_Enable_dispatch>
20163fc: b0 10 20 09 mov 9, %i0
2016400: 81 c7 e0 08 ret
2016404: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2016408: 81 c7 e0 08 ret
201640c: 91 e8 20 04 restore %g0, 4, %o0
02033028 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
2033028: 9d e3 bf 98 save %sp, -104, %sp
203302c: 11 00 81 8a sethi %hi(0x2062800), %o0
2033030: 92 10 00 18 mov %i0, %o1
2033034: 90 12 23 24 or %o0, 0x324, %o0
2033038: 7f ff 57 6f call 2008df4 <_Objects_Get>
203303c: 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 ) {
2033040: c2 07 bf fc ld [ %fp + -4 ], %g1
2033044: 80 a0 60 00 cmp %g1, 0
2033048: 12 80 00 6a bne 20331f0 <rtems_rate_monotonic_period+0x1c8>
203304c: ba 10 00 08 mov %o0, %i5
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
2033050: 37 00 81 89 sethi %hi(0x2062400), %i3
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
2033054: c4 02 20 40 ld [ %o0 + 0x40 ], %g2
2033058: b6 16 e1 60 or %i3, 0x160, %i3
203305c: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
2033060: 80 a0 80 01 cmp %g2, %g1
2033064: 02 80 00 06 be 203307c <rtems_rate_monotonic_period+0x54>
2033068: 80 a6 60 00 cmp %i1, 0
_Thread_Enable_dispatch();
203306c: 7f ff 5b 1a call 2009cd4 <_Thread_Enable_dispatch>
2033070: b0 10 20 17 mov 0x17, %i0
2033074: 81 c7 e0 08 ret
2033078: 81 e8 00 00 restore
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
203307c: 12 80 00 0d bne 20330b0 <rtems_rate_monotonic_period+0x88>
2033080: 01 00 00 00 nop
switch ( the_period->state ) {
2033084: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
2033088: 80 a0 60 04 cmp %g1, 4
203308c: 18 80 00 05 bgu 20330a0 <rtems_rate_monotonic_period+0x78><== NEVER TAKEN
2033090: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2033094: 05 00 81 6f sethi %hi(0x205bc00), %g2
2033098: 84 10 a1 90 or %g2, 0x190, %g2 ! 205bd90 <CSWTCH.24>
203309c: f0 08 80 01 ldub [ %g2 + %g1 ], %i0
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
20330a0: 7f ff 5b 0d call 2009cd4 <_Thread_Enable_dispatch>
20330a4: 01 00 00 00 nop
20330a8: 81 c7 e0 08 ret
20330ac: 81 e8 00 00 restore
return( return_value );
}
_ISR_Disable( level );
20330b0: 7f ff 3c a8 call 2002350 <sparc_disable_interrupts>
20330b4: 01 00 00 00 nop
20330b8: b4 10 00 08 mov %o0, %i2
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
20330bc: f8 07 60 38 ld [ %i5 + 0x38 ], %i4
20330c0: 80 a7 20 00 cmp %i4, 0
20330c4: 12 80 00 15 bne 2033118 <rtems_rate_monotonic_period+0xf0>
20330c8: 80 a7 20 02 cmp %i4, 2
_ISR_Enable( level );
20330cc: 7f ff 3c a5 call 2002360 <sparc_enable_interrupts>
20330d0: 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 );
20330d4: 90 10 00 1d mov %i5, %o0
20330d8: 7f ff ff b8 call 2032fb8 <_Rate_monotonic_Initiate_statistics>
20330dc: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
the_period->state = RATE_MONOTONIC_ACTIVE;
20330e0: 82 10 20 02 mov 2, %g1
20330e4: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20330e8: 03 00 80 cc sethi %hi(0x2033000), %g1
20330ec: 82 10 61 fc or %g1, 0x1fc, %g1 ! 20331fc <_Rate_monotonic_Timeout>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20330f0: c0 27 60 18 clr [ %i5 + 0x18 ]
the_watchdog->routine = routine;
20330f4: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
the_watchdog->id = id;
20330f8: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
the_watchdog->user_data = user_data;
20330fc: c0 27 60 34 clr [ %i5 + 0x34 ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2033100: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2033104: 11 00 81 88 sethi %hi(0x2062000), %o0
2033108: 92 07 60 10 add %i5, 0x10, %o1
203310c: 7f ff 5e 17 call 200a968 <_Watchdog_Insert>
2033110: 90 12 20 dc or %o0, 0xdc, %o0
2033114: 30 80 00 1b b,a 2033180 <rtems_rate_monotonic_period+0x158>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
2033118: 12 80 00 1e bne 2033190 <rtems_rate_monotonic_period+0x168>
203311c: 80 a7 20 04 cmp %i4, 4
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
2033120: 7f ff ff 5d call 2032e94 <_Rate_monotonic_Update_statistics>
2033124: 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;
2033128: 82 10 20 01 mov 1, %g1
the_period->next_length = length;
203312c: 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;
2033130: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
_ISR_Enable( level );
2033134: 7f ff 3c 8b call 2002360 <sparc_enable_interrupts>
2033138: 90 10 00 1a mov %i2, %o0
_Thread_Executing->Wait.id = the_period->Object.id;
203313c: d0 06 e0 10 ld [ %i3 + 0x10 ], %o0
2033140: c2 07 60 08 ld [ %i5 + 8 ], %g1
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
2033144: 13 00 00 10 sethi %hi(0x4000), %o1
2033148: 7f ff 5d 1b call 200a5b4 <_Thread_Set_state>
203314c: c2 22 20 20 st %g1, [ %o0 + 0x20 ]
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
2033150: 7f ff 3c 80 call 2002350 <sparc_disable_interrupts>
2033154: 01 00 00 00 nop
local_state = the_period->state;
2033158: f4 07 60 38 ld [ %i5 + 0x38 ], %i2
the_period->state = RATE_MONOTONIC_ACTIVE;
203315c: f8 27 60 38 st %i4, [ %i5 + 0x38 ]
_ISR_Enable( level );
2033160: 7f ff 3c 80 call 2002360 <sparc_enable_interrupts>
2033164: 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 )
2033168: 80 a6 a0 03 cmp %i2, 3
203316c: 12 80 00 05 bne 2033180 <rtems_rate_monotonic_period+0x158>
2033170: 01 00 00 00 nop
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
2033174: d0 06 e0 10 ld [ %i3 + 0x10 ], %o0
2033178: 7f ff 59 e9 call 200991c <_Thread_Clear_state>
203317c: 13 00 00 10 sethi %hi(0x4000), %o1
_Thread_Enable_dispatch();
2033180: 7f ff 5a d5 call 2009cd4 <_Thread_Enable_dispatch>
2033184: b0 10 20 00 clr %i0
2033188: 81 c7 e0 08 ret
203318c: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
2033190: 12 bf ff b9 bne 2033074 <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
2033194: b0 10 20 04 mov 4, %i0
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
2033198: 7f ff ff 3f call 2032e94 <_Rate_monotonic_Update_statistics>
203319c: 90 10 00 1d mov %i5, %o0
_ISR_Enable( level );
20331a0: 7f ff 3c 70 call 2002360 <sparc_enable_interrupts>
20331a4: 90 10 00 1a mov %i2, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
20331a8: 82 10 20 02 mov 2, %g1
20331ac: 92 07 60 10 add %i5, 0x10, %o1
20331b0: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
20331b4: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
20331b8: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
20331bc: 11 00 81 88 sethi %hi(0x2062000), %o0
20331c0: 7f ff 5d ea call 200a968 <_Watchdog_Insert>
20331c4: 90 12 20 dc or %o0, 0xdc, %o0 ! 20620dc <_Watchdog_Ticks_chain>
20331c8: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
20331cc: d2 07 60 3c ld [ %i5 + 0x3c ], %o1
20331d0: 03 00 81 77 sethi %hi(0x205dc00), %g1
20331d4: c2 00 61 04 ld [ %g1 + 0x104 ], %g1 ! 205dd04 <_Scheduler+0x34>
20331d8: 9f c0 40 00 call %g1
20331dc: 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();
20331e0: 7f ff 5a bd call 2009cd4 <_Thread_Enable_dispatch>
20331e4: 01 00 00 00 nop
20331e8: 81 c7 e0 08 ret
20331ec: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
20331f0: b0 10 20 04 mov 4, %i0
}
20331f4: 81 c7 e0 08 ret
20331f8: 81 e8 00 00 restore
020262f0 <rtems_rate_monotonic_report_statistics_with_plugin>:
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
20262f0: 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 )
20262f4: 80 a6 60 00 cmp %i1, 0
20262f8: 02 80 00 75 be 20264cc <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc><== NEVER TAKEN
20262fc: 90 10 00 18 mov %i0, %o0
return;
(*print)( context, "Period information by period\n" );
2026300: 13 00 81 63 sethi %hi(0x2058c00), %o1
2026304: 9f c6 40 00 call %i1
2026308: 92 12 63 e8 or %o1, 0x3e8, %o1 ! 2058fe8 <_TOD_Days_per_month+0x68>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
202630c: 90 10 00 18 mov %i0, %o0
2026310: 13 00 81 64 sethi %hi(0x2059000), %o1
2026314: 9f c6 40 00 call %i1
2026318: 92 12 60 08 or %o1, 8, %o1 ! 2059008 <_TOD_Days_per_month+0x88>
(*print)( context, "--- Wall times are in seconds ---\n" );
202631c: 90 10 00 18 mov %i0, %o0
2026320: 13 00 81 64 sethi %hi(0x2059000), %o1
2026324: 9f c6 40 00 call %i1
2026328: 92 12 60 30 or %o1, 0x30, %o1 ! 2059030 <_TOD_Days_per_month+0xb0>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
202632c: 90 10 00 18 mov %i0, %o0
2026330: 13 00 81 64 sethi %hi(0x2059000), %o1
2026334: 9f c6 40 00 call %i1
2026338: 92 12 60 58 or %o1, 0x58, %o1 ! 2059058 <_TOD_Days_per_month+0xd8>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
202633c: 90 10 00 18 mov %i0, %o0
2026340: 13 00 81 64 sethi %hi(0x2059000), %o1
2026344: 9f c6 40 00 call %i1
2026348: 92 12 60 a8 or %o1, 0xa8, %o1 ! 20590a8 <_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 ;
202634c: 03 00 81 8a sethi %hi(0x2062800), %g1
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
2026350: 39 00 81 64 sethi %hi(0x2059000), %i4
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
(*print)( context,
2026354: 37 00 81 64 sethi %hi(0x2059000), %i3
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
(*print)( context,
2026358: 35 00 81 64 sethi %hi(0x2059000), %i2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
202635c: 21 00 81 69 sethi %hi(0x205a400), %l0
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
2026360: fa 00 63 2c ld [ %g1 + 0x32c ], %i5
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
2026364: b8 17 20 f8 or %i4, 0xf8, %i4
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
(*print)( context,
2026368: b6 16 e1 10 or %i3, 0x110, %i3
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
(*print)( context,
202636c: b4 16 a1 30 or %i2, 0x130, %i2
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
2026370: 10 80 00 52 b 20264b8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
2026374: a0 14 21 b8 or %l0, 0x1b8, %l0
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
2026378: 40 00 31 e9 call 2032b1c <rtems_rate_monotonic_get_statistics>
202637c: 92 07 bf c8 add %fp, -56, %o1
if ( status != RTEMS_SUCCESSFUL )
2026380: 80 a2 20 00 cmp %o0, 0
2026384: 32 80 00 4d bne,a 20264b8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
2026388: ba 07 60 01 inc %i5
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
202638c: 92 07 bf b0 add %fp, -80, %o1
2026390: 40 00 32 54 call 2032ce0 <rtems_rate_monotonic_get_status>
2026394: 90 10 00 1d mov %i5, %o0
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
2026398: d0 07 bf b0 ld [ %fp + -80 ], %o0
202639c: 92 10 20 05 mov 5, %o1
20263a0: 7f ff a2 bc call 200ee90 <rtems_object_get_name>
20263a4: 94 07 bf a0 add %fp, -96, %o2
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
20263a8: d8 1f bf c8 ldd [ %fp + -56 ], %o4
20263ac: 92 10 00 1c mov %i4, %o1
20263b0: 90 10 00 18 mov %i0, %o0
20263b4: 94 10 00 1d mov %i5, %o2
20263b8: 9f c6 40 00 call %i1
20263bc: 96 07 bf a0 add %fp, -96, %o3
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
20263c0: d2 07 bf c8 ld [ %fp + -56 ], %o1
20263c4: 80 a2 60 00 cmp %o1, 0
20263c8: 12 80 00 07 bne 20263e4 <rtems_rate_monotonic_report_statistics_with_plugin+0xf4>
20263cc: 94 07 bf a8 add %fp, -88, %o2
(*print)( context, "\n" );
20263d0: 90 10 00 18 mov %i0, %o0
20263d4: 9f c6 40 00 call %i1
20263d8: 92 10 00 10 mov %l0, %o1
continue;
20263dc: 10 80 00 37 b 20264b8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
20263e0: ba 07 60 01 inc %i5
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
20263e4: 40 00 02 b7 call 2026ec0 <_Timespec_Divide_by_integer>
20263e8: 90 07 bf e0 add %fp, -32, %o0
(*print)( context,
20263ec: d0 07 bf d4 ld [ %fp + -44 ], %o0
20263f0: 40 00 a6 ac call 204fea0 <.div>
20263f4: 92 10 23 e8 mov 0x3e8, %o1
20263f8: a6 10 00 08 mov %o0, %l3
20263fc: d0 07 bf dc ld [ %fp + -36 ], %o0
2026400: 40 00 a6 a8 call 204fea0 <.div>
2026404: 92 10 23 e8 mov 0x3e8, %o1
2026408: c2 07 bf a8 ld [ %fp + -88 ], %g1
202640c: a2 10 00 08 mov %o0, %l1
2026410: d0 07 bf ac ld [ %fp + -84 ], %o0
2026414: e8 07 bf d0 ld [ %fp + -48 ], %l4
2026418: e4 07 bf d8 ld [ %fp + -40 ], %l2
202641c: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2026420: 40 00 a6 a0 call 204fea0 <.div>
2026424: 92 10 23 e8 mov 0x3e8, %o1
2026428: 96 10 00 13 mov %l3, %o3
202642c: 98 10 00 12 mov %l2, %o4
2026430: 9a 10 00 11 mov %l1, %o5
2026434: 94 10 00 14 mov %l4, %o2
2026438: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
202643c: 92 10 00 1b mov %i3, %o1
2026440: 9f c6 40 00 call %i1
2026444: 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);
2026448: d2 07 bf c8 ld [ %fp + -56 ], %o1
202644c: 94 07 bf a8 add %fp, -88, %o2
2026450: 40 00 02 9c call 2026ec0 <_Timespec_Divide_by_integer>
2026454: 90 07 bf f8 add %fp, -8, %o0
(*print)( context,
2026458: d0 07 bf ec ld [ %fp + -20 ], %o0
202645c: 40 00 a6 91 call 204fea0 <.div>
2026460: 92 10 23 e8 mov 0x3e8, %o1
2026464: a6 10 00 08 mov %o0, %l3
2026468: d0 07 bf f4 ld [ %fp + -12 ], %o0
202646c: 40 00 a6 8d call 204fea0 <.div>
2026470: 92 10 23 e8 mov 0x3e8, %o1
2026474: c2 07 bf a8 ld [ %fp + -88 ], %g1
2026478: a2 10 00 08 mov %o0, %l1
202647c: d0 07 bf ac ld [ %fp + -84 ], %o0
2026480: e8 07 bf e8 ld [ %fp + -24 ], %l4
2026484: e4 07 bf f0 ld [ %fp + -16 ], %l2
2026488: 92 10 23 e8 mov 0x3e8, %o1
202648c: 40 00 a6 85 call 204fea0 <.div>
2026490: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2026494: 92 10 00 1a mov %i2, %o1
2026498: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
202649c: 94 10 00 14 mov %l4, %o2
20264a0: 90 10 00 18 mov %i0, %o0
20264a4: 96 10 00 13 mov %l3, %o3
20264a8: 98 10 00 12 mov %l2, %o4
20264ac: 9f c6 40 00 call %i1
20264b0: 9a 10 00 11 mov %l1, %o5
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
20264b4: ba 07 60 01 inc %i5
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
20264b8: 03 00 81 8a sethi %hi(0x2062800), %g1
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
20264bc: c2 00 63 30 ld [ %g1 + 0x330 ], %g1 ! 2062b30 <_Rate_monotonic_Information+0xc>
20264c0: 80 a7 40 01 cmp %i5, %g1
20264c4: 08 bf ff ad bleu 2026378 <rtems_rate_monotonic_report_statistics_with_plugin+0x88>
20264c8: 90 10 00 1d mov %i5, %o0
20264cc: 81 c7 e0 08 ret
20264d0: 81 e8 00 00 restore
020088a4 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
20088a4: 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;
20088a8: 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;
20088ac: 90 10 00 19 mov %i1, %o0
20088b0: 92 10 00 1d mov %i5, %o1
20088b4: 40 00 44 7e call 2019aac <.urem>
20088b8: b6 10 00 19 mov %i1, %i3
if (excess > 0) {
20088bc: 80 a2 20 00 cmp %o0, 0
20088c0: 02 80 00 05 be 20088d4 <rtems_rbheap_allocate+0x30> <== ALWAYS TAKEN
20088c4: 80 a6 c0 19 cmp %i3, %i1
value += alignment - excess;
20088c8: b6 06 40 1d add %i1, %i5, %i3 <== NOT EXECUTED
20088cc: b6 26 c0 08 sub %i3, %o0, %i3 <== NOT EXECUTED
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
20088d0: 80 a6 c0 19 cmp %i3, %i1 <== NOT EXECUTED
20088d4: 0a 80 00 04 bcs 20088e4 <rtems_rbheap_allocate+0x40> <== NEVER TAKEN
20088d8: 80 a6 60 00 cmp %i1, 0
20088dc: 32 80 00 04 bne,a 20088ec <rtems_rbheap_allocate+0x48>
20088e0: c2 06 00 00 ld [ %i0 ], %g1
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
20088e4: 81 c7 e0 08 ret
20088e8: 91 e8 20 00 restore %g0, 0, %o0
rtems_chain_control *free_chain,
size_t size
)
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
20088ec: 84 06 20 04 add %i0, 4, %g2
rtems_rbheap_chunk *big_enough = NULL;
20088f0: 10 80 00 06 b 2008908 <rtems_rbheap_allocate+0x64>
20088f4: ba 10 20 00 clr %i5
while (current != tail && big_enough == NULL) {
rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;
if (free_chunk->size >= size) {
20088f8: 80 a0 c0 1b cmp %g3, %i3
20088fc: ba 40 3f ff addx %g0, -1, %i5
2008900: ba 08 40 1d and %g1, %i5, %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
2008904: c2 00 40 00 ld [ %g1 ], %g1
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
2008908: 80 a7 60 00 cmp %i5, 0
200890c: 12 80 00 04 bne 200891c <rtems_rbheap_allocate+0x78>
2008910: 80 a0 40 02 cmp %g1, %g2
2008914: 32 bf ff f9 bne,a 20088f8 <rtems_rbheap_allocate+0x54>
2008918: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
200891c: 80 a7 60 00 cmp %i5, 0
2008920: 02 bf ff f1 be 20088e4 <rtems_rbheap_allocate+0x40>
2008924: 01 00 00 00 nop
uintptr_t free_size = free_chunk->size;
2008928: f4 07 60 1c ld [ %i5 + 0x1c ], %i2
if (free_size > aligned_size) {
200892c: 80 a6 80 1b cmp %i2, %i3
2008930: 28 80 00 14 bleu,a 2008980 <rtems_rbheap_allocate+0xdc>
2008934: c4 07 40 00 ld [ %i5 ], %g2
rtems_rbheap_chunk *new_chunk = get_chunk(control);
2008938: 7f ff ff 80 call 2008738 <get_chunk>
200893c: 90 10 00 18 mov %i0, %o0
if (new_chunk != NULL) {
2008940: b8 92 20 00 orcc %o0, 0, %i4
2008944: 02 bf ff e8 be 20088e4 <rtems_rbheap_allocate+0x40> <== NEVER TAKEN
2008948: b4 26 80 1b sub %i2, %i3, %i2
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
200894c: 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;
2008950: f4 27 60 1c st %i2, [ %i5 + 0x1c ]
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
2008954: f6 27 20 1c st %i3, [ %i4 + 0x1c ]
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
2008958: b4 06 80 01 add %i2, %g1, %i2
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
200895c: c0 27 20 04 clr [ %i4 + 4 ]
2008960: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
2008964: c0 27 00 00 clr [ %i4 ]
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
2008968: 90 06 20 18 add %i0, 0x18, %o0
200896c: 40 00 06 b6 call 200a444 <_RBTree_Insert_unprotected>
2008970: 92 07 20 08 add %i4, 8, %o1
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
rtems_chain_set_off_chain(&new_chunk->chain_node);
insert_into_tree(chunk_tree, new_chunk);
ptr = (void *) new_chunk->begin;
2008974: f0 07 20 18 ld [ %i4 + 0x18 ], %i0
2008978: 81 c7 e0 08 ret
200897c: 81 e8 00 00 restore
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
2008980: c2 07 60 04 ld [ %i5 + 4 ], %g1
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
2008984: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
next->previous = previous;
2008988: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
200898c: c4 20 40 00 st %g2, [ %g1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
2008990: c0 27 60 04 clr [ %i5 + 4 ]
2008994: c0 27 40 00 clr [ %i5 ]
}
}
}
return ptr;
}
2008998: 81 c7 e0 08 ret
200899c: 81 e8 00 00 restore
02008ad0 <rtems_rbheap_extend_descriptors_with_malloc>:
/* Do nothing */
}
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
2008ad0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
2008ad4: 7f ff ed 5d call 2004048 <malloc> <== NOT EXECUTED
2008ad8: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
if (chunk != NULL) {
2008adc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2008ae0: 02 80 00 07 be 2008afc <rtems_rbheap_extend_descriptors_with_malloc+0x2c><== NOT EXECUTED
2008ae4: 82 06 20 0c add %i0, 0xc, %g1 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2008ae8: c2 22 20 04 st %g1, [ %o0 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
2008aec: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
after_node->next = the_node;
2008af0: d0 26 20 0c st %o0, [ %i0 + 0xc ] <== NOT EXECUTED
the_node->next = before_node;
2008af4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
before_node->previous = the_node;
2008af8: d0 20 60 04 st %o0, [ %g1 + 4 ] <== NOT EXECUTED
2008afc: 81 c7 e0 08 ret <== NOT EXECUTED
2008b00: 81 e8 00 00 restore <== NOT EXECUTED
020089a0 <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
20089a0: 9d e3 bf 80 save %sp, -128, %sp
20089a4: b6 10 00 18 mov %i0, %i3
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
20089a8: 80 a6 60 00 cmp %i1, 0
20089ac: 02 80 00 45 be 2008ac0 <rtems_rbheap_free+0x120>
20089b0: b0 10 20 00 clr %i0
#define NULL_PAGE rtems_rbheap_chunk_of_node(NULL)
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
20089b4: 90 07 bf e0 add %fp, -32, %o0
20089b8: 92 10 20 00 clr %o1
20089bc: 94 10 20 20 mov 0x20, %o2
20089c0: 40 00 22 7e call 20113b8 <memset>
20089c4: b4 06 e0 18 add %i3, 0x18, %i2
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
20089c8: ba 10 20 00 clr %i5
20089cc: f2 27 bf f8 st %i1, [ %fp + -8 ]
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
20089d0: 10 80 00 12 b 2008a18 <rtems_rbheap_free+0x78>
20089d4: f8 06 e0 1c ld [ %i3 + 0x1c ], %i4
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
20089d8: 90 07 bf e8 add %fp, -24, %o0
20089dc: 9f c0 40 00 call %g1
20089e0: 92 10 00 1c mov %i4, %o1
if ( _RBTree_Is_equal( compare_result ) ) {
20089e4: 80 a2 20 00 cmp %o0, 0
20089e8: 12 80 00 07 bne 2008a04 <rtems_rbheap_free+0x64>
20089ec: 83 3a 20 1f sra %o0, 0x1f, %g1
found = iter_node;
if ( the_rbtree->is_unique )
20089f0: c2 0e a0 14 ldub [ %i2 + 0x14 ], %g1
20089f4: 80 a0 60 00 cmp %g1, 0
20089f8: 12 80 00 0c bne 2008a28 <rtems_rbheap_free+0x88> <== ALWAYS TAKEN
20089fc: ba 10 00 1c mov %i4, %i5
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
2008a00: 83 3a 20 1f sra %o0, 0x1f, %g1 <== NOT EXECUTED
2008a04: 90 20 40 08 sub %g1, %o0, %o0
2008a08: 91 32 20 1f srl %o0, 0x1f, %o0
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
2008a0c: 91 2a 20 02 sll %o0, 2, %o0
2008a10: b8 07 00 08 add %i4, %o0, %i4
2008a14: f8 07 20 04 ld [ %i4 + 4 ], %i4
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
2008a18: 80 a7 20 00 cmp %i4, 0
2008a1c: 32 bf ff ef bne,a 20089d8 <rtems_rbheap_free+0x38>
2008a20: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
2008a24: b8 10 00 1d mov %i5, %i4
return rtems_rbheap_chunk_of_node(
2008a28: ba 07 3f f8 add %i4, -8, %i5
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
2008a2c: 80 a7 7f f8 cmp %i5, -8
2008a30: 02 80 00 24 be 2008ac0 <rtems_rbheap_free+0x120>
2008a34: 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);
2008a38: c4 07 3f f8 ld [ %i4 + -8 ], %g2
2008a3c: 80 a0 a0 00 cmp %g2, 0
2008a40: 12 80 00 05 bne 2008a54 <rtems_rbheap_free+0xb4>
2008a44: 82 10 20 00 clr %g1
2008a48: c2 07 60 04 ld [ %i5 + 4 ], %g1
2008a4c: 80 a0 00 01 cmp %g0, %g1
2008a50: 82 60 3f ff subx %g0, -1, %g1
if (!rtems_rbheap_is_chunk_free(chunk)) {
2008a54: 80 a0 60 00 cmp %g1, 0
2008a58: 02 80 00 1a be 2008ac0 <rtems_rbheap_free+0x120>
2008a5c: b0 10 20 0e mov 0xe, %i0
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
2008a60: b8 07 60 08 add %i5, 8, %i4
2008a64: 92 10 20 00 clr %o1
2008a68: 40 00 07 1c call 200a6d8 <_RBTree_Next_unprotected>
2008a6c: 90 10 00 1c mov %i4, %o0
2008a70: 92 10 20 01 mov 1, %o1
2008a74: b2 10 00 08 mov %o0, %i1
2008a78: 40 00 07 18 call 200a6d8 <_RBTree_Next_unprotected>
2008a7c: 90 10 00 1c mov %i4, %o0
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT);
rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT);
check_and_merge(free_chain, chunk_tree, chunk, succ);
2008a80: 92 10 00 1a mov %i2, %o1
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
2008a84: 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);
2008a88: 94 10 00 1d mov %i5, %o2
2008a8c: 7f ff ff 02 call 2008694 <check_and_merge>
2008a90: 90 10 00 1b mov %i3, %o0
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
2008a94: c2 06 c0 00 ld [ %i3 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2008a98: f6 27 60 04 st %i3, [ %i5 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
2008a9c: fa 26 c0 00 st %i5, [ %i3 ]
the_node->next = before_node;
2008aa0: c2 27 40 00 st %g1, [ %i5 ]
before_node->previous = the_node;
2008aa4: fa 20 60 04 st %i5, [ %g1 + 4 ]
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
2008aa8: 90 10 00 1b mov %i3, %o0
2008aac: 92 10 00 1a mov %i2, %o1
2008ab0: 94 10 00 1d mov %i5, %o2
2008ab4: 96 06 7f f8 add %i1, -8, %o3
2008ab8: 7f ff fe f7 call 2008694 <check_and_merge>
2008abc: b0 10 20 00 clr %i0
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
2008ac0: 81 c7 e0 08 ret
2008ac4: 81 e8 00 00 restore
02019830 <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)
{
2019830: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (!control->buffer)
2019834: 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)
{
2019838: ba 10 00 18 mov %i0, %i5
int rc;
if (!control->buffer)
201983c: 80 a0 60 00 cmp %g1, 0
2019840: 02 80 00 0f be 201987c <rtems_rfs_bitmap_load_map+0x4c>
2019844: b0 10 20 06 mov 6, %i0
return ENXIO;
*map = NULL;
2019848: c0 26 40 00 clr [ %i1 ]
rc = rtems_rfs_buffer_handle_request (control->fs,
201984c: d4 07 60 08 ld [ %i5 + 8 ], %o2
2019850: d0 07 60 04 ld [ %i5 + 4 ], %o0
2019854: d2 07 40 00 ld [ %i5 ], %o1
2019858: 40 00 06 e8 call 201b3f8 <rtems_rfs_buffer_handle_request>
201985c: 96 10 20 01 mov 1, %o3
control->buffer,
control->block,
true);
if (rc)
2019860: b0 92 20 00 orcc %o0, 0, %i0
2019864: 12 80 00 06 bne 201987c <rtems_rfs_bitmap_load_map+0x4c> <== NEVER TAKEN
2019868: 01 00 00 00 nop
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
201986c: c2 07 40 00 ld [ %i5 ], %g1
2019870: c2 00 60 08 ld [ %g1 + 8 ], %g1
2019874: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2019878: c2 26 40 00 st %g1, [ %i1 ]
return 0;
}
201987c: 81 c7 e0 08 ret
2019880: 81 e8 00 00 restore
02019e00 <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)
{
2019e00: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
2019e04: c0 2e 80 00 clrb [ %i2 ]
* we have searched all of the map. The seed may not be aligned to a window
* boundary so we may need to search a partial window and this may also not
* be balanced for the upper or lower seeds. We move to the limits, search
* then return false if no clear bits are found.
*/
while (((upper_seed >= 0) && (upper_seed < control->size))
2019e08: 10 80 00 2d b 2019ebc <rtems_rfs_bitmap_map_alloc+0xbc>
2019e0c: ba 10 00 19 mov %i1, %i5
|| ((lower_seed >= 0) && (lower_seed < control->size)))
{
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
2019e10: 2a 80 00 07 bcs,a 2019e2c <rtems_rfs_bitmap_map_alloc+0x2c><== NEVER TAKEN
2019e14: fa 26 c0 00 st %i5, [ %i3 ] <== NOT EXECUTED
window, 1);
if ((rc > 0) || *allocated)
break;
}
if (lower_seed >= 0)
2019e18: 80 a6 60 00 cmp %i1, 0
2019e1c: 36 80 00 17 bge,a 2019e78 <rtems_rfs_bitmap_map_alloc+0x78>
2019e20: 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)
2019e24: 10 80 00 10 b 2019e64 <rtems_rfs_bitmap_map_alloc+0x64>
2019e28: c2 06 20 0c ld [ %i0 + 0xc ], %g1
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
{
*bit = upper_seed;
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
2019e2c: 90 10 00 18 mov %i0, %o0
2019e30: 92 10 00 1b mov %i3, %o1
2019e34: 94 10 00 1a mov %i2, %o2
2019e38: 7f ff fe 93 call 2019884 <rtems_rfs_search_map_for_clear_bit.constprop.1>
2019e3c: 96 10 20 01 mov 1, %o3
window, 1);
if ((rc > 0) || *allocated)
2019e40: 80 a2 20 00 cmp %o0, 0
2019e44: 34 80 00 2d bg,a 2019ef8 <rtems_rfs_bitmap_map_alloc+0xf8><== NEVER TAKEN
2019e48: b0 10 20 00 clr %i0 <== NOT EXECUTED
2019e4c: c2 0e 80 00 ldub [ %i2 ], %g1
2019e50: 80 a0 60 00 cmp %g1, 0
2019e54: 02 bf ff f2 be 2019e1c <rtems_rfs_bitmap_map_alloc+0x1c>
2019e58: 80 a6 60 00 cmp %i1, 0
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
2019e5c: 81 c7 e0 08 ret
2019e60: 91 e8 20 00 restore %g0, 0, %o0
/*
* Do not bound the limits at the edges of the map. Do not update if an
* edge has been passed.
*/
if (upper_seed < control->size)
2019e64: 80 a7 40 01 cmp %i5, %g1
2019e68: 2a 80 00 12 bcs,a 2019eb0 <rtems_rfs_bitmap_map_alloc+0xb0>
2019e6c: ba 07 68 00 add %i5, 0x800, %i5
upper_seed += window;
if (lower_seed >= 0)
2019e70: 10 80 00 11 b 2019eb4 <rtems_rfs_bitmap_map_alloc+0xb4>
2019e74: 80 a6 60 00 cmp %i1, 0
}
if (lower_seed >= 0)
{
*bit = lower_seed;
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
2019e78: 90 10 00 18 mov %i0, %o0
2019e7c: 92 10 00 1b mov %i3, %o1
2019e80: 94 10 00 1a mov %i2, %o2
2019e84: 7f ff fe 80 call 2019884 <rtems_rfs_search_map_for_clear_bit.constprop.1>
2019e88: 96 10 3f ff mov -1, %o3
window, -1);
if ((rc > 0) || *allocated)
2019e8c: 80 a2 20 00 cmp %o0, 0
2019e90: 34 80 00 1a bg,a 2019ef8 <rtems_rfs_bitmap_map_alloc+0xf8><== NEVER TAKEN
2019e94: b0 10 20 00 clr %i0 <== NOT EXECUTED
2019e98: c2 0e 80 00 ldub [ %i2 ], %g1
2019e9c: 80 a0 60 00 cmp %g1, 0
2019ea0: 22 bf ff f1 be,a 2019e64 <rtems_rfs_bitmap_map_alloc+0x64>
2019ea4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
2019ea8: 81 c7 e0 08 ret
2019eac: 91 e8 20 00 restore %g0, 0, %o0
* Do not bound the limits at the edges of the map. Do not update if an
* edge has been passed.
*/
if (upper_seed < control->size)
upper_seed += window;
if (lower_seed >= 0)
2019eb0: 80 a6 60 00 cmp %i1, 0
2019eb4: 36 80 00 02 bge,a 2019ebc <rtems_rfs_bitmap_map_alloc+0xbc>
2019eb8: b2 06 78 00 add %i1, -2048, %i1
* we have searched all of the map. The seed may not be aligned to a window
* boundary so we may need to search a partial window and this may also not
* be balanced for the upper or lower seeds. We move to the limits, search
* then return false if no clear bits are found.
*/
while (((upper_seed >= 0) && (upper_seed < control->size))
2019ebc: 80 a7 60 00 cmp %i5, 0
2019ec0: 06 80 00 07 bl 2019edc <rtems_rfs_bitmap_map_alloc+0xdc>
2019ec4: 80 a6 60 00 cmp %i1, 0
2019ec8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2019ecc: 80 a7 40 01 cmp %i5, %g1
2019ed0: 2a bf ff d7 bcs,a 2019e2c <rtems_rfs_bitmap_map_alloc+0x2c>
2019ed4: fa 26 c0 00 st %i5, [ %i3 ]
|| ((lower_seed >= 0) && (lower_seed < control->size)))
2019ed8: 80 a6 60 00 cmp %i1, 0
2019edc: 26 80 00 07 bl,a 2019ef8 <rtems_rfs_bitmap_map_alloc+0xf8>
2019ee0: b0 10 20 00 clr %i0
2019ee4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2019ee8: 80 a6 40 01 cmp %i1, %g1
2019eec: 0a bf ff c9 bcs 2019e10 <rtems_rfs_bitmap_map_alloc+0x10>
2019ef0: 80 a7 40 01 cmp %i5, %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
2019ef4: b0 10 20 00 clr %i0
2019ef8: 81 c7 e0 08 ret
2019efc: 81 e8 00 00 restore
02019b04 <rtems_rfs_bitmap_mask>:
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
return mask;
}
2019b04: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
2019b08: 90 20 00 08 neg %o0 <== NOT EXECUTED
return mask;
}
2019b0c: 81 c3 e0 08 retl <== NOT EXECUTED
2019b10: 91 30 40 08 srl %g1, %o0, %o0 <== NOT EXECUTED
02019b14 <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
2019b14: 82 10 00 08 mov %o0, %g1
rtems_rfs_bitmap_element mask = 0;
if (end > start)
2019b18: 80 a2 40 01 cmp %o1, %g1
2019b1c: 08 80 00 06 bleu 2019b34 <rtems_rfs_bitmap_mask_section+0x20><== NEVER TAKEN
2019b20: 90 10 20 00 clr %o0
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
2019b24: 92 20 40 09 sub %g1, %o1, %o1
2019b28: 90 10 3f ff mov -1, %o0
2019b2c: 91 32 00 09 srl %o0, %o1, %o0
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
if (end > start)
mask = rtems_rfs_bitmap_mask (end - start) << start;
2019b30: 91 2a 00 01 sll %o0, %g1, %o0
return mask;
}
2019b34: 81 c3 e0 08 retl
0201a268 <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)
{
201a268: 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);
201a26c: 96 10 20 01 mov 1, %o3
201a270: 90 10 00 18 mov %i0, %o0
201a274: 92 10 00 19 mov %i1, %o1
201a278: 40 00 04 60 call 201b3f8 <rtems_rfs_buffer_handle_request>
201a27c: 94 10 00 1a mov %i2, %o2
if (rc > 0)
201a280: 80 a2 20 00 cmp %o0, 0
201a284: 14 80 00 26 bg 201a31c <rtems_rfs_block_find_indirect+0xb4><== NEVER TAKEN
201a288: 87 2e e0 02 sll %i3, 2, %g3
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
201a28c: c2 06 60 08 ld [ %i1 + 8 ], %g1
201a290: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
201a294: 90 10 20 00 clr %o0
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
201a298: 84 01 00 03 add %g4, %g3, %g2
201a29c: c2 09 00 03 ldub [ %g4 + %g3 ], %g1
201a2a0: fa 08 a0 03 ldub [ %g2 + 3 ], %i5
201a2a4: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
201a2a8: c4 08 a0 02 ldub [ %g2 + 2 ], %g2
201a2ac: 83 28 60 18 sll %g1, 0x18, %g1
201a2b0: 85 28 a0 08 sll %g2, 8, %g2
201a2b4: 82 17 40 01 or %i5, %g1, %g1
201a2b8: 87 28 e0 10 sll %g3, 0x10, %g3
201a2bc: 82 10 40 03 or %g1, %g3, %g1
201a2c0: 82 10 40 02 or %g1, %g2, %g1
if ((*result + 1) == 0)
*result = 0;
201a2c4: 84 38 00 01 xnor %g0, %g1, %g2
201a2c8: 80 a0 00 02 cmp %g0, %g2
201a2cc: 84 60 20 00 subx %g0, 0, %g2
201a2d0: 82 08 40 02 and %g1, %g2, %g1
if (*result >= rtems_rfs_fs_blocks (fs))
201a2d4: c4 06 20 04 ld [ %i0 + 4 ], %g2
201a2d8: 80 a0 40 02 cmp %g1, %g2
201a2dc: 0a 80 00 10 bcs 201a31c <rtems_rfs_block_find_indirect+0xb4><== ALWAYS TAKEN
201a2e0: c2 27 00 00 st %g1, [ %i4 ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
201a2e4: 90 10 20 00 clr %o0 <== NOT EXECUTED
201a2e8: 7f ff e5 08 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201a2ec: 13 00 00 04 sethi %hi(0x1000), %o1 <== NOT EXECUTED
201a2f0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201a2f4: 22 80 00 09 be,a 201a318 <rtems_rfs_block_find_indirect+0xb0><== NOT EXECUTED
201a2f8: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
201a2fc: d2 07 00 00 ld [ %i4 ], %o1 <== NOT EXECUTED
201a300: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201a304: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201a308: 90 12 21 20 or %o0, 0x120, %o0 <== NOT EXECUTED
201a30c: 40 00 1f 1e call 2021f84 <printf> <== NOT EXECUTED
201a310: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
201a314: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
201a318: 90 10 20 00 clr %o0 <== NOT EXECUTED
rc = EIO;
}
return 0;
}
201a31c: 81 c7 e0 08 ret
201a320: 91 e8 00 08 restore %g0, %o0, %o0
0201a388 <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)
{
201a388: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if (pos == 0)
201a38c: 80 96 40 1a orcc %i1, %i2, %g0 <== NOT EXECUTED
201a390: 32 80 00 06 bne,a 201a3a8 <rtems_rfs_block_get_block_size+0x20><== NOT EXECUTED
201a394: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== NOT EXECUTED
* @param size A pointer to the block size.
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
201a398: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
size->offset = 0;
201a39c: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
201a3a0: 81 c7 e0 08 ret <== NOT EXECUTED
201a3a4: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
201a3a8: 94 10 20 00 clr %o2 <== NOT EXECUTED
201a3ac: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
201a3b0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
201a3b4: 40 00 52 44 call 202ecc4 <__udivdi3> <== NOT EXECUTED
201a3b8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201a3bc: 92 02 60 01 inc %o1 <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
201a3c0: 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;
201a3c4: d2 26 c0 00 st %o1, [ %i3 ] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
201a3c8: 94 10 20 00 clr %o2 <== NOT EXECUTED
201a3cc: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201a3d0: 40 00 53 11 call 202f014 <__umoddi3> <== NOT EXECUTED
201a3d4: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
201a3d8: d2 26 e0 04 st %o1, [ %i3 + 4 ] <== NOT EXECUTED
201a3dc: 81 c7 e0 08 ret <== NOT EXECUTED
201a3e0: 81 e8 00 00 restore <== NOT EXECUTED
0201a5c8 <rtems_rfs_block_map_close>:
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
201a5c8: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
int brc;
if (map->dirty && map->inode)
201a5cc: c2 0e 40 00 ldub [ %i1 ], %g1
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
201a5d0: ba 10 00 18 mov %i0, %i5
int rc = 0;
int brc;
if (map->dirty && map->inode)
201a5d4: 80 a0 60 00 cmp %g1, 0
201a5d8: 02 80 00 61 be 201a75c <rtems_rfs_block_map_close+0x194>
201a5dc: b0 10 20 00 clr %i0
201a5e0: d2 06 60 04 ld [ %i1 + 4 ], %o1
201a5e4: 80 a2 60 00 cmp %o1, 0
201a5e8: 22 80 00 5e be,a 201a760 <rtems_rfs_block_map_close+0x198><== NEVER TAKEN
201a5ec: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
{
brc = rtems_rfs_inode_load (fs, map->inode);
201a5f0: 7f ff dd 90 call 2011c30 <rtems_rfs_inode_load>
201a5f4: 90 10 00 1d mov %i5, %o0
if (brc > 0)
201a5f8: b0 92 20 00 orcc %o0, 0, %i0
201a5fc: 14 80 00 59 bg 201a760 <rtems_rfs_block_map_close+0x198> <== NEVER TAKEN
201a600: 92 06 60 38 add %i1, 0x38, %o1
201a604: 82 10 20 00 clr %g1
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201a608: b8 10 20 01 mov 1, %i4
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
201a60c: c4 06 60 04 ld [ %i1 + 4 ], %g2
return rc;
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
201a610: 87 28 60 02 sll %g1, 2, %g3
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
201a614: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
201a618: 86 06 40 03 add %i1, %g3, %g3
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
201a61c: c6 00 e0 24 ld [ %g3 + 0x24 ], %g3
201a620: 88 00 60 06 add %g1, 6, %g4
201a624: 89 29 20 02 sll %g4, 2, %g4
201a628: b6 06 c0 04 add %i3, %g4, %i3
201a62c: b5 30 e0 18 srl %g3, 0x18, %i2
201a630: f4 2e e0 04 stb %i2, [ %i3 + 4 ]
201a634: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
201a638: b5 30 e0 10 srl %g3, 0x10, %i2
201a63c: b6 06 c0 04 add %i3, %g4, %i3
201a640: f4 2e e0 05 stb %i2, [ %i3 + 5 ]
201a644: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
201a648: b5 30 e0 08 srl %g3, 8, %i2
201a64c: b6 06 c0 04 add %i3, %g4, %i3
201a650: f4 2e e0 06 stb %i2, [ %i3 + 6 ]
201a654: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
201a658: 82 00 60 01 inc %g1
201a65c: 88 06 c0 04 add %i3, %g4, %g4
201a660: c6 29 20 07 stb %g3, [ %g4 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201a664: f8 28 a0 10 stb %i4, [ %g2 + 0x10 ]
201a668: 80 a0 60 05 cmp %g1, 5
201a66c: 12 bf ff e8 bne 201a60c <rtems_rfs_block_map_close+0x44>
201a670: 86 10 20 01 mov 1, %g3
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
201a674: c2 06 60 04 ld [ %i1 + 4 ], %g1
201a678: c4 06 60 08 ld [ %i1 + 8 ], %g2
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
201a67c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a680: b9 30 a0 18 srl %g2, 0x18, %i4
201a684: f8 29 20 0c stb %i4, [ %g4 + 0xc ]
201a688: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a68c: b9 30 a0 10 srl %g2, 0x10, %i4
201a690: f8 29 20 0d stb %i4, [ %g4 + 0xd ]
201a694: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a698: b9 30 a0 08 srl %g2, 8, %i4
201a69c: f8 29 20 0e stb %i4, [ %g4 + 0xe ]
201a6a0: c8 00 60 0c ld [ %g1 + 0xc ], %g4
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
201a6a4: 90 10 00 1d mov %i5, %o0
201a6a8: c4 29 20 0f stb %g2, [ %g4 + 0xf ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201a6ac: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
201a6b0: c2 06 60 04 ld [ %i1 + 4 ], %g1
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
201a6b4: f8 0e 60 0e ldub [ %i1 + 0xe ], %i4
201a6b8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
201a6bc: c8 06 60 0c ld [ %i1 + 0xc ], %g4
201a6c0: f8 28 a0 0a stb %i4, [ %g2 + 0xa ]
201a6c4: c4 00 60 0c ld [ %g1 + 0xc ], %g2
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
201a6c8: 94 10 20 01 mov 1, %o2
201a6cc: c8 28 a0 0b stb %g4, [ %g2 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201a6d0: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
201a6d4: c2 06 60 04 ld [ %i1 + 4 ], %g1
201a6d8: 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);
201a6dc: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a6e0: b9 30 a0 18 srl %g2, 0x18, %i4
201a6e4: f8 29 20 30 stb %i4, [ %g4 + 0x30 ]
201a6e8: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a6ec: b9 30 a0 10 srl %g2, 0x10, %i4
201a6f0: f8 29 20 31 stb %i4, [ %g4 + 0x31 ]
201a6f4: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a6f8: b9 30 a0 08 srl %g2, 8, %i4
201a6fc: f8 29 20 32 stb %i4, [ %g4 + 0x32 ]
201a700: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a704: c4 29 20 33 stb %g2, [ %g4 + 0x33 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201a708: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
201a70c: c2 06 60 04 ld [ %i1 + 4 ], %g1
201a710: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
* @param block_count The last data block number.
*/
static inline void
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
201a714: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a718: b9 30 a0 18 srl %g2, 0x18, %i4
201a71c: f8 29 20 34 stb %i4, [ %g4 + 0x34 ]
201a720: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a724: b9 30 a0 10 srl %g2, 0x10, %i4
201a728: f8 29 20 35 stb %i4, [ %g4 + 0x35 ]
201a72c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a730: b9 30 a0 08 srl %g2, 8, %i4
201a734: f8 29 20 36 stb %i4, [ %g4 + 0x36 ]
201a738: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a73c: c4 29 20 37 stb %g2, [ %g4 + 0x37 ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
201a740: d2 06 60 04 ld [ %i1 + 4 ], %o1
201a744: 7f ff dd 9e call 2011dbc <rtems_rfs_inode_unload>
201a748: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
if (brc > 0)
rc = brc;
map->dirty = false;
201a74c: c0 2e 40 00 clrb [ %i1 ]
201a750: 82 38 00 08 xnor %g0, %o0, %g1
201a754: 83 38 60 1f sra %g1, 0x1f, %g1
201a758: b0 0a 00 01 and %o0, %g1, %i0
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
201a75c: 92 06 60 38 add %i1, 0x38, %o1
}
}
map->inode = NULL;
201a760: c0 26 60 04 clr [ %i1 + 4 ]
201a764: 40 00 02 b1 call 201b228 <rtems_rfs_buffer_handle_release>
201a768: 90 10 00 1d mov %i5, %o0
201a76c: 90 10 00 1d mov %i5, %o0
handle->dirty = false;
201a770: c0 2e 60 38 clrb [ %i1 + 0x38 ]
handle->bnum = 0;
201a774: c0 26 60 3c clr [ %i1 + 0x3c ]
handle->buffer = NULL;
201a778: 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);
201a77c: 40 00 02 ab call 201b228 <rtems_rfs_buffer_handle_release>
201a780: 92 06 60 44 add %i1, 0x44, %o1
handle->dirty = false;
201a784: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
201a788: c0 26 60 48 clr [ %i1 + 0x48 ]
handle->buffer = NULL;
201a78c: 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;
}
201a790: 81 c7 e0 08 ret
201a794: 81 e8 00 00 restore
0201a798 <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)
{
201a798: 9d e3 bf 98 save %sp, -104, %sp
int rc = 0;
*block = 0;
201a79c: 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))
201a7a0: fa 06 80 00 ld [ %i2 ], %i5
201a7a4: 80 a7 60 00 cmp %i5, 0
201a7a8: 02 80 00 05 be 201a7bc <rtems_rfs_block_map_find+0x24>
201a7ac: f8 06 60 08 ld [ %i1 + 8 ], %i4
201a7b0: 80 a7 20 00 cmp %i4, 0
201a7b4: 02 80 00 53 be 201a900 <rtems_rfs_block_map_find+0x168> <== NEVER TAKEN
201a7b8: 90 10 20 06 mov 6, %o0
201a7bc: 80 a7 40 1c cmp %i5, %i4
201a7c0: 1a 80 00 50 bcc 201a900 <rtems_rfs_block_map_find+0x168>
201a7c4: 90 10 20 06 mov 6, %o0
return ENXIO;
/*
* If the block position is the same and we have found the block just return it.
*/
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
201a7c8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
201a7cc: 80 a7 40 01 cmp %i5, %g1
201a7d0: 12 80 00 08 bne 201a7f0 <rtems_rfs_block_map_find+0x58>
201a7d4: 80 a7 20 05 cmp %i4, 5
201a7d8: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
201a7dc: 80 a0 60 00 cmp %g1, 0
201a7e0: 02 80 00 04 be 201a7f0 <rtems_rfs_block_map_find+0x58>
201a7e4: 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];
201a7e8: 10 80 00 3d b 201a8dc <rtems_rfs_block_map_find+0x144>
201a7ec: c2 26 c0 00 st %g1, [ %i3 ]
/*
* Determine the type of access we need to perform. If the number of blocks
* is less than or equal to the number of slots in the inode the blocks are
* directly accessed.
*/
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
201a7f0: 38 80 00 08 bgu,a 201a810 <rtems_rfs_block_map_find+0x78>
201a7f4: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
{
*block = map->blocks[bpos->bno];
201a7f8: ba 07 60 08 add %i5, 8, %i5
201a7fc: bb 2f 60 02 sll %i5, 2, %i5
201a800: ba 06 40 1d add %i1, %i5, %i5
201a804: c2 07 60 04 ld [ %i5 + 4 ], %g1
201a808: 10 80 00 35 b 201a8dc <rtems_rfs_block_map_find+0x144>
201a80c: 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;
201a810: 90 10 00 1d mov %i5, %o0
201a814: 40 00 4e 5d call 202e188 <.urem>
201a818: 92 10 00 10 mov %l0, %o1
singly = bpos->bno / fs->blocks_per_block;
201a81c: 92 10 00 10 mov %l0, %o1
* The map is either singly or doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
201a820: a2 10 00 08 mov %o0, %l1
singly = bpos->bno / fs->blocks_per_block;
201a824: 7f ff 9f 96 call 200267c <.udiv>
201a828: 90 10 00 1d mov %i5, %o0
if (map->size.count <= fs->block_map_singly_blocks)
201a82c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
singly = bpos->bno / fs->blocks_per_block;
201a830: d0 27 bf fc st %o0, [ %fp + -4 ]
if (map->size.count <= fs->block_map_singly_blocks)
201a834: 80 a7 00 01 cmp %i4, %g1
201a838: 18 80 00 09 bgu 201a85c <rtems_rfs_block_map_find+0xc4> <== NEVER TAKEN
201a83c: ba 10 00 08 mov %o0, %i5
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
201a840: ba 02 20 08 add %o0, 8, %i5
201a844: 92 06 60 38 add %i1, 0x38, %o1
201a848: bb 2f 60 02 sll %i5, 2, %i5
201a84c: 90 10 00 18 mov %i0, %o0
201a850: ba 06 40 1d add %i1, %i5, %i5
201a854: 10 80 00 1c b 201a8c4 <rtems_rfs_block_map_find+0x12c>
201a858: d4 07 60 04 ld [ %i5 + 4 ], %o2
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
201a85c: 40 00 4e 4b call 202e188 <.urem> <== NOT EXECUTED
201a860: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
201a864: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
201a868: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
201a86c: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
201a870: 80 a7 00 02 cmp %i4, %g2 <== NOT EXECUTED
201a874: 1a 80 00 23 bcc 201a900 <rtems_rfs_block_map_find+0x168> <== NOT EXECUTED
201a878: 90 10 20 06 mov 6, %o0 <== NOT EXECUTED
/*
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
201a87c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201a880: 7f ff 9f 7f call 200267c <.udiv> <== NOT EXECUTED
201a884: 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,
201a888: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED
201a88c: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
201a890: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
201a894: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
201a898: b8 06 60 44 add %i1, 0x44, %i4 <== NOT EXECUTED
201a89c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201a8a0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201a8a4: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
201a8a8: 7f ff fe 70 call 201a268 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
201a8ac: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
201a8b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201a8b4: 12 80 00 13 bne 201a900 <rtems_rfs_block_map_find+0x168> <== NOT EXECUTED
201a8b8: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
201a8bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201a8c0: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
201a8c4: 96 10 00 11 mov %l1, %o3
201a8c8: 7f ff fe 68 call 201a268 <rtems_rfs_block_find_indirect>
201a8cc: 98 10 00 1b mov %i3, %o4
}
}
}
}
if (rc == 0)
201a8d0: 80 a2 20 00 cmp %o0, 0
201a8d4: 12 80 00 0b bne 201a900 <rtems_rfs_block_map_find+0x168> <== NEVER TAKEN
201a8d8: 01 00 00 00 nop
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
201a8dc: c2 06 80 00 ld [ %i2 ], %g1
map->bpos.block = *block;
201a8e0: 90 10 20 00 clr %o0
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
201a8e4: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
201a8e8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
201a8ec: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
201a8f0: c2 06 a0 08 ld [ %i2 + 8 ], %g1
201a8f4: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
map->bpos.block = *block;
201a8f8: c2 06 c0 00 ld [ %i3 ], %g1
201a8fc: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
}
return rc;
}
201a900: 81 c7 e0 08 ret
201a904: 91 e8 00 08 restore %g0, %o0, %o0
0201a9b0 <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)
{
201a9b0: 9d e3 bf 98 save %sp, -104, %sp
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
201a9b4: 90 10 20 00 clr %o0
201a9b8: 13 00 00 08 sethi %hi(0x2000), %o1
201a9bc: 7f ff e3 53 call 2013708 <rtems_rfs_trace>
201a9c0: ba 10 00 18 mov %i0, %i5
201a9c4: 80 8a 20 ff btst 0xff, %o0
201a9c8: 22 80 00 08 be,a 201a9e8 <rtems_rfs_block_map_grow+0x38> <== ALWAYS TAKEN
201a9cc: c4 06 60 08 ld [ %i1 + 8 ], %g2
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
201a9d0: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
201a9d4: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201a9d8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201a9dc: 40 00 1d 6a call 2021f84 <printf> <== NOT EXECUTED
201a9e0: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
201a9e4: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
201a9e8: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
201a9ec: 84 06 80 02 add %i2, %g2, %g2
201a9f0: 80 a0 80 01 cmp %g2, %g1
201a9f4: 1a 80 00 b2 bcc 201acbc <rtems_rfs_block_map_grow+0x30c> <== NEVER TAKEN
201a9f8: b0 10 20 1b mov 0x1b, %i0
map->last_map_block = new_block;
return 0;
}
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
201a9fc: 10 80 00 d4 b 201ad4c <rtems_rfs_block_map_grow+0x39c>
201aa00: a0 10 20 00 clr %l0
/*
* Allocate the block. If an indirect block is needed and cannot be
* allocated free this block.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
201aa04: 90 10 00 1d mov %i5, %o0
201aa08: 94 10 20 00 clr %o2
201aa0c: 7f ff db 61 call 2011790 <rtems_rfs_group_bitmap_alloc>
201aa10: 96 07 bf f8 add %fp, -8, %o3
false, &block);
if (rc > 0)
201aa14: b0 92 20 00 orcc %o0, 0, %i0
201aa18: 14 80 00 d4 bg 201ad68 <rtems_rfs_block_map_grow+0x3b8>
201aa1c: 01 00 00 00 nop
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
201aa20: f8 06 60 08 ld [ %i1 + 8 ], %i4
201aa24: 80 a7 20 04 cmp %i4, 4
201aa28: 38 80 00 08 bgu,a 201aa48 <rtems_rfs_block_map_grow+0x98>
201aa2c: f0 07 60 34 ld [ %i5 + 0x34 ], %i0
map->blocks[map->size.count] = block;
201aa30: c2 07 bf f8 ld [ %fp + -8 ], %g1
201aa34: b8 07 20 08 add %i4, 8, %i4
201aa38: b9 2f 20 02 sll %i4, 2, %i4
201aa3c: b8 06 40 1c add %i1, %i4, %i4
201aa40: 10 80 00 b7 b 201ad1c <rtems_rfs_block_map_grow+0x36c>
201aa44: c2 27 20 04 st %g1, [ %i4 + 4 ]
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
201aa48: 90 10 00 1c mov %i4, %o0
201aa4c: 40 00 4d cf call 202e188 <.urem>
201aa50: 92 10 00 18 mov %i0, %o1
singly = map->size.count / fs->blocks_per_block;
201aa54: 92 10 00 18 mov %i0, %o1
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
201aa58: a4 10 00 08 mov %o0, %l2
singly = map->size.count / fs->blocks_per_block;
201aa5c: 7f ff 9f 08 call 200267c <.udiv>
201aa60: 90 10 00 1c mov %i4, %o0
if (map->size.count < fs->block_map_singly_blocks)
201aa64: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
201aa68: 80 a7 00 01 cmp %i4, %g1
201aa6c: 1a 80 00 1d bcc 201aae0 <rtems_rfs_block_map_grow+0x130> <== NEVER TAKEN
201aa70: ac 10 00 08 mov %o0, %l6
* Singly indirect tables are being used. Allocate a new block for a
* mapping table if direct is 0 or we are moving up (upping). If upping
* move the direct blocks into the table and if not this is the first
* entry of a new block.
*/
if ((direct == 0) ||
201aa74: 80 a4 a0 00 cmp %l2, 0
201aa78: 22 80 00 07 be,a 201aa94 <rtems_rfs_block_map_grow+0xe4> <== NEVER TAKEN
201aa7c: b8 1f 20 05 xor %i4, 5, %i4 <== NOT EXECUTED
201aa80: 80 a4 a0 05 cmp %l2, 5
201aa84: 12 80 00 10 bne 201aac4 <rtems_rfs_block_map_grow+0x114>
201aa88: 80 a2 20 00 cmp %o0, 0
201aa8c: 12 80 00 0e bne 201aac4 <rtems_rfs_block_map_grow+0x114> <== NEVER TAKEN
201aa90: b8 1f 20 05 xor %i4, 5, %i4
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201aa94: 80 a0 00 1c cmp %g0, %i4
&map->singly_buffer,
&map->blocks[singly],
201aa98: 96 05 a0 08 add %l6, 8, %o3
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201aa9c: 90 10 00 1d mov %i5, %o0
&map->singly_buffer,
&map->blocks[singly],
201aaa0: 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,
201aaa4: 92 10 00 19 mov %i1, %o1
&map->singly_buffer,
&map->blocks[singly],
201aaa8: 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,
201aaac: 94 10 00 11 mov %l1, %o2
201aab0: 96 02 e0 04 add %o3, 4, %o3
201aab4: 7f ff fd 9c call 201a124 <rtems_rfs_block_map_indirect_alloc>
201aab8: 98 60 3f ff subx %g0, -1, %o4
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
201aabc: 10 80 00 7a b 201aca4 <rtems_rfs_block_map_grow+0x2f4>
201aac0: b0 92 20 00 orcc %o0, 0, %i0
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201aac4: ac 05 a0 08 add %l6, 8, %l6
201aac8: 90 10 00 1d mov %i5, %o0
201aacc: ad 2d a0 02 sll %l6, 2, %l6
201aad0: 92 10 00 11 mov %l1, %o1
201aad4: ac 06 40 16 add %i1, %l6, %l6
201aad8: 10 80 00 70 b 201ac98 <rtems_rfs_block_map_grow+0x2e8>
201aadc: d4 05 a0 04 ld [ %l6 + 4 ], %o2
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
201aae0: 7f ff 9e e7 call 200267c <.udiv> <== NOT EXECUTED
201aae4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
singly %= fs->blocks_per_block;
201aae8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
201aaec: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED
singly %= fs->blocks_per_block;
201aaf0: 40 00 4d a6 call 202e188 <.urem> <== NOT EXECUTED
201aaf4: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
* Allocate a new block for a singly indirect table if direct is 0 as
* it is the first entry of a new block. We may also need to allocate a
* doubly indirect block as well. Both always occur when direct is 0
* and the doubly indirect block when singly is 0.
*/
if (direct == 0)
201aaf8: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
201aafc: 12 80 00 4a bne 201ac24 <rtems_rfs_block_map_grow+0x274> <== NOT EXECUTED
201ab00: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201ab04: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ab08: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201ab0c: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
201ab10: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
201ab14: 7f ff fd 84 call 201a124 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
201ab18: 98 10 20 00 clr %o4 <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
201ab1c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201ab20: 04 80 00 04 ble 201ab30 <rtems_rfs_block_map_grow+0x180> <== NOT EXECUTED
201ab24: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
201ab28: 10 80 00 62 b 201acb0 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
201ab2c: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
/*
* Allocate a new block for a doubly indirect table if singly is 0 as
* it is the first entry of a new singly indirect block.
*/
if ((singly == 0) ||
201ab30: 22 80 00 08 be,a 201ab50 <rtems_rfs_block_map_grow+0x1a0><== NOT EXECUTED
201ab34: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
201ab38: 80 a7 20 05 cmp %i4, 5 <== NOT EXECUTED
201ab3c: 12 80 00 13 bne 201ab88 <rtems_rfs_block_map_grow+0x1d8> <== NOT EXECUTED
201ab40: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
201ab44: 32 80 00 12 bne,a 201ab8c <rtems_rfs_block_map_grow+0x1dc><== NOT EXECUTED
201ab48: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
201ab4c: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
201ab50: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
&map->doubly_buffer,
&map->blocks[doubly],
201ab54: 96 04 e0 08 add %l3, 8, %o3 <== NOT EXECUTED
*/
if ((singly == 0) ||
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
201ab58: 82 18 80 01 xor %g2, %g1, %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201ab5c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
201ab60: 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,
201ab64: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
201ab68: 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,
201ab6c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201ab70: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
201ab74: 96 02 e0 04 add %o3, 4, %o3 <== NOT EXECUTED
201ab78: 7f ff fd 6b call 201a124 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
201ab7c: 98 60 3f ff subx %g0, -1, %o4 <== NOT EXECUTED
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
201ab80: 10 80 00 0b b 201abac <rtems_rfs_block_map_grow+0x1fc> <== NOT EXECUTED
201ab84: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
201ab88: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
201ab8c: a7 2c e0 02 sll %l3, 2, %l3 <== NOT EXECUTED
201ab90: a6 06 40 13 add %i1, %l3, %l3 <== NOT EXECUTED
201ab94: d4 04 e0 04 ld [ %l3 + 4 ], %o2 <== NOT EXECUTED
201ab98: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ab9c: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
201aba0: 40 00 02 16 call 201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201aba4: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
201aba8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201abac: 24 80 00 08 ble,a 201abcc <rtems_rfs_block_map_grow+0x21c><== NOT EXECUTED
201abb0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
201abb4: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
201abb8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201abbc: 7f ff db 79 call 20119a0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201abc0: 92 10 20 00 clr %o1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
201abc4: 10 80 00 3b b 201acb0 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
201abc8: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
201abcc: c4 0f bf fc ldub [ %fp + -4 ], %g2 <== NOT EXECUTED
201abd0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
201abd4: b9 2f 20 02 sll %i4, 2, %i4 <== NOT EXECUTED
201abd8: c4 28 40 1c stb %g2, [ %g1 + %i4 ] <== NOT EXECUTED
201abdc: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201abe0: c4 17 bf fc lduh [ %fp + -4 ], %g2 <== NOT EXECUTED
201abe4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
201abe8: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
201abec: c4 28 60 01 stb %g2, [ %g1 + 1 ] <== NOT EXECUTED
201abf0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201abf4: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
201abf8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
201abfc: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED
201ac00: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
201ac04: c4 28 60 02 stb %g2, [ %g1 + 2 ] <== NOT EXECUTED
201ac08: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201ac0c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
201ac10: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
201ac14: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
201ac18: c2 2f 20 03 stb %g1, [ %i4 + 3 ] <== NOT EXECUTED
201ac1c: 10 80 00 2a b 201acc4 <rtems_rfs_block_map_grow+0x314> <== NOT EXECUTED
201ac20: e8 2e 60 44 stb %l4, [ %i1 + 0x44 ] <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
201ac24: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
201ac28: a7 2c e0 02 sll %l3, 2, %l3 <== NOT EXECUTED
201ac2c: a6 06 40 13 add %i1, %l3, %l3 <== NOT EXECUTED
201ac30: d4 04 e0 04 ld [ %l3 + 4 ], %o2 <== NOT EXECUTED
201ac34: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ac38: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
201ac3c: 40 00 01 ef call 201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201ac40: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
201ac44: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201ac48: 24 80 00 04 ble,a 201ac58 <rtems_rfs_block_map_grow+0x2a8><== NOT EXECUTED
201ac4c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
201ac50: 10 80 00 18 b 201acb0 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
201ac54: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
201ac58: b9 2f 20 02 sll %i4, 2, %i4 <== NOT EXECUTED
201ac5c: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ac60: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
201ac64: 82 00 80 1c add %g2, %i4, %g1 <== NOT EXECUTED
201ac68: d4 08 80 1c ldub [ %g2 + %i4 ], %o2 <== NOT EXECUTED
201ac6c: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED
201ac70: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
201ac74: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
201ac78: 95 2a a0 18 sll %o2, 0x18, %o2 <== NOT EXECUTED
201ac7c: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
201ac80: 94 10 c0 0a or %g3, %o2, %o2 <== NOT EXECUTED
201ac84: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
201ac88: 94 12 80 02 or %o2, %g2, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ac8c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
201ac90: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED
201ac94: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ac98: 40 00 01 d8 call 201b3f8 <rtems_rfs_buffer_handle_request>
201ac9c: 96 10 20 01 mov 1, %o3
singly_block, true);
if (rc > 0)
201aca0: b0 92 20 00 orcc %o0, 0, %i0
201aca4: 24 80 00 09 ble,a 201acc8 <rtems_rfs_block_map_grow+0x318><== ALWAYS TAKEN
201aca8: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
{
rtems_rfs_group_bitmap_free (fs, false, block);
201acac: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
201acb0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201acb4: 7f ff db 3b call 20119a0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201acb8: 92 10 20 00 clr %o1 <== NOT EXECUTED
201acbc: 81 c7 e0 08 ret <== NOT EXECUTED
201acc0: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
201acc4: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
201acc8: c4 0f bf f8 ldub [ %fp + -8 ], %g2
201accc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201acd0: a5 2c a0 02 sll %l2, 2, %l2
201acd4: c4 28 40 12 stb %g2, [ %g1 + %l2 ]
201acd8: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201acdc: c4 17 bf f8 lduh [ %fp + -8 ], %g2
201ace0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201ace4: 82 00 40 12 add %g1, %l2, %g1
201ace8: c4 28 60 01 stb %g2, [ %g1 + 1 ]
201acec: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201acf0: c4 07 bf f8 ld [ %fp + -8 ], %g2
201acf4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201acf8: 85 30 a0 08 srl %g2, 8, %g2
201acfc: 82 00 40 12 add %g1, %l2, %g1
201ad00: c4 28 60 02 stb %g2, [ %g1 + 2 ]
201ad04: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201ad08: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201ad0c: a4 00 40 12 add %g1, %l2, %l2
201ad10: c2 07 bf f8 ld [ %fp + -8 ], %g1
201ad14: c2 2c a0 03 stb %g1, [ %l2 + 3 ]
201ad18: e8 2e 60 38 stb %l4, [ %i1 + 0x38 ]
}
map->size.count++;
201ad1c: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.offset = 0;
201ad20: c0 26 60 0c clr [ %i1 + 0xc ]
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
201ad24: 82 00 60 01 inc %g1
201ad28: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->size.offset = 0;
if (b == 0)
201ad2c: 80 a4 20 00 cmp %l0, 0
201ad30: 12 80 00 03 bne 201ad3c <rtems_rfs_block_map_grow+0x38c> <== NEVER TAKEN
201ad34: c2 07 bf f8 ld [ %fp + -8 ], %g1
*new_block = block;
201ad38: c2 26 c0 00 st %g1, [ %i3 ]
map->last_data_block = block;
201ad3c: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
map->dirty = true;
201ad40: e8 2e 40 00 stb %l4, [ %i1 ]
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
201ad44: 10 80 00 05 b 201ad58 <rtems_rfs_block_map_grow+0x3a8>
201ad48: a0 04 20 01 inc %l0
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
201ad4c: a8 10 20 01 mov 1, %l4
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
201ad50: aa 06 60 44 add %i1, 0x44, %l5
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ad54: a2 06 60 38 add %i1, 0x38, %l1
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
201ad58: 80 a4 00 1a cmp %l0, %i2
201ad5c: 32 bf ff 2a bne,a 201aa04 <rtems_rfs_block_map_grow+0x54>
201ad60: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
201ad64: b0 10 20 00 clr %i0
}
201ad68: 81 c7 e0 08 ret
201ad6c: 81 e8 00 00 restore
0201a124 <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)
{
201a124: 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);
201a128: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
201a12c: 90 10 00 18 mov %i0, %o0
201a130: 94 10 20 00 clr %o2
201a134: 7f ff dd 97 call 2011790 <rtems_rfs_group_bitmap_alloc>
201a138: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
201a13c: ba 92 20 00 orcc %o0, 0, %i5
201a140: 34 80 00 48 bg,a 201a260 <rtems_rfs_block_map_indirect_alloc+0x13c><== NEVER TAKEN
201a144: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
201a148: d4 07 bf fc ld [ %fp + -4 ], %o2
201a14c: 90 10 00 18 mov %i0, %o0
201a150: 92 10 00 1a mov %i2, %o1
201a154: 40 00 04 a9 call 201b3f8 <rtems_rfs_buffer_handle_request>
201a158: 96 10 20 00 clr %o3
if (rc > 0)
201a15c: ba 92 20 00 orcc %o0, 0, %i5
201a160: 04 80 00 07 ble 201a17c <rtems_rfs_block_map_indirect_alloc+0x58><== ALWAYS TAKEN
201a164: d4 07 bf fc ld [ %fp + -4 ], %o2
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
201a168: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201a16c: 7f ff de 0d call 20119a0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201a170: 92 10 20 00 clr %o1 <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
map->last_map_block = new_block;
return 0;
}
201a174: 81 c7 e0 08 ret <== NOT EXECUTED
201a178: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
return rc;
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
201a17c: c2 06 a0 08 ld [ %i2 + 8 ], %g1
201a180: d4 06 20 08 ld [ %i0 + 8 ], %o2
201a184: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
201a188: 40 00 1f 01 call 2021d8c <memset>
201a18c: 92 10 20 ff mov 0xff, %o1
if (upping)
201a190: 80 a7 20 00 cmp %i4, 0
201a194: 02 80 00 2d be 201a248 <rtems_rfs_block_map_indirect_alloc+0x124><== NEVER TAKEN
201a198: 82 10 20 01 mov 1, %g1
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
201a19c: 90 10 20 00 clr %o0
201a1a0: 7f ff e5 5a call 2013708 <rtems_rfs_trace>
201a1a4: 13 00 00 08 sethi %hi(0x2000), %o1
201a1a8: 80 8a 20 ff btst 0xff, %o0
201a1ac: 02 80 00 07 be 201a1c8 <rtems_rfs_block_map_indirect_alloc+0xa4><== ALWAYS TAKEN
201a1b0: 84 10 00 19 mov %i1, %g2
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
201a1b4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201a1b8: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201a1bc: 40 00 1f 72 call 2021f84 <printf> <== NOT EXECUTED
201a1c0: 90 12 20 e8 or %o0, 0xe8, %o0 ! 20334e8 <CSWTCH.2+0x8> <== NOT EXECUTED
201a1c4: 84 10 00 19 mov %i1, %g2 <== NOT EXECUTED
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
201a1c8: 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]);
201a1cc: 86 10 20 01 mov 1, %g3
201a1d0: c8 06 a0 08 ld [ %i2 + 8 ], %g4
201a1d4: fa 08 a0 24 ldub [ %g2 + 0x24 ], %i5
201a1d8: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
201a1dc: fa 29 00 01 stb %i5, [ %g4 + %g1 ]
201a1e0: c8 06 a0 08 ld [ %i2 + 8 ], %g4
201a1e4: fa 10 a0 24 lduh [ %g2 + 0x24 ], %i5
201a1e8: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
201a1ec: 88 01 00 01 add %g4, %g1, %g4
201a1f0: fa 29 20 01 stb %i5, [ %g4 + 1 ]
201a1f4: c8 06 a0 08 ld [ %i2 + 8 ], %g4
201a1f8: fa 00 a0 24 ld [ %g2 + 0x24 ], %i5
201a1fc: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
201a200: bb 37 60 08 srl %i5, 8, %i5
201a204: 88 01 00 01 add %g4, %g1, %g4
201a208: fa 29 20 02 stb %i5, [ %g4 + 2 ]
201a20c: c8 06 a0 08 ld [ %i2 + 8 ], %g4
201a210: fa 00 a0 24 ld [ %g2 + 0x24 ], %i5
201a214: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
201a218: 84 00 a0 04 add %g2, 4, %g2
201a21c: 88 01 00 01 add %g4, %g1, %g4
201a220: fa 29 20 03 stb %i5, [ %g4 + 3 ]
201a224: 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++)
201a228: 80 a0 60 14 cmp %g1, 0x14
201a22c: 12 bf ff e9 bne 201a1d0 <rtems_rfs_block_map_indirect_alloc+0xac>
201a230: c6 2e 80 00 stb %g3, [ %i2 ]
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
201a234: 90 06 60 24 add %i1, 0x24, %o0
201a238: 92 10 20 00 clr %o1
201a23c: 40 00 1e d4 call 2021d8c <memset>
201a240: 94 10 20 14 mov 0x14, %o2
}
rtems_rfs_buffer_mark_dirty (buffer);
201a244: 82 10 20 01 mov 1, %g1
201a248: c2 2e 80 00 stb %g1, [ %i2 ]
*block = new_block;
201a24c: c2 07 bf fc ld [ %fp + -4 ], %g1
map->last_map_block = new_block;
return 0;
201a250: ba 10 20 00 clr %i5
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
201a254: c2 26 c0 00 st %g1, [ %i3 ]
map->last_map_block = new_block;
201a258: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
return 0;
}
201a25c: b0 10 00 1d mov %i5, %i0
201a260: 81 c7 e0 08 ret
201a264: 81 e8 00 00 restore
0201a044 <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)
{
201a044: 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) ||
201a048: 80 a7 20 00 cmp %i4, 0
201a04c: 02 80 00 09 be 201a070 <rtems_rfs_block_map_indirect_shrink+0x2c><== NEVER TAKEN
201a050: 82 06 e0 08 add %i3, 8, %g1
201a054: 80 a7 20 05 cmp %i4, 5
201a058: 32 80 00 2f bne,a 201a114 <rtems_rfs_block_map_indirect_shrink+0xd0>
201a05c: b0 10 20 00 clr %i0
201a060: 80 a6 e0 00 cmp %i3, 0
201a064: 32 80 00 2c bne,a 201a114 <rtems_rfs_block_map_indirect_shrink+0xd0><== NEVER TAKEN
201a068: b0 10 20 00 clr %i0 <== NOT EXECUTED
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
201a06c: 82 06 e0 08 add %i3, 8, %g1
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
201a070: 80 a7 20 05 cmp %i4, 5
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
201a074: 83 28 60 02 sll %g1, 2, %g1
201a078: 82 06 40 01 add %i1, %g1, %g1
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
201a07c: 12 80 00 1a bne 201a0e4 <rtems_rfs_block_map_indirect_shrink+0xa0><== NEVER TAKEN
201a080: fa 00 60 04 ld [ %g1 + 4 ], %i5
201a084: 80 a6 e0 00 cmp %i3, 0
201a088: 32 80 00 18 bne,a 201a0e8 <rtems_rfs_block_map_indirect_shrink+0xa4><== NEVER TAKEN
201a08c: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
201a090: c2 06 a0 08 ld [ %i2 + 8 ], %g1
201a094: 84 10 20 00 clr %g2
201a098: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201a09c: f8 08 40 00 ldub [ %g1 ], %i4
201a0a0: c8 08 60 01 ldub [ %g1 + 1 ], %g4
201a0a4: b9 2f 20 18 sll %i4, 0x18, %i4
201a0a8: 89 29 20 10 sll %g4, 0x10, %g4
201a0ac: 88 17 00 04 or %i4, %g4, %g4
201a0b0: f8 08 60 03 ldub [ %g1 + 3 ], %i4
* @param indirect The index index in the inode's block table.
* @param index The index in the indirect table of the block.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
201a0b4: 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);
201a0b8: 88 11 00 1c or %g4, %i4, %g4
201a0bc: f8 08 60 02 ldub [ %g1 + 2 ], %i4
201a0c0: 84 00 a0 04 add %g2, 4, %g2
201a0c4: b9 2f 20 08 sll %i4, 8, %i4
201a0c8: 88 11 00 1c or %g4, %i4, %g4
201a0cc: c8 20 e0 24 st %g4, [ %g3 + 0x24 ]
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
201a0d0: 80 a0 a0 14 cmp %g2, 0x14
201a0d4: 12 bf ff f2 bne 201a09c <rtems_rfs_block_map_indirect_shrink+0x58>
201a0d8: 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);
201a0dc: 10 80 00 07 b 201a0f8 <rtems_rfs_block_map_indirect_shrink+0xb4>
201a0e0: 90 10 00 18 mov %i0, %o0
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
201a0e4: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED
201a0e8: b7 2e e0 02 sll %i3, 2, %i3 <== NOT EXECUTED
201a0ec: b6 06 40 1b add %i1, %i3, %i3 <== NOT EXECUTED
201a0f0: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
201a0f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201a0f8: 92 10 20 00 clr %o1
201a0fc: 7f ff de 29 call 20119a0 <rtems_rfs_group_bitmap_free>
201a100: 94 10 00 1d mov %i5, %o2
if (rc > 0)
201a104: b0 92 20 00 orcc %o0, 0, %i0
201a108: 14 80 00 05 bg 201a11c <rtems_rfs_block_map_indirect_shrink+0xd8><== NEVER TAKEN
201a10c: 01 00 00 00 nop
return rc;
map->last_map_block = block_to_free;
201a110: fa 26 60 1c st %i5, [ %i1 + 0x1c ]
201a114: 81 c7 e0 08 ret
201a118: 81 e8 00 00 restore
}
return rc;
}
201a11c: 81 c7 e0 08 ret <== NOT EXECUTED
201a120: 81 e8 00 00 restore <== NOT EXECUTED
0201a444 <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)
{
201a444: 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;
201a448: c0 2e 80 00 clrb [ %i2 ]
map->inode = NULL;
201a44c: 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;
201a450: c0 26 a0 08 clr [ %i2 + 8 ]
size->offset = 0;
201a454: 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;
201a458: c0 26 a0 10 clr [ %i2 + 0x10 ]
bpos->boff = 0;
201a45c: c0 26 a0 14 clr [ %i2 + 0x14 ]
bpos->block = 0;
201a460: 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;
201a464: c0 2e a0 38 clrb [ %i2 + 0x38 ]
handle->bnum = 0;
201a468: c0 26 a0 3c clr [ %i2 + 0x3c ]
handle->buffer = NULL;
201a46c: 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;
201a470: c0 2e a0 44 clrb [ %i2 + 0x44 ]
handle->bnum = 0;
201a474: c0 26 a0 48 clr [ %i2 + 0x48 ]
handle->buffer = NULL;
201a478: 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);
201a47c: 90 10 00 18 mov %i0, %o0
201a480: 7f ff dd ec call 2011c30 <rtems_rfs_inode_load>
201a484: 92 10 00 19 mov %i1, %o1
if (rc > 0)
201a488: ba 92 20 00 orcc %o0, 0, %i5
201a48c: 14 80 00 40 bg 201a58c <rtems_rfs_block_map_open+0x148> <== NEVER TAKEN
201a490: 84 10 20 00 clr %g2
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
201a494: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
201a498: f2 26 a0 04 st %i1, [ %i2 + 4 ]
201a49c: 88 00 a0 06 add %g2, 6, %g4
201a4a0: 89 29 20 02 sll %g4, 2, %g4
201a4a4: 88 00 40 04 add %g1, %g4, %g4
201a4a8: 86 01 20 04 add %g4, 4, %g3
201a4ac: f8 09 20 04 ldub [ %g4 + 4 ], %i4
201a4b0: c8 09 20 05 ldub [ %g4 + 5 ], %g4
201a4b4: b9 2f 20 18 sll %i4, 0x18, %i4
201a4b8: 89 29 20 10 sll %g4, 0x10, %g4
201a4bc: b8 17 00 04 or %i4, %g4, %i4
201a4c0: c8 08 e0 03 ldub [ %g3 + 3 ], %g4
block_size = rtems_rfs_fs_block_size (fs);
return (((uint64_t) (size->count - 1)) * block_size) + offset;
}
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
201a4c4: bb 28 a0 02 sll %g2, 2, %i5
201a4c8: b8 17 00 04 or %i4, %g4, %i4
201a4cc: c8 08 e0 02 ldub [ %g3 + 2 ], %g4
201a4d0: ba 06 80 1d add %i2, %i5, %i5
201a4d4: 89 29 20 08 sll %g4, 8, %g4
201a4d8: 86 17 00 04 or %i4, %g4, %g3
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
201a4dc: 84 00 a0 01 inc %g2
201a4e0: 80 a0 a0 05 cmp %g2, 5
201a4e4: 12 bf ff ee bne 201a49c <rtems_rfs_block_map_open+0x58>
201a4e8: c6 27 60 24 st %g3, [ %i5 + 0x24 ]
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
201a4ec: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
201a4f0: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
201a4f4: 87 28 e0 18 sll %g3, 0x18, %g3
201a4f8: 85 28 a0 10 sll %g2, 0x10, %g2
201a4fc: 84 10 c0 02 or %g3, %g2, %g2
201a500: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
201a504: 84 10 80 03 or %g2, %g3, %g2
201a508: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
201a50c: 87 28 e0 08 sll %g3, 8, %g3
201a510: 84 10 80 03 or %g2, %g3, %g2
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
201a514: c4 26 a0 08 st %g2, [ %i2 + 8 ]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
201a518: 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);
201a51c: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
201a520: 85 28 a0 08 sll %g2, 8, %g2
201a524: 84 10 c0 02 or %g3, %g2, %g2
201a528: c4 26 a0 0c st %g2, [ %i2 + 0xc ]
* @return uint32_t The last map block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_map_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_map_block);
201a52c: c6 08 60 30 ldub [ %g1 + 0x30 ], %g3
201a530: c4 08 60 31 ldub [ %g1 + 0x31 ], %g2
201a534: 87 28 e0 18 sll %g3, 0x18, %g3
201a538: 85 28 a0 10 sll %g2, 0x10, %g2
201a53c: 84 10 c0 02 or %g3, %g2, %g2
201a540: c6 08 60 33 ldub [ %g1 + 0x33 ], %g3
201a544: 84 10 80 03 or %g2, %g3, %g2
201a548: c6 08 60 32 ldub [ %g1 + 0x32 ], %g3
201a54c: 87 28 e0 08 sll %g3, 8, %g3
201a550: 84 10 80 03 or %g2, %g3, %g2
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
201a554: c4 26 a0 1c st %g2, [ %i2 + 0x1c ]
* @return uint32_t The last data block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_data_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_data_block);
201a558: c4 08 60 35 ldub [ %g1 + 0x35 ], %g2
201a55c: c6 08 60 34 ldub [ %g1 + 0x34 ], %g3
201a560: 85 28 a0 10 sll %g2, 0x10, %g2
201a564: 87 28 e0 18 sll %g3, 0x18, %g3
201a568: 86 10 c0 02 or %g3, %g2, %g3
201a56c: c4 08 60 37 ldub [ %g1 + 0x37 ], %g2
201a570: 86 10 c0 02 or %g3, %g2, %g3
201a574: c4 08 60 36 ldub [ %g1 + 0x36 ], %g2
201a578: 85 28 a0 08 sll %g2, 8, %g2
201a57c: 82 10 c0 02 or %g3, %g2, %g1
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
201a580: c2 26 a0 20 st %g1, [ %i2 + 0x20 ]
rc = rtems_rfs_inode_unload (fs, inode, false);
201a584: 7f ff de 0e call 2011dbc <rtems_rfs_inode_unload>
201a588: 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);
201a58c: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED
201a590: 40 00 03 26 call 201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201a594: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201a598: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
201a59c: c0 2e a0 38 clrb [ %i2 + 0x38 ] <== NOT EXECUTED
handle->bnum = 0;
201a5a0: c0 26 a0 3c clr [ %i2 + 0x3c ] <== NOT EXECUTED
handle->buffer = NULL;
201a5a4: 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);
201a5a8: 92 06 a0 44 add %i2, 0x44, %o1 <== NOT EXECUTED
201a5ac: 40 00 03 1f call 201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201a5b0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
handle->dirty = false;
201a5b4: c0 2e a0 44 clrb [ %i2 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
201a5b8: c0 26 a0 48 clr [ %i2 + 0x48 ] <== NOT EXECUTED
handle->buffer = NULL;
201a5bc: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED
return rc;
}
201a5c0: 81 c7 e0 08 ret <== NOT EXECUTED
201a5c4: 81 e8 00 00 restore <== NOT EXECUTED
0201ad70 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
201ad70: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
201ad74: 90 10 20 00 clr %o0
201ad78: 7f ff e2 64 call 2013708 <rtems_rfs_trace>
201ad7c: 13 00 00 10 sethi %hi(0x4000), %o1
201ad80: 80 8a 20 ff btst 0xff, %o0
201ad84: 22 80 00 08 be,a 201ada4 <rtems_rfs_block_map_shrink+0x34><== ALWAYS TAKEN
201ad88: c2 06 60 08 ld [ %i1 + 8 ], %g1
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
201ad8c: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
201ad90: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201ad94: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201ad98: 40 00 1c 7b call 2021f84 <printf> <== NOT EXECUTED
201ad9c: 90 12 21 a8 or %o0, 0x1a8, %o0 <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
201ada0: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
201ada4: 80 a0 60 00 cmp %g1, 0
201ada8: 12 80 00 04 bne 201adb8 <rtems_rfs_block_map_shrink+0x48>
201adac: 80 a6 80 01 cmp %i2, %g1
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
201adb0: 10 80 00 b8 b 201b090 <rtems_rfs_block_map_shrink+0x320>
201adb4: 90 10 20 00 clr %o0
201adb8: 38 80 00 90 bgu,a 201aff8 <rtems_rfs_block_map_shrink+0x288><== NEVER TAKEN
201adbc: b4 10 00 01 mov %g1, %i2 <== NOT EXECUTED
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
201adc0: 10 80 00 8f b 201affc <rtems_rfs_block_map_shrink+0x28c>
201adc4: a4 06 60 44 add %i1, 0x44, %l2
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
201adc8: ba 00 7f ff add %g1, -1, %i5
if (block < RTEMS_RFS_INODE_BLOCKS)
201adcc: 80 a7 60 04 cmp %i5, 4
201add0: 38 80 00 08 bgu,a 201adf0 <rtems_rfs_block_map_shrink+0x80>
201add4: f6 06 20 34 ld [ %i0 + 0x34 ], %i3
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
201add8: 82 00 60 07 add %g1, 7, %g1
201addc: 83 28 60 02 sll %g1, 2, %g1
201ade0: 82 06 40 01 add %i1, %g1, %g1
201ade4: fa 00 60 04 ld [ %g1 + 4 ], %i5
map->blocks[block] = 0;
201ade8: 10 80 00 76 b 201afc0 <rtems_rfs_block_map_shrink+0x250>
201adec: c0 20 60 04 clr [ %g1 + 4 ]
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
201adf0: 90 10 00 1d mov %i5, %o0
201adf4: 40 00 4c e5 call 202e188 <.urem>
201adf8: 92 10 00 1b mov %i3, %o1
singly = block / fs->blocks_per_block;
201adfc: 92 10 00 1b mov %i3, %o1
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
201ae00: b8 10 00 08 mov %o0, %i4
singly = block / fs->blocks_per_block;
201ae04: 7f ff 9e 1e call 200267c <.udiv>
201ae08: 90 10 00 1d mov %i5, %o0
if (block < fs->block_map_singly_blocks)
201ae0c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
201ae10: 80 a7 40 01 cmp %i5, %g1
201ae14: 1a 80 00 20 bcc 201ae94 <rtems_rfs_block_map_shrink+0x124><== NEVER TAKEN
201ae18: a2 10 00 08 mov %o0, %l1
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ae1c: 82 02 20 08 add %o0, 8, %g1
201ae20: 83 28 60 02 sll %g1, 2, %g1
201ae24: 82 06 40 01 add %i1, %g1, %g1
201ae28: d4 00 60 04 ld [ %g1 + 4 ], %o2
201ae2c: 90 10 00 18 mov %i0, %o0
201ae30: 92 10 00 10 mov %l0, %o1
201ae34: 40 00 01 71 call 201b3f8 <rtems_rfs_buffer_handle_request>
201ae38: 96 10 20 01 mov 1, %o3
map->blocks[singly], true);
if (rc > 0)
201ae3c: 80 a2 20 00 cmp %o0, 0
201ae40: 14 80 00 94 bg 201b090 <rtems_rfs_block_map_shrink+0x320> <== NEVER TAKEN
201ae44: 85 2f 20 02 sll %i4, 2, %g2
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
201ae48: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201ae4c: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
201ae50: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
201ae54: 82 00 c0 02 add %g3, %g2, %g1
201ae58: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5
201ae5c: c8 08 60 03 ldub [ %g1 + 3 ], %g4
201ae60: c4 08 60 01 ldub [ %g1 + 1 ], %g2
201ae64: c2 08 60 02 ldub [ %g1 + 2 ], %g1
201ae68: bb 2f 60 18 sll %i5, 0x18, %i5
201ae6c: 85 28 a0 10 sll %g2, 0x10, %g2
201ae70: ba 11 00 1d or %g4, %i5, %i5
201ae74: 83 28 60 08 sll %g1, 8, %g1
201ae78: ba 17 40 02 or %i5, %g2, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
201ae7c: 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,
201ae80: ba 17 40 01 or %i5, %g1, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
201ae84: 94 10 00 10 mov %l0, %o2
201ae88: 96 10 00 11 mov %l1, %o3
201ae8c: 10 80 00 48 b 201afac <rtems_rfs_block_map_shrink+0x23c>
201ae90: 98 10 00 1c mov %i4, %o4
singly, direct);
if (rc)
return rc;
}
else if (block < fs->block_map_doubly_blocks)
201ae94: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED
201ae98: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
201ae9c: 3a 80 00 5d bcc,a 201b010 <rtems_rfs_block_map_shrink+0x2a0><== NOT EXECUTED
201aea0: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
201aea4: 7f ff 9d f6 call 200267c <.udiv> <== NOT EXECUTED
201aea8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
201aeac: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
201aeb0: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
201aeb4: 40 00 4c b5 call 202e188 <.urem> <== NOT EXECUTED
201aeb8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
201aebc: 82 05 20 08 add %l4, 8, %g1 <== NOT EXECUTED
201aec0: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
201aec4: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
201aec8: 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;
201aecc: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
201aed0: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
201aed4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201aed8: 40 00 01 48 call 201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201aedc: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
201aee0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201aee4: 14 80 00 6b bg 201b090 <rtems_rfs_block_map_shrink+0x320> <== NOT EXECUTED
201aee8: 85 2c 60 02 sll %l1, 2, %g2 <== NOT EXECUTED
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
201aeec: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201aef0: 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,
201aef4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
201aef8: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
201aefc: f6 08 c0 02 ldub [ %g3 + %g2 ], %i3 <== NOT EXECUTED
201af00: c8 08 60 03 ldub [ %g1 + 3 ], %g4 <== NOT EXECUTED
201af04: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
201af08: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
201af0c: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
201af10: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
201af14: b7 2e e0 18 sll %i3, 0x18, %i3 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201af18: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
201af1c: b6 11 00 1b or %g4, %i3, %i3 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201af20: 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,
201af24: b6 16 c0 02 or %i3, %g2, %i3 <== NOT EXECUTED
201af28: b6 16 c0 01 or %i3, %g1, %i3 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201af2c: 40 00 01 33 call 201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201af30: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
singly, true);
if (rc > 0)
201af34: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201af38: 14 80 00 56 bg 201b090 <rtems_rfs_block_map_shrink+0x320> <== NOT EXECUTED
201af3c: 85 2f 20 02 sll %i4, 2, %g2 <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
201af40: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
201af44: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED
direct);
if (direct == 0)
201af48: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly, true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
201af4c: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
201af50: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5 <== NOT EXECUTED
201af54: c8 08 60 03 ldub [ %g1 + 3 ], %g4 <== NOT EXECUTED
201af58: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
201af5c: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
201af60: bb 2f 60 18 sll %i5, 0x18, %i5 <== NOT EXECUTED
201af64: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
201af68: ba 11 00 1d or %g4, %i5, %i5 <== NOT EXECUTED
201af6c: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
201af70: ba 17 40 02 or %i5, %g2, %i5 <== NOT EXECUTED
direct);
if (direct == 0)
201af74: 12 80 00 13 bne 201afc0 <rtems_rfs_block_map_shrink+0x250><== NOT EXECUTED
201af78: ba 17 40 01 or %i5, %g1, %i5 <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
201af7c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201af80: 92 10 20 00 clr %o1 <== NOT EXECUTED
201af84: 7f ff da 87 call 20119a0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201af88: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
if (rc > 0)
201af8c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201af90: 14 80 00 40 bg 201b090 <rtems_rfs_block_map_shrink+0x320> <== NOT EXECUTED
201af94: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
return rc;
map->last_map_block = singly;
201af98: f6 26 60 1c st %i3, [ %i1 + 0x1c ] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
201af9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201afa0: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
201afa4: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
201afa8: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
201afac: 7f ff fc 26 call 201a044 <rtems_rfs_block_map_indirect_shrink>
201afb0: 01 00 00 00 nop
doubly, doubly_singly);
if (rc)
201afb4: 80 a2 20 00 cmp %o0, 0
201afb8: 12 80 00 36 bne 201b090 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
201afbc: 01 00 00 00 nop
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
201afc0: 90 10 00 18 mov %i0, %o0
201afc4: 92 10 20 00 clr %o1
201afc8: 7f ff da 76 call 20119a0 <rtems_rfs_group_bitmap_free>
201afcc: 94 10 00 1d mov %i5, %o2
if (rc > 0)
201afd0: 80 a2 20 00 cmp %o0, 0
201afd4: 14 80 00 2f bg 201b090 <rtems_rfs_block_map_shrink+0x320> <== NEVER TAKEN
201afd8: b4 06 bf ff add %i2, -1, %i2
return rc;
map->size.count--;
201afdc: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.offset = 0;
201afe0: 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--;
201afe4: 82 00 7f ff add %g1, -1, %g1
map->size.offset = 0;
map->last_data_block = block_to_free;
201afe8: 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--;
201afec: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
201aff0: 10 80 00 05 b 201b004 <rtems_rfs_block_map_shrink+0x294>
201aff4: e6 2e 40 00 stb %l3, [ %i1 ]
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
201aff8: a4 06 60 44 add %i1, 0x44, %l2 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201affc: a0 06 60 38 add %i1, 0x38, %l0
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
201b000: a6 10 20 01 mov 1, %l3
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
201b004: 80 a6 a0 00 cmp %i2, 0
201b008: 12 bf ff 70 bne 201adc8 <rtems_rfs_block_map_shrink+0x58>
201b00c: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
201b010: 80 a0 60 00 cmp %g1, 0
201b014: 32 80 00 05 bne,a 201b028 <rtems_rfs_block_map_shrink+0x2b8>
201b018: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
{
map->last_map_block = 0;
201b01c: c0 26 60 1c clr [ %i1 + 0x1c ]
map->last_data_block = 0;
201b020: c0 26 60 20 clr [ %i1 + 0x20 ]
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
201b024: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
201b028: 80 a0 a0 00 cmp %g2, 0
201b02c: 02 80 00 06 be 201b044 <rtems_rfs_block_map_shrink+0x2d4>
201b030: 80 a0 80 01 cmp %g2, %g1
201b034: 80 a0 60 00 cmp %g1, 0
201b038: 22 80 00 0e be,a 201b070 <rtems_rfs_block_map_shrink+0x300><== ALWAYS TAKEN
201b03c: c4 06 60 0c ld [ %i1 + 0xc ], %g2
201b040: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
201b044: 3a 80 00 0b bcc,a 201b070 <rtems_rfs_block_map_shrink+0x300>
201b048: c4 06 60 0c ld [ %i1 + 0xc ], %g2
201b04c: 86 00 7f ff add %g1, -1, %g3
201b050: 80 a0 80 03 cmp %g2, %g3
201b054: 12 80 00 0f bne 201b090 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
201b058: 90 10 20 00 clr %o0
201b05c: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
201b060: c4 06 60 0c ld [ %i1 + 0xc ], %g2
201b064: 80 a0 c0 02 cmp %g3, %g2
201b068: 08 80 00 0a bleu 201b090 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
201b06c: 01 00 00 00 nop
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
201b070: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
201b074: c4 26 60 14 st %g2, [ %i1 + 0x14 ]
201b078: 80 a0 a0 00 cmp %g2, 0
201b07c: 02 80 00 04 be 201b08c <rtems_rfs_block_map_shrink+0x31c> <== ALWAYS TAKEN
201b080: c0 26 60 18 clr [ %i1 + 0x18 ]
201b084: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
201b088: c2 26 60 10 st %g1, [ %i1 + 0x10 ] <== NOT EXECUTED
return 0;
201b08c: 90 10 20 00 clr %o0
}
201b090: 81 c7 e0 08 ret
201b094: 91 e8 00 08 restore %g0, %o0, %o0
020205c0 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
20205c0: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
20205c4: 90 10 20 00 clr %o0
20205c8: 7f ff cc 50 call 2013708 <rtems_rfs_trace>
20205cc: 92 10 20 40 mov 0x40, %o1
20205d0: 80 8a 20 ff btst 0xff, %o0
20205d4: 02 80 00 0e be 202060c <rtems_rfs_buffer_bdbuf_release+0x4c><== ALWAYS TAKEN
20205d8: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
20205dc: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED
20205e0: 02 80 00 05 be 20205f4 <rtems_rfs_buffer_bdbuf_release+0x34><== NOT EXECUTED
20205e4: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED
20205e8: 17 00 80 d3 sethi %hi(0x2034c00), %o3 <== NOT EXECUTED
20205ec: 10 80 00 04 b 20205fc <rtems_rfs_buffer_bdbuf_release+0x3c><== NOT EXECUTED
20205f0: 96 12 e1 a8 or %o3, 0x1a8, %o3 ! 2034da8 <rtems_termios_baud_table+0x100><== NOT EXECUTED
20205f4: 17 00 80 c2 sethi %hi(0x2030800), %o3 <== NOT EXECUTED
20205f8: 96 12 e3 10 or %o3, 0x310, %o3 ! 2030b10 <__FUNCTION__.7127+0x438><== NOT EXECUTED
20205fc: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
2020600: 40 00 06 61 call 2021f84 <printf> <== NOT EXECUTED
2020604: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 2034db8 <rtems_termios_baud_table+0x110><== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
2020608: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
202060c: 02 80 00 06 be 2020624 <rtems_rfs_buffer_bdbuf_release+0x64>
2020610: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release_modified (buffer);
2020614: 7f ff d5 3a call 2015afc <rtems_bdbuf_release_modified>
2020618: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
202061c: 10 80 00 05 b 2020630 <rtems_rfs_buffer_bdbuf_release+0x70>
2020620: 80 a0 00 08 cmp %g0, %o0
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
else
sc = rtems_bdbuf_release (buffer);
2020624: 7f ff d5 01 call 2015a28 <rtems_bdbuf_release>
2020628: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
202062c: 80 a0 00 08 cmp %g0, %o0
2020630: b0 60 20 00 subx %g0, 0, %i0
#endif
rc = EIO;
}
return rc;
}
2020634: b0 0e 20 05 and %i0, 5, %i0
2020638: 81 c7 e0 08 ret
202063c: 81 e8 00 00 restore
0201b9fc <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
201b9fc: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
201ba00: 90 10 20 00 clr %o0
201ba04: 7f ff df 41 call 2013708 <rtems_rfs_trace>
201ba08: 92 10 20 10 mov 0x10, %o1
201ba0c: 80 8a 20 ff btst 0xff, %o0
201ba10: 22 80 00 06 be,a 201ba28 <rtems_rfs_buffer_close+0x2c> <== ALWAYS TAKEN
201ba14: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
printf ("rtems-rfs: buffer-close: closing\n");
201ba18: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201ba1c: 40 00 19 f2 call 20221e4 <puts> <== NOT EXECUTED
201ba20: 90 12 22 80 or %o0, 0x280, %o0 ! 2033a80 <CSWTCH.2+0x5a0> <== NOT EXECUTED
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
201ba24: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
201ba28: 90 10 00 18 mov %i0, %o0
201ba2c: 7f ff ff b9 call 201b910 <rtems_rfs_buffer_setblksize>
201ba30: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
201ba34: ba 92 20 00 orcc %o0, 0, %i5
201ba38: 04 80 00 0e ble 201ba70 <rtems_rfs_buffer_close+0x74> <== ALWAYS TAKEN
201ba3c: 90 10 20 00 clr %o0
201ba40: 7f ff df 32 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201ba44: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
201ba48: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ba4c: 02 80 00 09 be 201ba70 <rtems_rfs_buffer_close+0x74> <== NOT EXECUTED
201ba50: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
201ba54: 40 00 1d b8 call 2023134 <strerror> <== NOT EXECUTED
201ba58: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ba5c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201ba60: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201ba64: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201ba68: 40 00 19 47 call 2021f84 <printf> <== NOT EXECUTED
201ba6c: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 2033aa8 <CSWTCH.2+0x5c8> <== NOT EXECUTED
rc, strerror (rc));
if (close (fs->device) < 0)
201ba70: 7f ff b0 a0 call 2007cf0 <close>
201ba74: d0 06 20 0c ld [ %i0 + 0xc ], %o0
201ba78: 80 a2 20 00 cmp %o0, 0
201ba7c: 16 80 00 12 bge 201bac4 <rtems_rfs_buffer_close+0xc8> <== ALWAYS TAKEN
201ba80: 01 00 00 00 nop
{
rc = errno;
201ba84: 40 00 13 e7 call 2020a20 <__errno> <== NOT EXECUTED
201ba88: 01 00 00 00 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
201ba8c: 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;
201ba90: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
201ba94: 7f ff df 1d call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201ba98: 90 10 20 00 clr %o0 <== NOT EXECUTED
201ba9c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201baa0: 02 80 00 09 be 201bac4 <rtems_rfs_buffer_close+0xc8> <== NOT EXECUTED
201baa4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
201baa8: 40 00 1d a3 call 2023134 <strerror> <== NOT EXECUTED
201baac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201bab0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201bab4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201bab8: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201babc: 40 00 19 32 call 2021f84 <printf> <== NOT EXECUTED
201bac0: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 2033ae8 <CSWTCH.2+0x608> <== NOT EXECUTED
rc, strerror (rc));
}
return rc;
}
201bac4: 81 c7 e0 08 ret
201bac8: 91 e8 00 1d restore %g0, %i5, %o0
0201b228 <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
201b228: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
201b22c: c2 06 60 08 ld [ %i1 + 8 ], %g1
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
201b230: ba 10 00 18 mov %i0, %i5
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
201b234: 80 a0 60 00 cmp %g1, 0
201b238: 02 80 00 6e be 201b3f0 <rtems_rfs_buffer_handle_release+0x1c8>
201b23c: b0 10 20 00 clr %i0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
201b240: 90 10 20 00 clr %o0
201b244: 7f ff e1 31 call 2013708 <rtems_rfs_trace>
201b248: 92 10 22 00 mov 0x200, %o1
201b24c: 80 8a 20 ff btst 0xff, %o0
201b250: 22 80 00 18 be,a 201b2b0 <rtems_rfs_buffer_handle_release+0x88><== ALWAYS TAKEN
201b254: d0 06 60 08 ld [ %i1 + 8 ], %o0
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
201b258: c2 0e 40 00 ldub [ %i1 ], %g1 <== NOT EXECUTED
201b25c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201b260: 02 80 00 05 be 201b274 <rtems_rfs_buffer_handle_release+0x4c><== NOT EXECUTED
201b264: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
201b268: 15 00 80 cd sethi %hi(0x2033400), %o2 <== NOT EXECUTED
201b26c: 10 80 00 04 b 201b27c <rtems_rfs_buffer_handle_release+0x54><== NOT EXECUTED
201b270: 94 12 a2 70 or %o2, 0x270, %o2 ! 2033670 <CSWTCH.2+0x190> <== NOT EXECUTED
201b274: 15 00 80 c2 sethi %hi(0x2030800), %o2 <== NOT EXECUTED
201b278: 94 12 a3 10 or %o2, 0x310, %o2 ! 2030b10 <__FUNCTION__.7127+0x438><== 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" : "");
201b27c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
201b280: 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",
201b284: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
201b288: 32 80 00 05 bne,a 201b29c <rtems_rfs_buffer_handle_release+0x74><== NOT EXECUTED
201b28c: 19 00 80 c2 sethi %hi(0x2030800), %o4 <== NOT EXECUTED
201b290: 19 00 80 cd sethi %hi(0x2033400), %o4 <== NOT EXECUTED
201b294: 10 80 00 03 b 201b2a0 <rtems_rfs_buffer_handle_release+0x78><== NOT EXECUTED
201b298: 98 13 22 78 or %o4, 0x278, %o4 ! 2033678 <CSWTCH.2+0x198> <== NOT EXECUTED
201b29c: 98 13 23 10 or %o4, 0x310, %o4 <== NOT EXECUTED
201b2a0: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201b2a4: 40 00 1b 38 call 2021f84 <printf> <== NOT EXECUTED
201b2a8: 90 12 22 88 or %o0, 0x288, %o0 ! 2033688 <CSWTCH.2+0x1a8> <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
if (rtems_rfs_buffer_refs (handle) > 0)
201b2ac: d0 06 60 08 ld [ %i1 + 8 ], %o0 <== NOT EXECUTED
201b2b0: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
201b2b4: 80 a0 60 00 cmp %g1, 0
201b2b8: 04 80 00 03 ble 201b2c4 <rtems_rfs_buffer_handle_release+0x9c><== NEVER TAKEN
201b2bc: 82 00 7f ff add %g1, -1, %g1
rtems_rfs_buffer_refs_down (handle);
201b2c0: c2 22 20 30 st %g1, [ %o0 + 0x30 ]
if (rtems_rfs_buffer_refs (handle) == 0)
201b2c4: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
201b2c8: 80 a0 60 00 cmp %g1, 0
201b2cc: 12 80 00 48 bne 201b3ec <rtems_rfs_buffer_handle_release+0x1c4>
201b2d0: b0 10 20 00 clr %i0
201b2d4: 7f ff f3 d1 call 2018218 <_Chain_Extract>
201b2d8: 01 00 00 00 nop
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
201b2dc: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
if (rtems_rfs_fs_no_local_cache (fs))
201b2e0: f0 07 40 00 ld [ %i5 ], %i0
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
201b2e4: 82 00 7f ff add %g1, -1, %g1
if (rtems_rfs_fs_no_local_cache (fs))
201b2e8: b0 8e 20 02 andcc %i0, 2, %i0
201b2ec: 02 80 00 08 be 201b30c <rtems_rfs_buffer_handle_release+0xe4>
201b2f0: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
{
handle->buffer->user = (void*) 0;
201b2f4: d0 06 60 08 ld [ %i1 + 8 ], %o0
rc = rtems_rfs_buffer_io_release (handle->buffer,
201b2f8: d2 0e 40 00 ldub [ %i1 ], %o1
201b2fc: 40 00 14 b1 call 20205c0 <rtems_rfs_buffer_bdbuf_release>
201b300: c0 22 20 34 clr [ %o0 + 0x34 ]
201b304: 10 80 00 3a b 201b3ec <rtems_rfs_buffer_handle_release+0x1c4>
201b308: b0 10 00 08 mov %o0, %i0
* head.
*
* This code stops a large series of transactions causing all the
* buffers in the cache being held in queues of this file system.
*/
if ((fs->release_count +
201b30c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
201b310: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
201b314: 84 00 80 01 add %g2, %g1, %g2
201b318: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
201b31c: 80 a0 80 01 cmp %g2, %g1
201b320: 2a 80 00 25 bcs,a 201b3b4 <rtems_rfs_buffer_handle_release+0x18c>
201b324: c2 0e 40 00 ldub [ %i1 ], %g1
fs->release_modified_count) >= fs->max_held_buffers)
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
201b328: 90 10 20 00 clr %o0
201b32c: 7f ff e0 f7 call 2013708 <rtems_rfs_trace>
201b330: 92 10 22 00 mov 0x200, %o1
201b334: 80 8a 20 ff btst 0xff, %o0
201b338: 22 80 00 09 be,a 201b35c <rtems_rfs_buffer_handle_release+0x134><== ALWAYS TAKEN
201b33c: c4 07 60 60 ld [ %i5 + 0x60 ], %g2
printf ("rtems-rfs: buffer-release: local cache overflow:"
201b340: d2 07 60 70 ld [ %i5 + 0x70 ], %o1 <== NOT EXECUTED
201b344: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 <== NOT EXECUTED
201b348: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201b34c: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED
201b350: 40 00 1b 0d call 2021f84 <printf> <== NOT EXECUTED
201b354: 90 12 22 c0 or %o0, 0x2c0, %o0 <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
201b358: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
201b35c: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
201b360: 80 a0 80 01 cmp %g2, %g1
201b364: 08 80 00 09 bleu 201b388 <rtems_rfs_buffer_handle_release+0x160>
201b368: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
201b36c: 7f ff c8 86 call 200d584 <_Chain_Get>
201b370: 90 07 60 54 add %i5, 0x54, %o0
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
201b374: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
modified = false;
201b378: 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--;
201b37c: 82 00 7f ff add %g1, -1, %g1
201b380: 10 80 00 08 b 201b3a0 <rtems_rfs_buffer_handle_release+0x178>
201b384: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
201b388: 7f ff c8 7f call 200d584 <_Chain_Get>
201b38c: 90 07 60 64 add %i5, 0x64, %o0
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
201b390: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
modified = true;
201b394: 92 10 20 01 mov 1, %o1
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
201b398: 82 00 7f ff add %g1, -1, %g1
201b39c: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
modified = true;
}
buffer->user = (void*) 0;
201b3a0: c0 22 20 34 clr [ %o0 + 0x34 ]
rc = rtems_rfs_buffer_io_release (buffer, modified);
201b3a4: 40 00 14 87 call 20205c0 <rtems_rfs_buffer_bdbuf_release>
201b3a8: 92 0a 60 01 and %o1, 1, %o1
201b3ac: b0 10 00 08 mov %o0, %i0
}
if (rtems_rfs_buffer_dirty (handle))
201b3b0: c2 0e 40 00 ldub [ %i1 ], %g1
201b3b4: 80 a0 60 00 cmp %g1, 0
201b3b8: 02 80 00 08 be 201b3d8 <rtems_rfs_buffer_handle_release+0x1b0>
201b3bc: 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 );
201b3c0: 7f ff c8 65 call 200d554 <_Chain_Append>
201b3c4: 90 07 60 64 add %i5, 0x64, %o0
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
201b3c8: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
201b3cc: 82 00 60 01 inc %g1
201b3d0: 10 80 00 07 b 201b3ec <rtems_rfs_buffer_handle_release+0x1c4>
201b3d4: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
201b3d8: 7f ff c8 5f call 200d554 <_Chain_Append>
201b3dc: 90 07 60 54 add %i5, 0x54, %o0
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
201b3e0: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
201b3e4: 82 00 60 01 inc %g1
201b3e8: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
}
}
}
handle->buffer = NULL;
201b3ec: c0 26 60 08 clr [ %i1 + 8 ]
}
return rc;
}
201b3f0: 81 c7 e0 08 ret
201b3f4: 81 e8 00 00 restore
0201b3f8 <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)
{
201b3f8: 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))
201b3fc: c2 06 60 08 ld [ %i1 + 8 ], %g1
201b400: 80 a0 60 00 cmp %g1, 0
201b404: 02 80 00 1a be 201b46c <rtems_rfs_buffer_handle_request+0x74>
201b408: 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))
201b40c: 80 a6 a0 00 cmp %i2, 0
201b410: 02 80 00 06 be 201b428 <rtems_rfs_buffer_handle_request+0x30><== NEVER TAKEN
201b414: 90 10 20 00 clr %o0
201b418: c2 06 60 04 ld [ %i1 + 4 ], %g1
201b41c: 80 a0 40 1a cmp %g1, %i2
201b420: 02 80 00 75 be 201b5f4 <rtems_rfs_buffer_handle_request+0x1fc>
201b424: b0 10 20 00 clr %i0
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b428: 7f ff e0 b8 call 2013708 <rtems_rfs_trace>
201b42c: 92 10 21 00 mov 0x100, %o1
201b430: 80 8a 20 ff btst 0xff, %o0
201b434: 22 80 00 07 be,a 201b450 <rtems_rfs_buffer_handle_request+0x58><== ALWAYS TAKEN
201b438: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
201b43c: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
201b440: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201b444: 40 00 1a d0 call 2021f84 <printf> <== NOT EXECUTED
201b448: 90 12 23 00 or %o0, 0x300, %o0 ! 2033700 <CSWTCH.2+0x220> <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
201b44c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201b450: 7f ff ff 76 call 201b228 <rtems_rfs_buffer_handle_release>
201b454: 92 10 00 19 mov %i1, %o1
if (rc > 0)
201b458: b0 92 20 00 orcc %o0, 0, %i0
201b45c: 14 80 00 8b bg 201b688 <rtems_rfs_buffer_handle_request+0x290><== NEVER TAKEN
201b460: 01 00 00 00 nop
return rc;
handle->dirty = false;
201b464: c0 2e 40 00 clrb [ %i1 ]
handle->bnum = 0;
201b468: c0 26 60 04 clr [ %i1 + 4 ]
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b46c: 90 10 20 00 clr %o0
201b470: 7f ff e0 a6 call 2013708 <rtems_rfs_trace>
201b474: 92 10 21 00 mov 0x100, %o1
201b478: 80 8a 20 ff btst 0xff, %o0
201b47c: 22 80 00 07 be,a 201b498 <rtems_rfs_buffer_handle_request+0xa0><== ALWAYS TAKEN
201b480: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
201b484: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201b488: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201b48c: 40 00 1a be call 2021f84 <printf> <== NOT EXECUTED
201b490: 90 12 23 38 or %o0, 0x338, %o0 <== NOT EXECUTED
* currently attached to a handle. If it is share the access. A buffer could
* be shared where different parts of the block have separate functions. An
* example is an inode block and the file system needs to handle 2 inodes in
* the same block at the same time.
*/
if (fs->buffers_count)
201b494: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED
201b498: 80 a0 60 00 cmp %g1, 0
201b49c: 22 80 00 16 be,a 201b4f4 <rtems_rfs_buffer_handle_request+0xfc>
201b4a0: c2 07 40 00 ld [ %i5 ], %g1
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
201b4a4: 90 07 60 44 add %i5, 0x44, %o0
201b4a8: 92 07 60 50 add %i5, 0x50, %o1
201b4ac: 7f ff ff 22 call 201b134 <rtems_rfs_scan_chain>
201b4b0: 94 10 00 1a mov %i2, %o2
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
201b4b4: 80 a2 20 00 cmp %o0, 0
201b4b8: 02 80 00 0e be 201b4f0 <rtems_rfs_buffer_handle_request+0xf8>
201b4bc: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b4c0: 90 10 20 00 clr %o0
201b4c4: 7f ff e0 91 call 2013708 <rtems_rfs_trace>
201b4c8: 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) &&
201b4cc: 80 8a 20 ff btst 0xff, %o0
201b4d0: 22 80 00 09 be,a 201b4f4 <rtems_rfs_buffer_handle_request+0xfc><== ALWAYS TAKEN
201b4d4: c2 07 40 00 ld [ %i5 ], %g1
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
rtems_rfs_buffer_refs (handle) + 1);
201b4d8: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
201b4dc: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201b4e0: d2 00 60 30 ld [ %g1 + 0x30 ], %o1 <== NOT EXECUTED
201b4e4: 90 12 23 60 or %o0, 0x360, %o0 <== NOT EXECUTED
201b4e8: 40 00 1a a7 call 2021f84 <printf> <== NOT EXECUTED
201b4ec: 92 02 60 01 inc %o1 <== NOT EXECUTED
/*
* If the buffer has not been found check the local cache of released
* buffers. There are release and released modified lists to preserve the
* state.
*/
if (!rtems_rfs_fs_no_local_cache (fs) &&
201b4f0: c2 07 40 00 ld [ %i5 ], %g1
201b4f4: 80 88 60 02 btst 2, %g1
201b4f8: 12 80 00 20 bne 201b578 <rtems_rfs_buffer_handle_request+0x180>
201b4fc: c2 06 60 08 ld [ %i1 + 8 ], %g1
201b500: 80 a0 60 00 cmp %g1, 0
201b504: 32 80 00 42 bne,a 201b60c <rtems_rfs_buffer_handle_request+0x214>
201b508: d2 06 60 08 ld [ %i1 + 8 ], %o1
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
201b50c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
201b510: 80 a0 60 00 cmp %g1, 0
201b514: 22 80 00 08 be,a 201b534 <rtems_rfs_buffer_handle_request+0x13c>
201b518: c2 06 60 08 ld [ %i1 + 8 ], %g1
handle->buffer = rtems_rfs_scan_chain (&fs->release,
201b51c: 90 07 60 54 add %i5, 0x54, %o0
201b520: 92 07 60 60 add %i5, 0x60, %o1
201b524: 7f ff ff 04 call 201b134 <rtems_rfs_scan_chain>
201b528: 94 10 00 1a mov %i2, %o2
201b52c: d0 26 60 08 st %o0, [ %i1 + 8 ]
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
201b530: c2 06 60 08 ld [ %i1 + 8 ], %g1
201b534: 80 a0 60 00 cmp %g1, 0
201b538: 32 80 00 10 bne,a 201b578 <rtems_rfs_buffer_handle_request+0x180>
201b53c: c2 06 60 08 ld [ %i1 + 8 ], %g1
201b540: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
201b544: 80 a0 60 00 cmp %g1, 0
201b548: 22 80 00 0c be,a 201b578 <rtems_rfs_buffer_handle_request+0x180>
201b54c: c2 06 60 08 ld [ %i1 + 8 ], %g1
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
201b550: 90 07 60 64 add %i5, 0x64, %o0
201b554: 92 07 60 70 add %i5, 0x70, %o1
201b558: 7f ff fe f7 call 201b134 <rtems_rfs_scan_chain>
201b55c: 94 10 00 1a mov %i2, %o2
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
201b560: 80 a2 20 00 cmp %o0, 0
201b564: 02 80 00 04 be 201b574 <rtems_rfs_buffer_handle_request+0x17c>
201b568: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_buffer_mark_dirty (handle);
201b56c: 82 10 20 01 mov 1, %g1
201b570: c2 2e 40 00 stb %g1, [ %i1 ]
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
201b574: c2 06 60 08 ld [ %i1 + 8 ], %g1
201b578: 80 a0 60 00 cmp %g1, 0
201b57c: 32 80 00 24 bne,a 201b60c <rtems_rfs_buffer_handle_request+0x214>
201b580: d2 06 60 08 ld [ %i1 + 8 ], %o1
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
201b584: 90 10 00 1d mov %i5, %o0
201b588: 92 10 00 1a mov %i2, %o1
201b58c: 94 10 00 1b mov %i3, %o2
201b590: 40 00 13 fb call 202057c <rtems_rfs_buffer_bdbuf_request>
201b594: 96 06 60 08 add %i1, 8, %o3
if (rc > 0)
201b598: b0 92 20 00 orcc %o0, 0, %i0
201b59c: 04 80 00 18 ble 201b5fc <rtems_rfs_buffer_handle_request+0x204><== ALWAYS TAKEN
201b5a0: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b5a4: 7f ff e0 59 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201b5a8: 92 10 21 00 mov 0x100, %o1 <== NOT EXECUTED
201b5ac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b5b0: 02 80 00 11 be 201b5f4 <rtems_rfs_buffer_handle_request+0x1fc><== NOT EXECUTED
201b5b4: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
201b5b8: 22 80 00 05 be,a 201b5cc <rtems_rfs_buffer_handle_request+0x1d4><== NOT EXECUTED
201b5bc: 3b 00 80 cd sethi %hi(0x2033400), %i5 <== NOT EXECUTED
201b5c0: 3b 00 80 cc sethi %hi(0x2033000), %i5 <== NOT EXECUTED
201b5c4: 10 80 00 03 b 201b5d0 <rtems_rfs_buffer_handle_request+0x1d8><== NOT EXECUTED
201b5c8: ba 17 60 a8 or %i5, 0xa8, %i5 ! 20330a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
201b5cc: ba 17 62 f8 or %i5, 0x2f8, %i5 <== NOT EXECUTED
201b5d0: 40 00 1e d9 call 2023134 <strerror> <== NOT EXECUTED
201b5d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201b5d8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201b5dc: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
201b5e0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201b5e4: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201b5e8: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
201b5ec: 40 00 1a 66 call 2021f84 <printf> <== NOT EXECUTED
201b5f0: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
201b5f4: 81 c7 e0 08 ret
201b5f8: 81 e8 00 00 restore
block, read ? "read" : "get", rc, strerror (rc));
return rc;
}
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
201b5fc: c2 06 60 08 ld [ %i1 + 8 ], %g1
201b600: c0 20 60 04 clr [ %g1 + 4 ]
201b604: c0 20 40 00 clr [ %g1 ]
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
201b608: d2 06 60 08 ld [ %i1 + 8 ], %o1
201b60c: 90 07 60 44 add %i5, 0x44, %o0
201b610: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
201b614: 82 00 60 01 inc %g1
201b618: 7f ff c7 cf call 200d554 <_Chain_Append>
201b61c: c2 22 60 30 st %g1, [ %o1 + 0x30 ]
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
201b620: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b624: 90 10 20 00 clr %o0
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
201b628: 82 00 60 01 inc %g1
201b62c: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
handle->buffer->user = (void*) ((intptr_t) block);
201b630: c2 06 60 08 ld [ %i1 + 8 ], %g1
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b634: 92 10 21 00 mov 0x100, %o1
*/
rtems_rfs_buffer_refs_up (handle);
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
handle->buffer->user = (void*) ((intptr_t) block);
201b638: f4 20 60 34 st %i2, [ %g1 + 0x34 ]
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b63c: 7f ff e0 33 call 2013708 <rtems_rfs_trace>
201b640: f4 26 60 04 st %i2, [ %i1 + 4 ]
201b644: 80 8a 20 ff btst 0xff, %o0
201b648: 02 80 00 0f be 201b684 <rtems_rfs_buffer_handle_request+0x28c><== ALWAYS TAKEN
201b64c: 80 a6 e0 00 cmp %i3, 0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
201b650: 22 80 00 05 be,a 201b664 <rtems_rfs_buffer_handle_request+0x26c><== NOT EXECUTED
201b654: 15 00 80 cd sethi %hi(0x2033400), %o2 <== NOT EXECUTED
201b658: 15 00 80 cc sethi %hi(0x2033000), %o2 <== NOT EXECUTED
201b65c: 10 80 00 03 b 201b668 <rtems_rfs_buffer_handle_request+0x270><== NOT EXECUTED
201b660: 94 12 a0 a8 or %o2, 0xa8, %o2 ! 20330a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
201b664: 94 12 a2 f8 or %o2, 0x2f8, %o2 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
201b668: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
201b66c: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201b670: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
201b674: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED
201b678: 90 12 23 d0 or %o0, 0x3d0, %o0 <== NOT EXECUTED
201b67c: 40 00 1a 42 call 2021f84 <printf> <== NOT EXECUTED
201b680: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
201b684: b0 10 20 00 clr %i0
}
201b688: 81 c7 e0 08 ret
201b68c: 81 e8 00 00 restore
0201b690 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
201b690: 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))
201b694: 90 10 20 00 clr %o0
201b698: 7f ff e0 1c call 2013708 <rtems_rfs_trace>
201b69c: 92 10 20 20 mov 0x20, %o1
201b6a0: 80 8a 20 ff btst 0xff, %o0
201b6a4: 22 80 00 07 be,a 201b6c0 <rtems_rfs_buffer_open+0x30> <== ALWAYS TAKEN
201b6a8: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
201b6ac: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b6b0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201b6b4: 40 00 1a 34 call 2021f84 <printf> <== NOT EXECUTED
201b6b8: 90 12 20 10 or %o0, 0x10, %o0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
201b6bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201b6c0: 7f ff b6 17 call 2008f1c <open>
201b6c4: 92 10 20 02 mov 2, %o1
if (fs->device < 0)
201b6c8: 80 a2 20 00 cmp %o0, 0
201b6cc: 16 80 00 0f bge 201b708 <rtems_rfs_buffer_open+0x78> <== ALWAYS TAKEN
201b6d0: d0 26 60 0c st %o0, [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
201b6d4: 90 10 20 00 clr %o0 <== NOT EXECUTED
201b6d8: 7f ff e0 0c call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201b6dc: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201b6e0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b6e4: 12 80 00 04 bne 201b6f4 <rtems_rfs_buffer_open+0x64> <== NOT EXECUTED
201b6e8: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
201b6ec: 81 c7 e0 08 ret <== NOT EXECUTED
201b6f0: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
if (fs->device < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot open file\n");
201b6f4: 90 12 20 38 or %o0, 0x38, %o0 <== NOT EXECUTED
201b6f8: 40 00 1a bb call 20221e4 <puts> <== NOT EXECUTED
201b6fc: 01 00 00 00 nop <== NOT EXECUTED
return ENXIO;
201b700: 81 c7 e0 08 ret <== NOT EXECUTED
201b704: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED
}
if (fstat (fs->device, &st) < 0)
201b708: 7f ff b2 61 call 200808c <fstat>
201b70c: 92 07 bf b8 add %fp, -72, %o1
201b710: 80 a2 20 00 cmp %o0, 0
201b714: 16 80 00 12 bge 201b75c <rtems_rfs_buffer_open+0xcc> <== ALWAYS TAKEN
201b718: c4 07 bf c4 ld [ %fp + -60 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
201b71c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201b720: 7f ff df fa call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201b724: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201b728: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b72c: 02 bf ff f5 be 201b700 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
201b730: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
201b734: 40 00 14 bb call 2020a20 <__errno> <== NOT EXECUTED
201b738: 01 00 00 00 nop <== NOT EXECUTED
}
if (fstat (fs->device, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
201b73c: 40 00 1e 7e call 2023134 <strerror> <== NOT EXECUTED
201b740: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
201b744: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201b748: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201b74c: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b750: 40 00 1a 0d call 2021f84 <printf> <== NOT EXECUTED
201b754: 90 12 20 68 or %o0, 0x68, %o0 ! 2033868 <CSWTCH.2+0x388> <== NOT EXECUTED
201b758: 30 bf ff ea b,a 201b700 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
201b75c: 03 00 00 3c sethi %hi(0xf000), %g1
201b760: 84 08 80 01 and %g2, %g1, %g2
201b764: 03 00 00 18 sethi %hi(0x6000), %g1
201b768: 80 a0 80 01 cmp %g2, %g1
201b76c: 22 80 00 0c be,a 201b79c <rtems_rfs_buffer_open+0x10c> <== ALWAYS TAKEN
201b770: d0 06 60 0c ld [ %i1 + 0xc ], %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
201b774: 90 10 20 00 clr %o0 <== NOT EXECUTED
201b778: 7f ff df e4 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201b77c: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201b780: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b784: 02 bf ff df be 201b700 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
201b788: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
201b78c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201b790: 40 00 19 fd call 2021f84 <printf> <== NOT EXECUTED
201b794: 90 12 20 98 or %o0, 0x98, %o0 <== NOT EXECUTED
201b798: 30 bf ff da b,a 201b700 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
201b79c: 13 10 01 10 sethi %hi(0x40044000), %o1
201b7a0: 94 06 60 10 add %i1, 0x10, %o2
201b7a4: 7f ff b2 8d call 20081d8 <ioctl>
201b7a8: 92 12 62 09 or %o1, 0x209, %o1
/*
* Check that device is registred as a block device and lock it.
*/
rv = rtems_disk_fd_get_disk_device (fs->device, &fs->disk);
if (rv != 0)
201b7ac: 80 a2 20 00 cmp %o0, 0
201b7b0: 02 80 00 09 be 201b7d4 <rtems_rfs_buffer_open+0x144> <== ALWAYS TAKEN
201b7b4: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
201b7b8: 7f ff df d4 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201b7bc: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201b7c0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b7c4: 02 bf ff cf be 201b700 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
201b7c8: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
201b7cc: 10 bf ff cb b 201b6f8 <rtems_rfs_buffer_open+0x68> <== NOT EXECUTED
201b7d0: 90 12 20 d0 or %o0, 0xd0, %o0 ! 20338d0 <CSWTCH.2+0x3f0> <== NOT EXECUTED
#else
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
201b7d4: 92 10 20 20 mov 0x20, %o1
201b7d8: 7f ff df cc call 2013708 <rtems_rfs_trace>
201b7dc: b0 10 20 00 clr %i0
201b7e0: 80 8a 20 ff btst 0xff, %o0
201b7e4: 02 80 00 07 be 201b800 <rtems_rfs_buffer_open+0x170> <== ALWAYS TAKEN
201b7e8: 11 00 80 ce sethi %hi(0x2033800), %o0
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
201b7ec: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 <== NOT EXECUTED
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
201b7f0: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
201b7f4: d4 00 60 20 ld [ %g1 + 0x20 ], %o2 <== NOT EXECUTED
201b7f8: 40 00 19 e3 call 2021f84 <printf> <== NOT EXECUTED
201b7fc: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
201b800: 81 c7 e0 08 ret
201b804: 81 e8 00 00 restore
0201b910 <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
201b910: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
201b914: 90 10 20 00 clr %o0
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
201b918: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
201b91c: 7f ff df 7b call 2013708 <rtems_rfs_trace>
201b920: 92 10 24 00 mov 0x400, %o1
201b924: 80 8a 20 ff btst 0xff, %o0
201b928: 02 80 00 05 be 201b93c <rtems_rfs_buffer_setblksize+0x2c> <== ALWAYS TAKEN
201b92c: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
201b930: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b934: 40 00 19 94 call 2021f84 <printf> <== NOT EXECUTED
201b938: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 20339d0 <CSWTCH.2+0x4f0> <== NOT EXECUTED
rc = rtems_rfs_buffers_release (fs);
201b93c: 7f ff ff d5 call 201b890 <rtems_rfs_buffers_release>
201b940: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
201b944: ba 92 20 00 orcc %o0, 0, %i5
201b948: 04 80 00 0e ble 201b980 <rtems_rfs_buffer_setblksize+0x70><== ALWAYS TAKEN
201b94c: 90 10 20 00 clr %o0
201b950: 7f ff df 6e call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201b954: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
201b958: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b95c: 02 80 00 09 be 201b980 <rtems_rfs_buffer_setblksize+0x70> <== NOT EXECUTED
201b960: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
201b964: 40 00 1d f4 call 2023134 <strerror> <== NOT EXECUTED
201b968: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201b96c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201b970: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201b974: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b978: 40 00 19 83 call 2021f84 <printf> <== NOT EXECUTED
201b97c: 90 12 22 00 or %o0, 0x200, %o0 ! 2033a00 <CSWTCH.2+0x520> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
201b980: 7f ff ff a2 call 201b808 <rtems_rfs_buffer_sync>
201b984: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
201b988: ba 92 20 00 orcc %o0, 0, %i5
201b98c: 04 80 00 0e ble 201b9c4 <rtems_rfs_buffer_setblksize+0xb4><== ALWAYS TAKEN
201b990: 90 10 20 00 clr %o0
201b994: 7f ff df 5d call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201b998: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
201b99c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b9a0: 22 80 00 0a be,a 201b9c8 <rtems_rfs_buffer_setblksize+0xb8><== NOT EXECUTED
201b9a4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
201b9a8: 40 00 1d e3 call 2023134 <strerror> <== NOT EXECUTED
201b9ac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201b9b0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201b9b4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201b9b8: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b9bc: 40 00 19 72 call 2021f84 <printf> <== NOT EXECUTED
201b9c0: 90 12 22 40 or %o0, 0x240, %o0 ! 2033a40 <CSWTCH.2+0x560> <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
201b9c4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
201b9c8: 13 20 01 10 sethi %hi(0x80044000), %o1
201b9cc: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
201b9d0: 92 12 62 04 or %o1, 0x204, %o1
201b9d4: 9f c0 40 00 call %g1
201b9d8: 94 07 a0 48 add %fp, 0x48, %o2
if (rc < 0)
201b9dc: b0 92 20 00 orcc %o0, 0, %i0
201b9e0: 16 80 00 05 bge 201b9f4 <rtems_rfs_buffer_setblksize+0xe4><== ALWAYS TAKEN
201b9e4: 01 00 00 00 nop
rc = errno;
201b9e8: 40 00 14 0e call 2020a20 <__errno> <== NOT EXECUTED
201b9ec: 01 00 00 00 nop <== NOT EXECUTED
201b9f0: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
#endif
return rc;
}
201b9f4: 81 c7 e0 08 ret
201b9f8: 81 e8 00 00 restore
0201b808 <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
201b808: 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))
201b80c: 90 10 20 00 clr %o0
201b810: 7f ff df be call 2013708 <rtems_rfs_trace>
201b814: 92 10 20 20 mov 0x20, %o1
201b818: 80 8a 20 ff btst 0xff, %o0
201b81c: 22 80 00 06 be,a 201b834 <rtems_rfs_buffer_sync+0x2c> <== ALWAYS TAKEN
201b820: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
printf ("rtems-rfs: buffer-sync: syncing\n");
201b824: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b828: 40 00 1a 6f call 20221e4 <puts> <== NOT EXECUTED
201b82c: 90 12 21 30 or %o0, 0x130, %o0 ! 2033930 <CSWTCH.2+0x450> <== NOT EXECUTED
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
201b830: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
201b834: 7f ff e9 1c call 2015ca4 <rtems_bdbuf_syncdev>
201b838: ba 10 20 00 clr %i5
if (sc != RTEMS_SUCCESSFUL)
201b83c: 80 a2 20 00 cmp %o0, 0
201b840: 02 80 00 0f be 201b87c <rtems_rfs_buffer_sync+0x74> <== ALWAYS TAKEN
201b844: b8 10 00 08 mov %o0, %i4
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
201b848: 90 10 20 00 clr %o0 <== NOT EXECUTED
201b84c: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
201b850: 7f ff df ae call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201b854: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
201b858: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b85c: 22 80 00 09 be,a 201b880 <rtems_rfs_buffer_sync+0x78> <== NOT EXECUTED
201b860: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
201b864: 7f ff b1 44 call 2007d74 <rtems_status_text> <== NOT EXECUTED
201b868: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201b86c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
201b870: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b874: 40 00 19 c4 call 2021f84 <printf> <== NOT EXECUTED
201b878: 90 12 21 50 or %o0, 0x150, %o0 ! 2033950 <CSWTCH.2+0x470> <== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
201b87c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
201b880: 7f ff a3 ec call 2004830 <rtems_disk_release>
201b884: b0 10 00 1d mov %i5, %i0
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
201b888: 81 c7 e0 08 ret
201b88c: 81 e8 00 00 restore
0201b890 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
201b890: 9d e3 bf a0 save %sp, -96, %sp
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
201b894: 90 10 20 00 clr %o0
201b898: 92 10 20 40 mov 0x40, %o1
201b89c: 7f ff df 9b call 2013708 <rtems_rfs_trace>
201b8a0: ba 10 00 18 mov %i0, %i5
201b8a4: 80 8a 20 ff btst 0xff, %o0
201b8a8: 02 80 00 09 be 201b8cc <rtems_rfs_buffers_release+0x3c> <== ALWAYS TAKEN
201b8ac: 92 07 60 60 add %i5, 0x60, %o1
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
201b8b0: d2 06 20 50 ld [ %i0 + 0x50 ], %o1 <== NOT EXECUTED
201b8b4: d4 06 20 60 ld [ %i0 + 0x60 ], %o2 <== NOT EXECUTED
201b8b8: d6 06 20 70 ld [ %i0 + 0x70 ], %o3 <== NOT EXECUTED
201b8bc: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b8c0: 40 00 19 b1 call 2021f84 <printf> <== NOT EXECUTED
201b8c4: 90 12 21 80 or %o0, 0x180, %o0 ! 2033980 <CSWTCH.2+0x4a0> <== NOT EXECUTED
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
201b8c8: 92 07 60 60 add %i5, 0x60, %o1 <== NOT EXECUTED
201b8cc: 94 10 20 00 clr %o2
201b8d0: 7f ff fd f6 call 201b0a8 <rtems_rfs_release_chain>
201b8d4: 90 07 60 54 add %i5, 0x54, %o0
201b8d8: 82 38 00 08 xnor %g0, %o0, %g1
201b8dc: 83 38 60 1f sra %g1, 0x1f, %g1
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
201b8e0: 92 07 60 70 add %i5, 0x70, %o1
201b8e4: b0 0a 00 01 and %o0, %g1, %i0
201b8e8: 94 10 20 01 mov 1, %o2
201b8ec: 7f ff fd ef call 201b0a8 <rtems_rfs_release_chain>
201b8f0: 90 07 60 64 add %i5, 0x64, %o0
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
201b8f4: 80 a6 20 00 cmp %i0, 0
201b8f8: 12 80 00 04 bne 201b908 <rtems_rfs_buffers_release+0x78> <== NEVER TAKEN
201b8fc: 80 a2 20 00 cmp %o0, 0
201b900: 34 80 00 02 bg,a 201b908 <rtems_rfs_buffers_release+0x78><== NEVER TAKEN
201b904: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rrc = rc;
return rrc;
}
201b908: 81 c7 e0 08 ret
201b90c: 81 e8 00 00 restore
0201bfec <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)
{
201bfec: 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))
201bff0: 90 10 20 00 clr %o0
201bff4: 7f ff dd c5 call 2013708 <rtems_rfs_trace>
201bff8: 13 08 00 00 sethi %hi(0x20000000), %o1
201bffc: 80 8a 20 ff btst 0xff, %o0
201c000: 02 80 00 14 be 201c050 <rtems_rfs_dir_add_entry+0x64> <== ALWAYS TAKEN
201c004: a6 07 bf b0 add %fp, -80, %l3
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
201c008: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201c00c: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201c010: ba 10 00 1a mov %i2, %i5 <== NOT EXECUTED
201c014: 90 12 21 f0 or %o0, 0x1f0, %o0 <== NOT EXECUTED
201c018: 40 00 17 db call 2021f84 <printf> <== NOT EXECUTED
201c01c: a0 06 80 1b add %i2, %i3, %l0 <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
201c020: 10 80 00 05 b 201c034 <rtems_rfs_dir_add_entry+0x48> <== NOT EXECUTED
201c024: 80 a7 40 10 cmp %i5, %l0 <== NOT EXECUTED
printf ("%c", name[c]);
201c028: 40 00 18 41 call 202212c <putchar> <== NOT EXECUTED
201c02c: 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++)
201c030: 80 a7 40 10 cmp %i5, %l0 <== NOT EXECUTED
201c034: 32 bf ff fd bne,a 201c028 <rtems_rfs_dir_add_entry+0x3c> <== NOT EXECUTED
201c038: d0 4f 40 00 ldsb [ %i5 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
201c03c: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201c040: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201c044: 40 00 17 d0 call 2021f84 <printf> <== NOT EXECUTED
201c048: 90 12 22 20 or %o0, 0x220, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
201c04c: a6 07 bf b0 add %fp, -80, %l3 <== NOT EXECUTED
201c050: 90 10 00 18 mov %i0, %o0
201c054: 92 10 00 19 mov %i1, %o1
201c058: 7f ff f8 fb call 201a444 <rtems_rfs_block_map_open>
201c05c: 94 10 00 13 mov %l3, %o2
if (rc > 0)
201c060: ba 92 20 00 orcc %o0, 0, %i5
201c064: 34 80 00 c5 bg,a 201c378 <rtems_rfs_dir_add_entry+0x38c> <== NEVER TAKEN
201c068: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201c06c: 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;
201c070: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201c074: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201c078: 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;
201c07c: c0 27 bf 98 clr [ %fp + -104 ]
bpos->boff = 0;
201c080: c0 27 bf 9c clr [ %fp + -100 ]
bpos->block = 0;
201c084: c0 27 bf a0 clr [ %fp + -96 ]
201c088: a8 15 23 ff or %l4, 0x3ff, %l4
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
201c08c: aa 06 e0 0a add %i3, 0xa, %l5
/*
* Locate the first block. If an error the block will be 0. If the map is
* empty which happens when creating a directory and adding the first entry
* the seek will return ENXIO. In this case we need to grow the directory.
*/
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
201c090: 90 10 00 18 mov %i0, %o0
201c094: 92 10 00 13 mov %l3, %o1
201c098: 94 07 bf 98 add %fp, -104, %o2
201c09c: 7f ff f9 bf call 201a798 <rtems_rfs_block_map_find>
201c0a0: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
201c0a4: ba 92 20 00 orcc %o0, 0, %i5
201c0a8: 04 80 00 29 ble 201c14c <rtems_rfs_dir_add_entry+0x160>
201c0ac: 80 a7 60 06 cmp %i5, 6
{
if (rc != ENXIO)
201c0b0: 02 80 00 0f be 201c0ec <rtems_rfs_dir_add_entry+0x100> <== ALWAYS TAKEN
201c0b4: 90 10 00 18 mov %i0, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
201c0b8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c0bc: 7f ff dd 93 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201c0c0: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
201c0c4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c0c8: 22 80 00 a6 be,a 201c360 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
201c0cc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
201c0d0: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201c0d4: 40 00 1c 18 call 2023134 <strerror> <== NOT EXECUTED
201c0d8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c0dc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201c0e0: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201c0e4: 10 80 00 15 b 201c138 <rtems_rfs_dir_add_entry+0x14c> <== NOT EXECUTED
201c0e8: 90 12 22 30 or %o0, 0x230, %o0 ! 2033e30 <CSWTCH.2+0x950> <== NOT EXECUTED
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
201c0ec: 92 10 00 13 mov %l3, %o1
201c0f0: 94 10 20 01 mov 1, %o2
201c0f4: 7f ff fa 2f call 201a9b0 <rtems_rfs_block_map_grow>
201c0f8: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
201c0fc: ba 92 20 00 orcc %o0, 0, %i5
201c100: 04 80 00 14 ble 201c150 <rtems_rfs_dir_add_entry+0x164> <== ALWAYS TAKEN
201c104: a0 10 20 00 clr %l0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
201c108: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c10c: 7f ff dd 7f call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201c110: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
201c114: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c118: 22 80 00 92 be,a 201c360 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
201c11c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
201c120: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201c124: 40 00 1c 04 call 2023134 <strerror> <== NOT EXECUTED
201c128: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c12c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201c130: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201c134: 90 12 22 78 or %o0, 0x278, %o0 ! 2033e78 <CSWTCH.2+0x998> <== NOT EXECUTED
201c138: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201c13c: 40 00 17 92 call 2021f84 <printf> <== NOT EXECUTED
201c140: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201c144: 10 80 00 87 b 201c360 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
201c148: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
201c14c: a0 10 20 01 mov 1, %l0
}
read = false;
}
bpos.bno++;
201c150: c2 07 bf 98 ld [ %fp + -104 ], %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
201c154: d4 07 bf 94 ld [ %fp + -108 ], %o2
}
read = false;
}
bpos.bno++;
201c158: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
201c15c: a0 0c 20 ff and %l0, 0xff, %l0
}
read = false;
}
bpos.bno++;
201c160: c2 27 bf 98 st %g1, [ %fp + -104 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
201c164: 90 10 00 18 mov %i0, %o0
201c168: 92 07 bf a4 add %fp, -92, %o1
201c16c: 7f ff fc a3 call 201b3f8 <rtems_rfs_buffer_handle_request>
201c170: 96 10 00 10 mov %l0, %o3
if (rc > 0)
201c174: ba 92 20 00 orcc %o0, 0, %i5
201c178: 04 80 00 0f ble 201c1b4 <rtems_rfs_dir_add_entry+0x1c8> <== ALWAYS TAKEN
201c17c: c2 07 bf ac ld [ %fp + -84 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
201c180: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c184: 7f ff dd 61 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201c188: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
201c18c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c190: 22 80 00 74 be,a 201c360 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
201c194: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
201c198: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201c19c: 40 00 1b e6 call 2023134 <strerror> <== NOT EXECUTED
201c1a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c1a4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201c1a8: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201c1ac: 10 bf ff e3 b 201c138 <rtems_rfs_dir_add_entry+0x14c> <== NOT EXECUTED
201c1b0: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 2033ec0 <CSWTCH.2+0x9e0> <== NOT EXECUTED
break;
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
201c1b4: 80 a4 20 00 cmp %l0, 0
201c1b8: 12 80 00 06 bne 201c1d0 <rtems_rfs_dir_add_entry+0x1e4>
201c1bc: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
201c1c0: d4 06 20 08 ld [ %i0 + 8 ], %o2
201c1c4: 90 10 00 1d mov %i5, %o0
201c1c8: 40 00 16 f1 call 2021d8c <memset>
201c1cc: 92 10 20 ff mov 0xff, %o1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201c1d0: c2 06 20 08 ld [ %i0 + 8 ], %g1
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
201c1d4: a2 10 20 00 clr %l1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201c1d8: 10 80 00 5d b 201c34c <rtems_rfs_dir_add_entry+0x360>
201c1dc: 84 00 7f f6 add %g1, -10, %g2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201c1e0: e0 0f 60 08 ldub [ %i5 + 8 ], %l0
eino = rtems_rfs_dir_entry_ino (entry);
201c1e4: e4 0f 40 00 ldub [ %i5 ], %l2
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201c1e8: a1 2c 20 08 sll %l0, 8, %l0
201c1ec: a0 14 00 03 or %l0, %g3, %l0
eino = rtems_rfs_dir_entry_ino (entry);
201c1f0: c6 0f 60 01 ldub [ %i5 + 1 ], %g3
201c1f4: a5 2c a0 18 sll %l2, 0x18, %l2
201c1f8: 87 28 e0 10 sll %g3, 0x10, %g3
201c1fc: a4 14 80 03 or %l2, %g3, %l2
201c200: c6 0f 60 03 ldub [ %i5 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201c204: 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);
201c208: a4 14 80 03 or %l2, %g3, %l2
201c20c: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
201c210: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201c214: 12 80 00 2a bne 201c2bc <rtems_rfs_dir_add_entry+0x2d0>
201c218: a4 14 80 03 or %l2, %g3, %l2
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
201c21c: a2 20 40 11 sub %g1, %l1, %l1
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
201c220: 80 a5 40 11 cmp %l5, %l1
201c224: 3a bf ff 9c bcc,a 201c094 <rtems_rfs_dir_add_entry+0xa8> <== NEVER TAKEN
201c228: 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);
201c22c: 92 10 00 1b mov %i3, %o1
201c230: 40 00 11 10 call 2020670 <rtems_rfs_dir_hash>
201c234: 90 10 00 1a mov %i2, %o0
rtems_rfs_dir_set_entry_hash (entry, hash);
201c238: 83 32 20 18 srl %o0, 0x18, %g1
201c23c: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
201c240: 83 32 20 10 srl %o0, 0x10, %g1
201c244: c2 2f 60 05 stb %g1, [ %i5 + 5 ]
201c248: 83 32 20 08 srl %o0, 8, %g1
201c24c: c2 2f 60 06 stb %g1, [ %i5 + 6 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
201c250: 83 37 20 18 srl %i4, 0x18, %g1
201c254: c2 2f 40 00 stb %g1, [ %i5 ]
201c258: 83 37 20 10 srl %i4, 0x10, %g1
201c25c: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
201c260: 83 37 20 08 srl %i4, 8, %g1
201c264: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
rtems_rfs_dir_set_entry_length (entry,
201c268: 82 06 e0 0a add %i3, 0xa, %g1
201c26c: 85 30 60 08 srl %g1, 8, %g2
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
201c270: d0 2f 60 07 stb %o0, [ %i5 + 7 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
201c274: c4 2f 60 08 stb %g2, [ %i5 + 8 ]
201c278: c2 2f 60 09 stb %g1, [ %i5 + 9 ]
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
201c27c: 94 10 00 1b mov %i3, %o2
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
201c280: f8 2f 60 03 stb %i4, [ %i5 + 3 ]
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
201c284: 90 07 60 0a add %i5, 0xa, %o0
201c288: 40 00 16 32 call 2021b50 <memcpy>
201c28c: 92 10 00 1a mov %i2, %o1
rtems_rfs_buffer_mark_dirty (&buffer);
201c290: 82 10 20 01 mov 1, %g1
rtems_rfs_buffer_handle_close (fs, &buffer);
201c294: 92 07 bf a4 add %fp, -92, %o1
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
rtems_rfs_buffer_mark_dirty (&buffer);
201c298: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
201c29c: 7f ff fe 0c call 201bacc <rtems_rfs_buffer_handle_close>
201c2a0: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
201c2a4: 90 10 00 18 mov %i0, %o0
201c2a8: 92 07 bf b0 add %fp, -80, %o1
201c2ac: 7f ff f8 c7 call 201a5c8 <rtems_rfs_block_map_close>
201c2b0: ba 10 20 00 clr %i5
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
201c2b4: 81 c7 e0 08 ret
201c2b8: 91 e8 00 1d restore %g0, %i5, %o0
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201c2bc: 80 a4 20 0a cmp %l0, 0xa
201c2c0: 04 80 00 0d ble 201c2f4 <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
201c2c4: 90 10 20 00 clr %o0
201c2c8: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
201c2cc: 80 a4 00 03 cmp %l0, %g3
201c2d0: 1a 80 00 09 bcc 201c2f4 <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
201c2d4: 80 a4 a0 00 cmp %l2, 0
201c2d8: 02 80 00 07 be 201c2f4 <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
201c2dc: 01 00 00 00 nop
201c2e0: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
201c2e4: 80 a4 80 03 cmp %l2, %g3
201c2e8: 28 80 00 18 bleu,a 201c348 <rtems_rfs_dir_add_entry+0x35c><== ALWAYS TAKEN
201c2ec: ba 07 40 10 add %i5, %l0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
201c2f0: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c2f4: 7f ff dd 05 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201c2f8: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
201c2fc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c300: 02 80 00 0a be 201c328 <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
201c304: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
201c308: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201c30c: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201c310: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
201c314: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED
201c318: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
201c31c: 40 00 17 1a call 2021f84 <printf> <== NOT EXECUTED
201c320: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
rtems_rfs_inode_ino (dir), elength, eino, offset);
rtems_rfs_buffer_handle_close (fs, &buffer);
201c324: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
201c328: 7f ff fd e9 call 201bacc <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201c32c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
201c330: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c334: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201c338: 7f ff f8 a4 call 201a5c8 <rtems_rfs_block_map_close> <== NOT EXECUTED
201c33c: 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;
}
201c340: 81 c7 e0 08 ret <== NOT EXECUTED
201c344: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
offset += elength;
201c348: 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))
201c34c: 80 a4 40 02 cmp %l1, %g2
201c350: 2a bf ff a4 bcs,a 201c1e0 <rtems_rfs_dir_add_entry+0x1f4><== ALWAYS TAKEN
201c354: c6 0f 60 09 ldub [ %i5 + 9 ], %g3
/*
* Locate the first block. If an error the block will be 0. If the map is
* empty which happens when creating a directory and adding the first entry
* the seek will return ENXIO. In this case we need to grow the directory.
*/
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
201c358: 10 bf ff 4f b 201c094 <rtems_rfs_dir_add_entry+0xa8> <== NOT EXECUTED
201c35c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201c360: 7f ff fd db call 201bacc <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201c364: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
201c368: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c36c: 7f ff f8 97 call 201a5c8 <rtems_rfs_block_map_close> <== NOT EXECUTED
201c370: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
return rc;
}
201c374: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
201c378: 81 c7 e0 08 ret <== NOT EXECUTED
201c37c: 81 e8 00 00 restore <== NOT EXECUTED
0201c380 <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)
{
201c380: 9d e3 bf 38 save %sp, -200, %sp
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201c384: 90 10 20 00 clr %o0
201c388: 13 10 00 00 sethi %hi(0x40000000), %o1
201c38c: 7f ff dc df call 2013708 <rtems_rfs_trace>
201c390: ba 10 00 18 mov %i0, %i5
201c394: 80 8a 20 ff btst 0xff, %o0
201c398: 02 80 00 09 be 201c3bc <rtems_rfs_dir_del_entry+0x3c> <== ALWAYS TAKEN
201c39c: aa 07 bf b0 add %fp, -80, %l5
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
201c3a0: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201c3a4: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201c3a8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201c3ac: 90 12 23 50 or %o0, 0x350, %o0 <== NOT EXECUTED
201c3b0: 40 00 16 f5 call 2021f84 <printf> <== NOT EXECUTED
201c3b4: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
201c3b8: aa 07 bf b0 add %fp, -80, %l5 <== NOT EXECUTED
201c3bc: 90 10 00 1d mov %i5, %o0
201c3c0: 92 10 00 19 mov %i1, %o1
201c3c4: 7f ff f8 20 call 201a444 <rtems_rfs_block_map_open>
201c3c8: 94 10 00 15 mov %l5, %o2
if (rc > 0)
201c3cc: b0 92 20 00 orcc %o0, 0, %i0
201c3d0: 14 80 00 c4 bg 201c6e0 <rtems_rfs_dir_del_entry+0x360> <== NEVER TAKEN
201c3d4: ac 07 bf a0 add %fp, -96, %l6
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
201c3d8: 90 10 00 1d mov %i5, %o0
201c3dc: 92 10 00 15 mov %l5, %o1
201c3e0: 94 10 20 00 clr %o2
201c3e4: 96 10 00 1b mov %i3, %o3
201c3e8: 7f ff f9 48 call 201a908 <rtems_rfs_block_map_seek>
201c3ec: 98 10 00 16 mov %l6, %o4
if (rc > 0)
201c3f0: b0 92 20 00 orcc %o0, 0, %i0
201c3f4: 04 80 00 06 ble 201c40c <rtems_rfs_dir_del_entry+0x8c> <== ALWAYS TAKEN
201c3f8: 80 a6 20 06 cmp %i0, 6
{
if (rc == ENXIO)
201c3fc: 22 80 00 b6 be,a 201c6d4 <rtems_rfs_dir_del_entry+0x354> <== NOT EXECUTED
201c400: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
201c404: 10 80 00 b5 b 201c6d8 <rtems_rfs_dir_del_entry+0x358> <== NOT EXECUTED
201c408: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
201c40c: 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)
201c410: 29 00 00 3f sethi %hi(0xfc00), %l4
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
201c414: 2f 00 80 cf sethi %hi(0x2033c00), %l7
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201c418: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201c41c: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201c420: c0 27 bf ac clr [ %fp + -84 ]
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
201c424: b0 10 20 00 clr %i0
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
201c428: 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)
201c42c: a8 15 23 ff or %l4, 0x3ff, %l4
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
201c430: 10 80 00 c1 b 201c734 <rtems_rfs_dir_del_entry+0x3b4>
201c434: ae 15 e3 d8 or %l7, 0x3d8, %l7
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
201c438: 90 10 00 1d mov %i5, %o0
201c43c: 92 07 bf a4 add %fp, -92, %o1
201c440: 7f ff fb ee call 201b3f8 <rtems_rfs_buffer_handle_request>
201c444: 96 10 20 01 mov 1, %o3
if (rc > 0)
201c448: a4 92 20 00 orcc %o0, 0, %l2
201c44c: 04 80 00 13 ble 201c498 <rtems_rfs_dir_del_entry+0x118> <== ALWAYS TAKEN
201c450: 80 a4 e0 00 cmp %l3, 0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201c454: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c458: 7f ff dc ac call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201c45c: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
201c460: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c464: 22 80 00 b9 be,a 201c748 <rtems_rfs_dir_del_entry+0x3c8> <== NOT EXECUTED
201c468: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
201c46c: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201c470: 40 00 1b 31 call 2023134 <strerror> <== NOT EXECUTED
201c474: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
201c478: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201c47c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201c480: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
201c484: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201c488: 40 00 16 bf call 2021f84 <printf> <== NOT EXECUTED
201c48c: 90 12 23 90 or %o0, 0x390, %o0 ! 2033f90 <CSWTCH.2+0xab0> <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201c490: 10 80 00 ae b 201c748 <rtems_rfs_dir_del_entry+0x3c8> <== NOT EXECUTED
201c494: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
201c498: 12 80 00 06 bne 201c4b0 <rtems_rfs_dir_del_entry+0x130> <== NEVER TAKEN
201c49c: a0 10 20 00 clr %l0
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
201c4a0: d2 07 60 08 ld [ %i5 + 8 ], %o1
201c4a4: 40 00 47 39 call 202e188 <.urem>
201c4a8: 90 10 00 1b mov %i3, %o0
201c4ac: a0 10 00 08 mov %o0, %l0
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
201c4b0: c2 07 bf ac ld [ %fp + -84 ], %g1
201c4b4: f8 00 60 1c ld [ %g1 + 0x1c ], %i4
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201c4b8: c2 07 60 08 ld [ %i5 + 8 ], %g1
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
201c4bc: b8 07 00 10 add %i4, %l0, %i4
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201c4c0: 10 80 00 8d b 201c6f4 <rtems_rfs_dir_del_entry+0x374>
201c4c4: 84 00 7f f6 add %g1, -10, %g2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201c4c8: e2 0f 20 08 ldub [ %i4 + 8 ], %l1
eino = rtems_rfs_dir_entry_ino (entry);
201c4cc: d6 0f 00 00 ldub [ %i4 ], %o3
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201c4d0: a3 2c 60 08 sll %l1, 8, %l1
201c4d4: a2 14 40 03 or %l1, %g3, %l1
eino = rtems_rfs_dir_entry_ino (entry);
201c4d8: c6 0f 20 01 ldub [ %i4 + 1 ], %g3
201c4dc: 97 2a e0 18 sll %o3, 0x18, %o3
201c4e0: 87 28 e0 10 sll %g3, 0x10, %g3
201c4e4: 96 12 c0 03 or %o3, %g3, %o3
201c4e8: c6 0f 20 03 ldub [ %i4 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201c4ec: 80 a4 40 14 cmp %l1, %l4
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
201c4f0: 96 12 c0 03 or %o3, %g3, %o3
201c4f4: c6 0f 20 02 ldub [ %i4 + 2 ], %g3
201c4f8: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201c4fc: 02 80 00 81 be 201c700 <rtems_rfs_dir_del_entry+0x380> <== NEVER TAKEN
201c500: 96 12 c0 03 or %o3, %g3, %o3
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201c504: 80 a4 60 0a cmp %l1, 0xa
201c508: 24 80 00 0d ble,a 201c53c <rtems_rfs_dir_del_entry+0x1bc><== NEVER TAKEN
201c50c: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
201c510: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
201c514: 80 a4 40 03 cmp %l1, %g3
201c518: 1a 80 00 08 bcc 201c538 <rtems_rfs_dir_del_entry+0x1b8> <== NEVER TAKEN
201c51c: 80 a2 e0 00 cmp %o3, 0
201c520: 22 80 00 07 be,a 201c53c <rtems_rfs_dir_del_entry+0x1bc> <== NEVER TAKEN
201c524: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
201c528: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
201c52c: 80 a2 c0 03 cmp %o3, %g3
201c530: 08 80 00 11 bleu 201c574 <rtems_rfs_dir_del_entry+0x1f4> <== ALWAYS TAKEN
201c534: 80 a6 80 0b cmp %i2, %o3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201c538: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
201c53c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c540: 7f ff dc 72 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201c544: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
201c548: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c54c: 02 80 00 87 be 201c768 <rtems_rfs_dir_del_entry+0x3e8> <== NOT EXECUTED
201c550: d6 07 bf 9c ld [ %fp + -100 ], %o3 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
201c554: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201c558: d8 07 bf a0 ld [ %fp + -96 ], %o4 <== NOT EXECUTED
201c55c: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
201c560: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
201c564: 40 00 16 88 call 2021f84 <printf> <== NOT EXECUTED
201c568: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
201c56c: 10 80 00 71 b 201c730 <rtems_rfs_dir_del_entry+0x3b0> <== NOT EXECUTED
201c570: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
201c574: 12 80 00 5d bne 201c6e8 <rtems_rfs_dir_del_entry+0x368> <== NEVER TAKEN
201c578: 80 a4 e0 00 cmp %l3, 0
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
memmove (entry, entry + elength, remaining);
201c57c: 92 07 00 11 add %i4, %l1, %o1
201c580: 90 10 00 1c mov %i4, %o0
}
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
201c584: b6 04 00 11 add %l0, %l1, %i3
201c588: b6 20 40 1b sub %g1, %i3, %i3
memmove (entry, entry + elength, remaining);
201c58c: 40 00 15 ae call 2021c44 <memmove>
201c590: 94 10 00 1b mov %i3, %o2
memset (entry + remaining, 0xff, elength);
201c594: 90 07 00 1b add %i4, %i3, %o0
201c598: 92 10 20 ff mov 0xff, %o1
201c59c: 40 00 15 fc call 2021d8c <memset>
201c5a0: 94 10 00 11 mov %l1, %o2
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
201c5a4: c4 0f 20 08 ldub [ %i4 + 8 ], %g2
201c5a8: c2 0f 20 09 ldub [ %i4 + 9 ], %g1
201c5ac: 85 28 a0 08 sll %g2, 8, %g2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201c5b0: 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);
201c5b4: b8 10 80 01 or %g2, %g1, %i4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201c5b8: 7f ff dc 54 call 2013708 <rtems_rfs_trace>
201c5bc: 13 10 00 00 sethi %hi(0x40000000), %o1
201c5c0: 80 8a 20 ff btst 0xff, %o0
201c5c4: 02 80 00 1a be 201c62c <rtems_rfs_dir_del_entry+0x2ac> <== ALWAYS TAKEN
201c5c8: 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");
201c5cc: 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: "
201c5d0: d6 07 bf a0 ld [ %fp + -96 ], %o3 <== NOT EXECUTED
201c5d4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201c5d8: 12 80 00 08 bne 201c5f8 <rtems_rfs_dir_del_entry+0x278> <== NOT EXECUTED
201c5dc: 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");
201c5e0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
201c5e4: 12 80 00 06 bne 201c5fc <rtems_rfs_dir_del_entry+0x27c> <== NOT EXECUTED
201c5e8: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
201c5ec: 1b 00 80 ca sethi %hi(0x2032800), %o5 <== NOT EXECUTED
201c5f0: 10 80 00 08 b 201c610 <rtems_rfs_dir_del_entry+0x290> <== NOT EXECUTED
201c5f4: 9a 13 63 28 or %o5, 0x328, %o5 ! 2032b28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
201c5f8: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
201c5fc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201c600: 02 bf ff fc be 201c5f0 <rtems_rfs_dir_del_entry+0x270> <== NOT EXECUTED
201c604: 1b 00 80 ca sethi %hi(0x2032800), %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: "
201c608: 1b 00 80 c3 sethi %hi(0x2030c00), %o5 <== NOT EXECUTED
201c60c: 9a 13 60 10 or %o5, 0x10, %o5 ! 2030c10 <__FUNCTION__.7127+0x538><== NOT EXECUTED
201c610: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c614: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201c618: 90 12 20 28 or %o0, 0x28, %o0 <== NOT EXECUTED
201c61c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201c620: 40 00 16 59 call 2021f84 <printf> <== NOT EXECUTED
201c624: 98 10 00 10 mov %l0, %o4 <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
201c628: 03 3f ff c0 sethi %hi(0xffff0000), %g1 <== NOT EXECUTED
201c62c: b8 38 40 1c xnor %g1, %i4, %i4
201c630: 80 a7 20 00 cmp %i4, 0
201c634: 12 80 00 23 bne 201c6c0 <rtems_rfs_dir_del_entry+0x340>
201c638: 80 a4 20 00 cmp %l0, 0
201c63c: 12 80 00 21 bne 201c6c0 <rtems_rfs_dir_del_entry+0x340> <== ALWAYS TAKEN
201c640: c2 07 bf c0 ld [ %fp + -64 ], %g1
(eoffset == 0) && rtems_rfs_block_map_last (&map))
201c644: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201c648: 12 80 00 05 bne 201c65c <rtems_rfs_dir_del_entry+0x2dc> <== NOT EXECUTED
201c64c: c4 07 bf b8 ld [ %fp + -72 ], %g2 <== NOT EXECUTED
201c650: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
201c654: 02 80 00 07 be 201c670 <rtems_rfs_dir_del_entry+0x2f0> <== NOT EXECUTED
201c658: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c65c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
201c660: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201c664: 12 80 00 18 bne 201c6c4 <rtems_rfs_dir_del_entry+0x344> <== NOT EXECUTED
201c668: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
201c66c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c670: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201c674: 7f ff f9 bf call 201ad70 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
201c678: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
if (rc > 0)
201c67c: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
201c680: 04 80 00 10 ble 201c6c0 <rtems_rfs_dir_del_entry+0x340> <== NOT EXECUTED
201c684: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201c688: 7f ff dc 20 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201c68c: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
201c690: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c694: 02 80 00 0c be 201c6c4 <rtems_rfs_dir_del_entry+0x344> <== NOT EXECUTED
201c698: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
201c69c: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
201c6a0: 40 00 1a a5 call 2023134 <strerror> <== NOT EXECUTED
201c6a4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201c6a8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201c6ac: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201c6b0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201c6b4: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c6b8: 40 00 16 33 call 2021f84 <printf> <== NOT EXECUTED
201c6bc: 90 12 20 88 or %o0, 0x88, %o0 ! 2034088 <CSWTCH.2+0xba8> <== NOT EXECUTED
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
201c6c0: 82 10 20 01 mov 1, %g1
rtems_rfs_buffer_handle_close (fs, &buffer);
201c6c4: 90 10 00 1d mov %i5, %o0
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
201c6c8: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
201c6cc: 7f ff fd 00 call 201bacc <rtems_rfs_buffer_handle_close>
201c6d0: 92 07 bf a4 add %fp, -92, %o1
rtems_rfs_block_map_close (fs, &map);
201c6d4: 90 10 00 1d mov %i5, %o0
201c6d8: 7f ff f7 bc call 201a5c8 <rtems_rfs_block_map_close>
201c6dc: 92 07 bf b0 add %fp, -80, %o1
201c6e0: 81 c7 e0 08 ret
201c6e4: 81 e8 00 00 restore
return 0;
}
if (!search)
201c6e8: 02 80 00 20 be 201c768 <rtems_rfs_dir_del_entry+0x3e8> <== NOT EXECUTED
201c6ec: b8 07 00 11 add %i4, %l1, %i4 <== NOT EXECUTED
rc = EIO;
break;
}
entry += elength;
eoffset += elength;
201c6f0: a0 04 00 11 add %l0, %l1, %l0 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201c6f4: 80 a4 00 02 cmp %l0, %g2
201c6f8: 2a bf ff 74 bcs,a 201c4c8 <rtems_rfs_dir_del_entry+0x148><== ALWAYS TAKEN
201c6fc: c6 0f 20 09 ldub [ %i4 + 9 ], %g3
entry += elength;
eoffset += elength;
}
if (rc == 0)
201c700: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
201c704: 32 80 00 0c bne,a 201c734 <rtems_rfs_dir_del_entry+0x3b4><== NOT EXECUTED
201c708: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201c70c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c710: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
201c714: 7f ff f8 9a call 201a97c <rtems_rfs_block_map_next_block> <== NOT EXECUTED
201c718: 94 10 00 16 mov %l6, %o2 <== NOT EXECUTED
if (rc == ENXIO)
201c71c: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED
201c720: 12 80 00 05 bne 201c734 <rtems_rfs_dir_del_entry+0x3b4> <== NOT EXECUTED
201c724: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rc = ENOENT;
201c728: 10 80 00 06 b 201c740 <rtems_rfs_dir_del_entry+0x3c0> <== NOT EXECUTED
201c72c: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
201c730: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
201c734: 80 a6 20 00 cmp %i0, 0
201c738: 02 bf ff 40 be 201c438 <rtems_rfs_dir_del_entry+0xb8> <== ALWAYS TAKEN
201c73c: d4 07 bf a0 ld [ %fp + -96 ], %o2
201c740: a4 10 00 18 mov %i0, %l2 <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201c744: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
201c748: 7f ff fc e1 call 201bacc <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201c74c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
201c750: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c754: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201c758: 7f ff f7 9c call 201a5c8 <rtems_rfs_block_map_close> <== NOT EXECUTED
201c75c: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
201c760: 81 c7 e0 08 ret <== NOT EXECUTED
201c764: 81 e8 00 00 restore <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
201c768: 10 bf ff f2 b 201c730 <rtems_rfs_dir_del_entry+0x3b0> <== NOT EXECUTED
201c76c: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED
0201cb08 <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
201cb08: 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))
201cb0c: 90 10 20 00 clr %o0
201cb10: 7f ff da fe call 2013708 <rtems_rfs_trace>
201cb14: 13 20 00 00 sethi %hi(0x80000000), %o1
201cb18: 80 8a 20 ff btst 0xff, %o0
201cb1c: 02 80 00 07 be 201cb38 <rtems_rfs_dir_empty+0x30> <== ALWAYS TAKEN
201cb20: b8 07 bf b0 add %fp, -80, %i4
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
201cb24: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201cb28: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201cb2c: 40 00 15 16 call 2021f84 <printf> <== NOT EXECUTED
201cb30: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 20341b8 <CSWTCH.2+0xcd8> <== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
201cb34: b8 07 bf b0 add %fp, -80, %i4 <== NOT EXECUTED
201cb38: 90 10 00 18 mov %i0, %o0
201cb3c: 92 10 00 19 mov %i1, %o1
201cb40: 7f ff f6 41 call 201a444 <rtems_rfs_block_map_open>
201cb44: 94 10 00 1c mov %i4, %o2
if (rc > 0)
201cb48: ba 92 20 00 orcc %o0, 0, %i5
201cb4c: 34 80 00 82 bg,a 201cd54 <rtems_rfs_dir_empty+0x24c> <== NEVER TAKEN
201cb50: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
201cb54: b6 07 bf a0 add %fp, -96, %i3
201cb58: 90 10 00 18 mov %i0, %o0
201cb5c: 92 10 00 1c mov %i4, %o1
201cb60: 94 10 20 00 clr %o2
201cb64: 96 10 20 00 clr %o3
201cb68: 7f ff f7 68 call 201a908 <rtems_rfs_block_map_seek>
201cb6c: 98 10 00 1b mov %i3, %o4
if (rc > 0)
201cb70: ba 92 20 00 orcc %o0, 0, %i5
201cb74: 04 80 00 05 ble 201cb88 <rtems_rfs_dir_empty+0x80> <== ALWAYS TAKEN
201cb78: 25 00 00 3f sethi %hi(0xfc00), %l2
{
rtems_rfs_block_map_close (fs, &map);
201cb7c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201cb80: 10 80 00 69 b 201cd24 <rtems_rfs_dir_empty+0x21c> <== NOT EXECUTED
201cb84: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
201cb88: 27 00 80 d0 sethi %hi(0x2034000), %l3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201cb8c: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201cb90: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201cb94: 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)
201cb98: a4 14 a3 ff or %l2, 0x3ff, %l2
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
201cb9c: a6 14 e1 d8 or %l3, 0x1d8, %l3
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201cba0: a2 10 00 1c mov %i4, %l1
201cba4: a0 10 00 1b mov %i3, %l0
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
201cba8: d4 07 bf a0 ld [ %fp + -96 ], %o2
201cbac: 90 10 00 18 mov %i0, %o0
201cbb0: 92 07 bf a4 add %fp, -92, %o1
201cbb4: 7f ff fa 11 call 201b3f8 <rtems_rfs_buffer_handle_request>
201cbb8: 96 10 20 01 mov 1, %o3
if (rc > 0)
201cbbc: ba 92 20 00 orcc %o0, 0, %i5
201cbc0: 14 80 00 4c bg 201ccf0 <rtems_rfs_dir_empty+0x1e8> <== NEVER TAKEN
201cbc4: 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))
201cbc8: c4 06 20 08 ld [ %i0 + 8 ], %g2
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
201cbcc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201cbd0: 84 00 bf f6 add %g2, -10, %g2
201cbd4: 10 80 00 3b b 201ccc0 <rtems_rfs_dir_empty+0x1b8>
201cbd8: b6 10 20 00 clr %i3
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201cbdc: f8 08 60 08 ldub [ %g1 + 8 ], %i4
eino = rtems_rfs_dir_entry_ino (entry);
201cbe0: f4 08 40 00 ldub [ %g1 ], %i2
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201cbe4: b9 2f 20 08 sll %i4, 8, %i4
201cbe8: b8 17 00 03 or %i4, %g3, %i4
eino = rtems_rfs_dir_entry_ino (entry);
201cbec: c6 08 60 01 ldub [ %g1 + 1 ], %g3
201cbf0: b5 2e a0 18 sll %i2, 0x18, %i2
201cbf4: 87 28 e0 10 sll %g3, 0x10, %g3
201cbf8: b4 16 80 03 or %i2, %g3, %i2
201cbfc: c6 08 60 03 ldub [ %g1 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201cc00: 80 a7 00 12 cmp %i4, %l2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
201cc04: b4 16 80 03 or %i2, %g3, %i2
201cc08: c6 08 60 02 ldub [ %g1 + 2 ], %g3
201cc0c: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201cc10: 02 80 00 48 be 201cd30 <rtems_rfs_dir_empty+0x228>
201cc14: b4 16 80 03 or %i2, %g3, %i2
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201cc18: 80 a7 20 0a cmp %i4, 0xa
201cc1c: 04 80 00 0d ble 201cc50 <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
201cc20: 90 10 20 01 mov 1, %o0
201cc24: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
201cc28: 80 a7 00 03 cmp %i4, %g3
201cc2c: 1a 80 00 09 bcc 201cc50 <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
201cc30: 80 a6 a0 00 cmp %i2, 0
201cc34: 02 80 00 07 be 201cc50 <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
201cc38: 01 00 00 00 nop
201cc3c: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
201cc40: 80 a6 80 03 cmp %i2, %g3
201cc44: 08 80 00 10 bleu 201cc84 <rtems_rfs_dir_empty+0x17c> <== ALWAYS TAKEN
201cc48: 80 a7 20 0b cmp %i4, 0xb
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
201cc4c: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
201cc50: 7f ff da ae call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201cc54: 92 10 20 00 clr %o1 <== NOT EXECUTED
201cc58: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201cc5c: 22 80 00 36 be,a 201cd34 <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
201cc60: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
201cc64: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201cc68: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
201cc6c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201cc70: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
201cc74: 40 00 14 c4 call 2021f84 <printf> <== NOT EXECUTED
201cc78: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201cc7c: 10 80 00 2e b 201cd34 <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
201cc80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
201cc84: 12 80 00 04 bne 201cc94 <rtems_rfs_dir_empty+0x18c>
201cc88: 80 a7 20 0c cmp %i4, 0xc
201cc8c: 10 80 00 09 b 201ccb0 <rtems_rfs_dir_empty+0x1a8>
201cc90: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
201cc94: 32 80 00 18 bne,a 201ccf4 <rtems_rfs_dir_empty+0x1ec>
201cc98: 82 10 20 00 clr %g1
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
201cc9c: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
201cca0: 80 a0 e0 2e cmp %g3, 0x2e
201cca4: 32 80 00 14 bne,a 201ccf4 <rtems_rfs_dir_empty+0x1ec> <== NEVER TAKEN
201cca8: 82 10 20 00 clr %g1 <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
201ccac: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
201ccb0: 80 a0 e0 2e cmp %g3, 0x2e
201ccb4: 12 80 00 0c bne 201cce4 <rtems_rfs_dir_empty+0x1dc> <== NEVER TAKEN
201ccb8: b6 06 c0 1c add %i3, %i4, %i3
{
empty = false;
break;
}
entry += elength;
201ccbc: 82 00 40 1c add %g1, %i4, %g1
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201ccc0: 80 a6 c0 02 cmp %i3, %g2
201ccc4: 2a bf ff c6 bcs,a 201cbdc <rtems_rfs_dir_empty+0xd4> <== ALWAYS TAKEN
201ccc8: c6 08 60 09 ldub [ %g1 + 9 ], %g3
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201cccc: 10 80 00 1a b 201cd34 <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
201ccd0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (rc > 0)
{
if (rc == ENXIO)
201ccd4: 02 80 00 06 be 201ccec <rtems_rfs_dir_empty+0x1e4> <== ALWAYS TAKEN
201ccd8: 82 10 20 01 mov 1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
201ccdc: 10 80 00 07 b 201ccf8 <rtems_rfs_dir_empty+0x1f0> <== NOT EXECUTED
201cce0: 82 18 60 01 xor %g1, 1, %g1 <== NOT EXECUTED
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
201cce4: 10 80 00 04 b 201ccf4 <rtems_rfs_dir_empty+0x1ec> <== NOT EXECUTED
201cce8: 82 10 20 00 clr %g1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc > 0)
{
if (rc == ENXIO)
rc = 0;
201ccec: ba 10 20 00 clr %i5
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc > 0)
{
if (rc == ENXIO)
201ccf0: 82 10 20 01 mov 1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
201ccf4: 82 18 60 01 xor %g1, 1, %g1
201ccf8: 80 88 60 ff btst 0xff, %g1
201ccfc: 02 80 00 06 be 201cd14 <rtems_rfs_dir_empty+0x20c>
201cd00: 92 07 bf a4 add %fp, -92, %o1
201cd04: 80 a7 60 00 cmp %i5, 0
201cd08: 22 80 00 03 be,a 201cd14 <rtems_rfs_dir_empty+0x20c> <== ALWAYS TAKEN
201cd0c: ba 10 20 5a mov 0x5a, %i5
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
201cd10: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
201cd14: 7f ff fb 6e call 201bacc <rtems_rfs_buffer_handle_close>
201cd18: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
201cd1c: 90 10 00 18 mov %i0, %o0
201cd20: 92 07 bf b0 add %fp, -80, %o1
201cd24: 7f ff f6 29 call 201a5c8 <rtems_rfs_block_map_close>
201cd28: b0 10 00 1d mov %i5, %i0
201cd2c: 30 80 00 0a b,a 201cd54 <rtems_rfs_dir_empty+0x24c>
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201cd30: 90 10 00 18 mov %i0, %o0
201cd34: 92 10 00 11 mov %l1, %o1
201cd38: 7f ff f7 11 call 201a97c <rtems_rfs_block_map_next_block>
201cd3c: 94 10 00 10 mov %l0, %o2
if (rc > 0)
201cd40: ba 92 20 00 orcc %o0, 0, %i5
201cd44: 24 bf ff 9a ble,a 201cbac <rtems_rfs_dir_empty+0xa4> <== NEVER TAKEN
201cd48: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
{
if (rc == ENXIO)
201cd4c: 10 bf ff e2 b 201ccd4 <rtems_rfs_dir_empty+0x1cc>
201cd50: 80 a7 60 06 cmp %i5, 6
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
201cd54: 81 c7 e0 08 ret
201cd58: 81 e8 00 00 restore
02020670 <rtems_rfs_dir_hash>:
{
uint32_t a,b,c; /* internal state */
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
/* Set up the internal state */
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
2020670: 05 37 f7 c5 sethi %hi(0xdfdf1400), %g2
2020674: 84 10 a2 9f or %g2, 0x29f, %g2 ! dfdf169f <RAM_END+0xdd9f169f>
2020678: 84 02 40 02 add %o1, %g2, %g2
202067c: 86 10 00 02 mov %g2, %g3
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
2020680: 10 80 00 48 b 20207a0 <rtems_rfs_dir_hash+0x130>
2020684: 88 10 00 02 mov %g2, %g4
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
2020688: d8 0a 20 02 ldub [ %o0 + 2 ], %o4
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
202068c: 88 03 40 04 add %o5, %g4, %g4
a += ((uint32_t)k[1])<<8;
2020690: da 0a 20 01 ldub [ %o0 + 1 ], %o5
a += ((uint32_t)k[2])<<16;
2020694: 99 2b 20 10 sll %o4, 0x10, %o4
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
2020698: 9b 2b 60 08 sll %o5, 8, %o5
202069c: 9a 01 00 0d add %g4, %o5, %o5
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
20206a0: c8 0a 20 04 ldub [ %o0 + 4 ], %g4
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
20206a4: 9a 03 40 0c add %o5, %o4, %o5
a += ((uint32_t)k[3])<<24;
b += k[4];
20206a8: 86 01 00 03 add %g4, %g3, %g3
b += ((uint32_t)k[5])<<8;
20206ac: c8 0a 20 05 ldub [ %o0 + 5 ], %g4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
20206b0: d8 0a 20 03 ldub [ %o0 + 3 ], %o4
b += k[4];
b += ((uint32_t)k[5])<<8;
20206b4: 89 29 20 08 sll %g4, 8, %g4
20206b8: 86 00 c0 04 add %g3, %g4, %g3
b += ((uint32_t)k[6])<<16;
20206bc: c8 0a 20 06 ldub [ %o0 + 6 ], %g4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
20206c0: 99 2b 20 18 sll %o4, 0x18, %o4
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
20206c4: 89 29 20 10 sll %g4, 0x10, %g4
20206c8: 86 00 c0 04 add %g3, %g4, %g3
b += ((uint32_t)k[7])<<24;
20206cc: c8 0a 20 07 ldub [ %o0 + 7 ], %g4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
20206d0: 9a 03 40 0c add %o5, %o4, %o5
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
20206d4: 89 29 20 18 sll %g4, 0x18, %g4
20206d8: 86 00 c0 04 add %g3, %g4, %g3
c += k[8];
20206dc: c8 0a 20 08 ldub [ %o0 + 8 ], %g4
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
length -= 12;
20206e0: 92 02 7f f4 add %o1, -12, %o1
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
20206e4: 84 01 00 02 add %g4, %g2, %g2
c += ((uint32_t)k[9])<<8;
20206e8: c8 0a 20 09 ldub [ %o0 + 9 ], %g4
20206ec: 89 29 20 08 sll %g4, 8, %g4
20206f0: 84 00 80 04 add %g2, %g4, %g2
c += ((uint32_t)k[10])<<16;
20206f4: c8 0a 20 0a ldub [ %o0 + 0xa ], %g4
20206f8: 89 29 20 10 sll %g4, 0x10, %g4
20206fc: 84 00 80 04 add %g2, %g4, %g2
c += ((uint32_t)k[11])<<24;
2020700: c8 0a 20 0b ldub [ %o0 + 0xb ], %g4
mix(a,b,c);
length -= 12;
k += 12;
2020704: 90 02 20 0c add %o0, 0xc, %o0
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
2020708: 89 29 20 18 sll %g4, 0x18, %g4
202070c: 84 00 80 04 add %g2, %g4, %g2
mix(a,b,c);
2020710: 9a 23 40 02 sub %o5, %g2, %o5
2020714: 99 28 a0 04 sll %g2, 4, %o4
2020718: 89 30 a0 1c srl %g2, 0x1c, %g4
202071c: 88 13 00 04 or %o4, %g4, %g4
2020720: 88 1b 40 04 xor %o5, %g4, %g4
2020724: 99 29 20 06 sll %g4, 6, %o4
2020728: 9b 31 20 1a srl %g4, 0x1a, %o5
202072c: 9a 13 00 0d or %o4, %o5, %o5
2020730: 84 00 80 03 add %g2, %g3, %g2
2020734: 86 20 c0 04 sub %g3, %g4, %g3
2020738: 86 1b 40 03 xor %o5, %g3, %g3
202073c: 99 28 e0 08 sll %g3, 8, %o4
2020740: 9b 30 e0 18 srl %g3, 0x18, %o5
2020744: 9a 13 00 0d or %o4, %o5, %o5
2020748: 88 01 00 02 add %g4, %g2, %g4
202074c: 84 20 80 03 sub %g2, %g3, %g2
2020750: 84 1b 40 02 xor %o5, %g2, %g2
2020754: 99 28 a0 10 sll %g2, 0x10, %o4
2020758: 9b 30 a0 10 srl %g2, 0x10, %o5
202075c: 9a 13 00 0d or %o4, %o5, %o5
2020760: 86 00 c0 04 add %g3, %g4, %g3
2020764: 88 21 00 02 sub %g4, %g2, %g4
2020768: 88 1b 40 04 xor %o5, %g4, %g4
202076c: 99 29 20 13 sll %g4, 0x13, %o4
2020770: 9b 31 20 0d srl %g4, 0xd, %o5
2020774: 9a 13 00 0d or %o4, %o5, %o5
2020778: 84 00 80 03 add %g2, %g3, %g2
202077c: 86 20 c0 04 sub %g3, %g4, %g3
2020780: 88 01 00 02 add %g4, %g2, %g4
2020784: 86 1b 40 03 xor %o5, %g3, %g3
2020788: 84 20 80 03 sub %g2, %g3, %g2
202078c: 99 28 e0 04 sll %g3, 4, %o4
2020790: 9b 30 e0 1c srl %g3, 0x1c, %o5
2020794: 86 00 c0 04 add %g3, %g4, %g3
2020798: 9a 13 00 0d or %o4, %o5, %o5
202079c: 84 1b 40 02 xor %o5, %g2, %g2
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
20207a0: 80 a2 60 0c cmp %o1, 0xc
20207a4: 38 bf ff b9 bgu,a 2020688 <rtems_rfs_dir_hash+0x18>
20207a8: da 0a 00 00 ldub [ %o0 ], %o5
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
20207ac: 92 02 7f ff add %o1, -1, %o1
20207b0: 80 a2 60 0b cmp %o1, 0xb
20207b4: 18 80 00 4b bgu 20208e0 <rtems_rfs_dir_hash+0x270> <== NEVER TAKEN
20207b8: 93 2a 60 02 sll %o1, 2, %o1
20207bc: 1b 00 80 81 sethi %hi(0x2020400), %o5
20207c0: 9a 13 62 40 or %o5, 0x240, %o5 ! 2020640 <rtems_rfs_buffer_bdbuf_release+0x80>
20207c4: da 03 40 09 ld [ %o5 + %o1 ], %o5
20207c8: 81 c3 40 00 jmp %o5
20207cc: 01 00 00 00 nop
{
case 12: c+=((uint32_t)k[11])<<24;
20207d0: da 0a 20 0b ldub [ %o0 + 0xb ], %o5
20207d4: 9b 2b 60 18 sll %o5, 0x18, %o5
20207d8: 84 03 40 02 add %o5, %g2, %g2
case 11: c+=((uint32_t)k[10])<<16;
20207dc: da 0a 20 0a ldub [ %o0 + 0xa ], %o5
20207e0: 9b 2b 60 10 sll %o5, 0x10, %o5
20207e4: 84 00 80 0d add %g2, %o5, %g2
case 10: c+=((uint32_t)k[9])<<8;
20207e8: da 0a 20 09 ldub [ %o0 + 9 ], %o5
20207ec: 9b 2b 60 08 sll %o5, 8, %o5
20207f0: 84 00 80 0d add %g2, %o5, %g2
case 9 : c+=k[8];
20207f4: da 0a 20 08 ldub [ %o0 + 8 ], %o5
20207f8: 84 00 80 0d add %g2, %o5, %g2
case 8 : b+=((uint32_t)k[7])<<24;
20207fc: da 0a 20 07 ldub [ %o0 + 7 ], %o5
2020800: 9b 2b 60 18 sll %o5, 0x18, %o5
2020804: 86 03 40 03 add %o5, %g3, %g3
case 7 : b+=((uint32_t)k[6])<<16;
2020808: da 0a 20 06 ldub [ %o0 + 6 ], %o5
202080c: 9b 2b 60 10 sll %o5, 0x10, %o5
2020810: 86 00 c0 0d add %g3, %o5, %g3
case 6 : b+=((uint32_t)k[5])<<8;
2020814: da 0a 20 05 ldub [ %o0 + 5 ], %o5
2020818: 9b 2b 60 08 sll %o5, 8, %o5
202081c: 86 00 c0 0d add %g3, %o5, %g3
case 5 : b+=k[4];
2020820: da 0a 20 04 ldub [ %o0 + 4 ], %o5
2020824: 86 00 c0 0d add %g3, %o5, %g3
case 4 : a+=((uint32_t)k[3])<<24;
2020828: da 0a 20 03 ldub [ %o0 + 3 ], %o5
202082c: 9b 2b 60 18 sll %o5, 0x18, %o5
2020830: 88 03 40 04 add %o5, %g4, %g4
case 3 : a+=((uint32_t)k[2])<<16;
2020834: da 0a 20 02 ldub [ %o0 + 2 ], %o5
2020838: 9b 2b 60 10 sll %o5, 0x10, %o5
202083c: 88 01 00 0d add %g4, %o5, %g4
case 2 : a+=((uint32_t)k[1])<<8;
2020840: da 0a 20 01 ldub [ %o0 + 1 ], %o5
2020844: 9b 2b 60 08 sll %o5, 8, %o5
2020848: 88 01 00 0d add %g4, %o5, %g4
case 1 : a+=k[0];
202084c: c2 0a 00 00 ldub [ %o0 ], %g1
break;
case 0 : return c;
}
}
final(a,b,c);
2020850: 9b 30 e0 12 srl %g3, 0x12, %o5
case 6 : b+=((uint32_t)k[5])<<8;
case 5 : b+=k[4];
case 4 : a+=((uint32_t)k[3])<<24;
case 3 : a+=((uint32_t)k[2])<<16;
case 2 : a+=((uint32_t)k[1])<<8;
case 1 : a+=k[0];
2020854: 88 01 00 01 add %g4, %g1, %g4
break;
case 0 : return c;
}
}
final(a,b,c);
2020858: 83 28 e0 0e sll %g3, 0xe, %g1
202085c: 82 13 40 01 or %o5, %g1, %g1
2020860: 84 18 80 03 xor %g2, %g3, %g2
2020864: 84 20 80 01 sub %g2, %g1, %g2
2020868: 9b 28 a0 0b sll %g2, 0xb, %o5
202086c: 83 30 a0 15 srl %g2, 0x15, %g1
2020870: 82 13 40 01 or %o5, %g1, %g1
2020874: 88 18 80 04 xor %g2, %g4, %g4
2020878: 88 21 00 01 sub %g4, %g1, %g4
202087c: 9b 29 20 19 sll %g4, 0x19, %o5
2020880: 83 31 20 07 srl %g4, 7, %g1
2020884: 82 13 40 01 or %o5, %g1, %g1
2020888: 86 19 00 03 xor %g4, %g3, %g3
202088c: 86 20 c0 01 sub %g3, %g1, %g3
2020890: 9b 28 e0 10 sll %g3, 0x10, %o5
2020894: 83 30 e0 10 srl %g3, 0x10, %g1
2020898: 82 13 40 01 or %o5, %g1, %g1
202089c: 84 18 c0 02 xor %g3, %g2, %g2
20208a0: 84 20 80 01 sub %g2, %g1, %g2
20208a4: 9b 28 a0 04 sll %g2, 4, %o5
20208a8: 83 30 a0 1c srl %g2, 0x1c, %g1
20208ac: 82 13 40 01 or %o5, %g1, %g1
20208b0: 88 18 80 04 xor %g2, %g4, %g4
20208b4: 88 21 00 01 sub %g4, %g1, %g4
20208b8: 83 29 20 0e sll %g4, 0xe, %g1
20208bc: 86 19 00 03 xor %g4, %g3, %g3
20208c0: 89 31 20 12 srl %g4, 0x12, %g4
20208c4: 88 10 40 04 or %g1, %g4, %g4
20208c8: 86 20 c0 04 sub %g3, %g4, %g3
20208cc: 84 18 c0 02 xor %g3, %g2, %g2
20208d0: 83 28 e0 18 sll %g3, 0x18, %g1
20208d4: 87 30 e0 08 srl %g3, 8, %g3
20208d8: 86 10 40 03 or %g1, %g3, %g3
20208dc: 84 20 80 03 sub %g2, %g3, %g2
return c;
}
20208e0: 81 c3 e0 08 retl
20208e4: 90 10 00 02 mov %g2, %o0
0201baf4 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
201baf4: 9d e3 bf 38 save %sp, -200, %sp
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201baf8: 90 10 20 00 clr %o0
201bafc: 13 01 00 00 sethi %hi(0x4000000), %o1
201bb00: 7f ff df 02 call 2013708 <rtems_rfs_trace>
201bb04: a0 10 00 18 mov %i0, %l0
201bb08: 80 8a 20 ff btst 0xff, %o0
201bb0c: 22 80 00 13 be,a 201bb58 <rtems_rfs_dir_lookup_ino+0x64> <== ALWAYS TAKEN
201bb10: c0 27 00 00 clr [ %i4 ]
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
201bb14: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201bb18: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
201bb1c: b0 10 20 00 clr %i0 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
201bb20: 40 00 19 19 call 2021f84 <printf> <== NOT EXECUTED
201bb24: 90 12 23 20 or %o0, 0x320, %o0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
201bb28: 10 80 00 05 b 201bb3c <rtems_rfs_dir_lookup_ino+0x48> <== NOT EXECUTED
201bb2c: 80 a6 00 1b cmp %i0, %i3 <== NOT EXECUTED
printf ("%c", name[c]);
201bb30: 40 00 19 7f call 202212c <putchar> <== NOT EXECUTED
201bb34: 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++)
201bb38: 80 a6 00 1b cmp %i0, %i3 <== NOT EXECUTED
201bb3c: 26 bf ff fd bl,a 201bb30 <rtems_rfs_dir_lookup_ino+0x3c> <== NOT EXECUTED
201bb40: d0 4e 80 18 ldsb [ %i2 + %i0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
201bb44: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201bb48: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201bb4c: 40 00 19 0e call 2021f84 <printf> <== NOT EXECUTED
201bb50: 90 12 23 58 or %o0, 0x358, %o0 <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
201bb54: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
*offset = 0;
201bb58: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, inode, &map);
201bb5c: 90 10 00 10 mov %l0, %o0
201bb60: 92 10 00 19 mov %i1, %o1
201bb64: 7f ff fa 38 call 201a444 <rtems_rfs_block_map_open>
201bb68: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
201bb6c: b0 92 20 00 orcc %o0, 0, %i0
201bb70: 04 80 00 12 ble 201bbb8 <rtems_rfs_dir_lookup_ino+0xc4> <== ALWAYS TAKEN
201bb74: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201bb78: 7f ff de e4 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201bb7c: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201bb80: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201bb84: 02 80 01 18 be 201bfe4 <rtems_rfs_dir_lookup_ino+0x4f0> <== NOT EXECUTED
201bb88: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
201bb8c: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
201bb90: 40 00 1d 69 call 2023134 <strerror> <== NOT EXECUTED
201bb94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201bb98: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201bb9c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201bba0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
201bba4: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201bba8: 40 00 18 f7 call 2021f84 <printf> <== NOT EXECUTED
201bbac: 90 12 23 68 or %o0, 0x368, %o0 ! 2033b68 <CSWTCH.2+0x688> <== NOT EXECUTED
201bbb0: 81 c7 e0 08 ret <== NOT EXECUTED
201bbb4: 81 e8 00 00 restore <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
201bbb8: 92 10 00 1b mov %i3, %o1
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201bbbc: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201bbc0: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201bbc4: c0 27 bf ac clr [ %fp + -84 ]
201bbc8: 40 00 12 aa call 2020670 <rtems_rfs_dir_hash>
201bbcc: 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);
201bbd0: 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);
201bbd4: d0 27 bf 9c st %o0, [ %fp + -100 ]
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
201bbd8: 94 10 20 00 clr %o2
201bbdc: 90 10 00 10 mov %l0, %o0
201bbe0: 96 10 20 00 clr %o3
201bbe4: 7f ff fb 49 call 201a908 <rtems_rfs_block_map_seek>
201bbe8: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
201bbec: b0 92 20 00 orcc %o0, 0, %i0
201bbf0: 04 80 00 d3 ble 201bf3c <rtems_rfs_dir_lookup_ino+0x448> <== ALWAYS TAKEN
201bbf4: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201bbf8: 7f ff de c4 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201bbfc: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201bc00: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201bc04: 02 80 00 0a be 201bc2c <rtems_rfs_dir_lookup_ino+0x138> <== NOT EXECUTED
201bc08: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
201bc0c: 40 00 1d 4a call 2023134 <strerror> <== NOT EXECUTED
201bc10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201bc14: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201bc18: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201bc1c: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201bc20: 40 00 18 d9 call 2021f84 <printf> <== NOT EXECUTED
201bc24: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 2033ba8 <CSWTCH.2+0x6c8> <== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
201bc28: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
201bc2c: 22 80 00 dc be,a 201bf9c <rtems_rfs_dir_lookup_ino+0x4a8><== NOT EXECUTED
201bc30: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
201bc34: 10 80 00 db b 201bfa0 <rtems_rfs_dir_lookup_ino+0x4ac> <== NOT EXECUTED
201bc38: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201bc3c: 7f ff de b3 call 2013708 <rtems_rfs_trace>
201bc40: 13 01 00 00 sethi %hi(0x4000000), %o1
201bc44: 80 8a 20 ff btst 0xff, %o0
201bc48: 02 80 00 08 be 201bc68 <rtems_rfs_dir_lookup_ino+0x174> <== ALWAYS TAKEN
201bc4c: d4 07 bf a0 ld [ %fp + -96 ], %o2
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
201bc50: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201bc54: d4 07 bf c0 ld [ %fp + -64 ], %o2 <== NOT EXECUTED
201bc58: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201bc5c: 40 00 18 ca call 2021f84 <printf> <== NOT EXECUTED
201bc60: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 2033be8 <CSWTCH.2+0x708> <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
201bc64: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
201bc68: 90 10 00 10 mov %l0, %o0
201bc6c: 92 07 bf a4 add %fp, -92, %o1
201bc70: 7f ff fd e2 call 201b3f8 <rtems_rfs_buffer_handle_request>
201bc74: 96 10 20 01 mov 1, %o3
if (rc > 0)
201bc78: a2 92 20 00 orcc %o0, 0, %l1
201bc7c: 04 80 00 15 ble 201bcd0 <rtems_rfs_dir_lookup_ino+0x1dc> <== ALWAYS TAKEN
201bc80: c2 07 bf ac ld [ %fp + -84 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201bc84: 90 10 20 00 clr %o0 <== NOT EXECUTED
201bc88: 7f ff de a0 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201bc8c: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201bc90: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201bc94: 22 80 00 c2 be,a 201bf9c <rtems_rfs_dir_lookup_ino+0x4a8><== NOT EXECUTED
201bc98: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
201bc9c: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201bca0: fa 07 bf a0 ld [ %fp + -96 ], %i5 <== NOT EXECUTED
201bca4: 40 00 1d 24 call 2023134 <strerror> <== NOT EXECUTED
201bca8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
201bcac: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201bcb0: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
201bcb4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201bcb8: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201bcbc: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
201bcc0: 40 00 18 b1 call 2021f84 <printf> <== NOT EXECUTED
201bcc4: 90 12 20 20 or %o0, 0x20, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
201bcc8: 10 80 00 b5 b 201bf9c <rtems_rfs_dir_lookup_ino+0x4a8> <== NOT EXECUTED
201bccc: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
201bcd0: c0 27 bf c4 clr [ %fp + -60 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201bcd4: 10 80 00 71 b 201be98 <rtems_rfs_dir_lookup_ino+0x3a4>
201bcd8: e4 00 60 1c ld [ %g1 + 0x1c ], %l2
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
201bcdc: c8 0c a0 04 ldub [ %l2 + 4 ], %g4
201bce0: 85 28 a0 10 sll %g2, 0x10, %g2
201bce4: 89 29 20 18 sll %g4, 0x18, %g4
201bce8: 88 11 00 02 or %g4, %g2, %g4
201bcec: c4 0c a0 07 ldub [ %l2 + 7 ], %g2
elength = rtems_rfs_dir_entry_length (entry);
201bcf0: c6 0c a0 09 ldub [ %l2 + 9 ], %g3
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
201bcf4: 88 11 00 02 or %g4, %g2, %g4
201bcf8: c4 0c a0 06 ldub [ %l2 + 6 ], %g2
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
201bcfc: de 0c 80 00 ldub [ %l2 ], %o7
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
201bd00: 85 28 a0 08 sll %g2, 8, %g2
201bd04: 88 11 00 02 or %g4, %g2, %g4
elength = rtems_rfs_dir_entry_length (entry);
201bd08: c4 0c a0 08 ldub [ %l2 + 8 ], %g2
*ino = rtems_rfs_dir_entry_ino (entry);
201bd0c: 9f 2b e0 18 sll %o7, 0x18, %o7
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
201bd10: 85 28 a0 08 sll %g2, 8, %g2
201bd14: a6 10 80 03 or %g2, %g3, %l3
*ino = rtems_rfs_dir_entry_ino (entry);
201bd18: c6 0c a0 01 ldub [ %l2 + 1 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201bd1c: 80 a4 c0 14 cmp %l3, %l4
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
201bd20: 87 28 e0 10 sll %g3, 0x10, %g3
201bd24: 86 13 c0 03 or %o7, %g3, %g3
201bd28: de 0c a0 03 ldub [ %l2 + 3 ], %o7
201bd2c: 86 10 c0 0f or %g3, %o7, %g3
201bd30: de 0c a0 02 ldub [ %l2 + 2 ], %o7
201bd34: 9f 2b e0 08 sll %o7, 8, %o7
201bd38: 86 10 c0 0f or %g3, %o7, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201bd3c: 12 80 00 07 bne 201bd58 <rtems_rfs_dir_lookup_ino+0x264>
201bd40: c6 27 00 00 st %g3, [ %i4 ]
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
201bd44: 80 a4 60 00 cmp %l1, 0
201bd48: 32 80 00 85 bne,a 201bf5c <rtems_rfs_dir_lookup_ino+0x468><== NEVER TAKEN
201bd4c: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201bd50: 10 80 00 5a b 201beb8 <rtems_rfs_dir_lookup_ino+0x3c4>
201bd54: 90 10 00 10 mov %l0, %o0
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
201bd58: 80 a4 e0 0a cmp %l3, 0xa
201bd5c: 34 80 00 0a bg,a 201bd84 <rtems_rfs_dir_lookup_ino+0x290><== ALWAYS TAKEN
201bd60: de 04 20 1c ld [ %l0 + 0x1c ], %o7
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201bd64: 90 10 20 00 clr %o0 <== NOT EXECUTED
201bd68: 7f ff de 68 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201bd6c: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201bd70: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201bd74: 22 80 00 70 be,a 201bf34 <rtems_rfs_dir_lookup_ino+0x440><== NOT EXECUTED
201bd78: a2 10 20 05 mov 5, %l1 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
201bd7c: 10 80 00 0c b 201bdac <rtems_rfs_dir_lookup_ino+0x2b8> <== NOT EXECUTED
201bd80: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
201bd84: 80 a4 c0 0f cmp %l3, %o7
201bd88: 1a bf ff f7 bcc 201bd64 <rtems_rfs_dir_lookup_ino+0x270> <== NEVER TAKEN
201bd8c: 80 a0 e0 00 cmp %g3, 0
201bd90: 02 bf ff f6 be 201bd68 <rtems_rfs_dir_lookup_ino+0x274> <== NEVER TAKEN
201bd94: 90 10 20 00 clr %o0
201bd98: de 04 20 14 ld [ %l0 + 0x14 ], %o7
201bd9c: 80 a0 c0 0f cmp %g3, %o7
201bda0: 08 80 00 0a bleu 201bdc8 <rtems_rfs_dir_lookup_ino+0x2d4> <== ALWAYS TAKEN
201bda4: c2 07 bf 9c ld [ %fp + -100 ], %g1
201bda8: 30 bf ff f0 b,a 201bd68 <rtems_rfs_dir_lookup_ino+0x274> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
201bdac: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
201bdb0: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
201bdb4: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
201bdb8: 40 00 18 73 call 2021f84 <printf> <== NOT EXECUTED
201bdbc: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
201bdc0: 10 80 00 5d b 201bf34 <rtems_rfs_dir_lookup_ino+0x440> <== NOT EXECUTED
201bdc4: a2 10 20 05 mov 5, %l1 <== NOT EXECUTED
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
201bdc8: 80 a1 00 01 cmp %g4, %g1
201bdcc: 12 80 00 30 bne 201be8c <rtems_rfs_dir_lookup_ino+0x398>
201bdd0: c6 07 bf c4 ld [ %fp + -60 ], %g3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
201bdd4: 90 10 20 00 clr %o0
201bdd8: 7f ff de 4c call 2013708 <rtems_rfs_trace>
201bddc: 13 02 00 00 sethi %hi(0x8000000), %o1
201bde0: 80 8a 20 ff btst 0xff, %o0
201bde4: 02 80 00 12 be 201be2c <rtems_rfs_dir_lookup_ino+0x338> <== ALWAYS TAKEN
201bde8: 90 04 a0 0a add %l2, 0xa, %o0
printf ("rtems-rfs: dir-lookup-ino: "
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
201bdec: c6 0c a0 01 ldub [ %l2 + 1 ], %g3 <== NOT EXECUTED
201bdf0: da 0c 80 00 ldub [ %l2 ], %o5 <== NOT EXECUTED
201bdf4: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
201bdf8: 9b 2b 60 18 sll %o5, 0x18, %o5 <== NOT EXECUTED
201bdfc: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
201be00: c6 0c a0 03 ldub [ %l2 + 3 ], %g3 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
201be04: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
201be08: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
201be0c: c6 0c a0 02 ldub [ %l2 + 2 ], %g3 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
201be10: 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));
201be14: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
201be18: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
201be1c: 98 10 00 13 mov %l3, %o4 <== NOT EXECUTED
201be20: 40 00 18 59 call 2021f84 <printf> <== NOT EXECUTED
201be24: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
201be28: 90 04 a0 0a add %l2, 0xa, %o0 <== NOT EXECUTED
201be2c: 92 10 00 1a mov %i2, %o1
201be30: 40 00 17 1e call 2021aa8 <memcmp>
201be34: 94 10 00 1b mov %i3, %o2
201be38: 80 a2 20 00 cmp %o0, 0
201be3c: 12 80 00 14 bne 201be8c <rtems_rfs_dir_lookup_ino+0x398> <== NEVER TAKEN
201be40: c6 07 bf c4 ld [ %fp + -60 ], %g3
{
*offset = rtems_rfs_block_map_pos (fs, &map);
201be44: 90 10 00 10 mov %l0, %o0
201be48: 7f ff f9 48 call 201a368 <rtems_rfs_block_get_pos>
201be4c: 92 07 bf c0 add %fp, -64, %o1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
201be50: 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);
201be54: d2 27 40 00 st %o1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
201be58: 7f ff de 2c call 2013708 <rtems_rfs_trace>
201be5c: 13 04 00 00 sethi %hi(0x10000000), %o1
201be60: 80 8a 20 ff btst 0xff, %o0
201be64: 22 80 00 4f be,a 201bfa0 <rtems_rfs_dir_lookup_ino+0x4ac><== ALWAYS TAKEN
201be68: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-lookup-ino: "
201be6c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201be70: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
201be74: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
201be78: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201be7c: 40 00 18 42 call 2021f84 <printf> <== NOT EXECUTED
201be80: 90 12 21 18 or %o0, 0x118, %o0 ! 2033d18 <CSWTCH.2+0x838> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
201be84: 10 80 00 47 b 201bfa0 <rtems_rfs_dir_lookup_ino+0x4ac> <== NOT EXECUTED
201be88: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
return 0;
}
}
map.bpos.boff += elength;
entry += elength;
201be8c: a4 04 80 13 add %l2, %l3, %l2
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
201be90: 86 00 c0 13 add %g3, %l3, %g3
201be94: c6 27 bf c4 st %g3, [ %fp + -60 ]
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201be98: c4 04 20 08 ld [ %l0 + 8 ], %g2
201be9c: c6 07 bf c4 ld [ %fp + -60 ], %g3
201bea0: 84 00 bf f6 add %g2, -10, %g2
201bea4: 80 a0 c0 02 cmp %g3, %g2
201bea8: 2a bf ff 8d bcs,a 201bcdc <rtems_rfs_dir_lookup_ino+0x1e8><== ALWAYS TAKEN
201beac: c4 0c a0 05 ldub [ %l2 + 5 ], %g2
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
201beb0: 10 bf ff a6 b 201bd48 <rtems_rfs_dir_lookup_ino+0x254> <== NOT EXECUTED
201beb4: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201beb8: 92 07 bf b0 add %fp, -80, %o1
201bebc: 7f ff fa b0 call 201a97c <rtems_rfs_block_map_next_block>
201bec0: 94 07 bf a0 add %fp, -96, %o2
if ((rc > 0) && (rc != ENXIO))
201bec4: 80 a2 20 06 cmp %o0, 6
201bec8: 02 80 00 05 be 201bedc <rtems_rfs_dir_lookup_ino+0x3e8> <== ALWAYS TAKEN
201becc: b0 10 00 08 mov %o0, %i0
201bed0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201bed4: 14 80 00 07 bg 201bef0 <rtems_rfs_dir_lookup_ino+0x3fc> <== NOT EXECUTED
201bed8: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
201bedc: 80 a6 20 06 cmp %i0, 6
201bee0: 12 80 00 20 bne 201bf60 <rtems_rfs_dir_lookup_ino+0x46c> <== NEVER TAKEN
201bee4: 80 a6 20 00 cmp %i0, 0
rc = ENOENT;
201bee8: 10 80 00 11 b 201bf2c <rtems_rfs_dir_lookup_ino+0x438>
201beec: b0 10 20 02 mov 2, %i0
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if ((rc > 0) && (rc != ENXIO))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201bef0: 7f ff de 06 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201bef4: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201bef8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201befc: 22 bf ff f9 be,a 201bee0 <rtems_rfs_dir_lookup_ino+0x3ec><== NOT EXECUTED
201bf00: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
201bf04: e2 06 60 08 ld [ %i1 + 8 ], %l1 <== NOT EXECUTED
201bf08: 40 00 1c 8b call 2023134 <strerror> <== NOT EXECUTED
201bf0c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201bf10: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
201bf14: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201bf18: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
201bf1c: 40 00 18 1a call 2021f84 <printf> <== NOT EXECUTED
201bf20: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
201bf24: 10 80 00 0f b 201bf60 <rtems_rfs_dir_lookup_ino+0x46c> <== NOT EXECUTED
201bf28: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
201bf2c: 10 80 00 25 b 201bfc0 <rtems_rfs_dir_lookup_ino+0x4cc>
201bf30: a2 10 00 18 mov %i0, %l1
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
201bf34: 10 80 00 0a b 201bf5c <rtems_rfs_dir_lookup_ino+0x468> <== NOT EXECUTED
201bf38: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201bf3c: 29 00 00 3f sethi %hi(0xfc00), %l4
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
201bf40: 2b 00 80 cf sethi %hi(0x2033c00), %l5
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if ((rc > 0) && (rc != ENXIO))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
201bf44: 2d 00 80 cf sethi %hi(0x2033c00), %l6
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
201bf48: 2f 00 80 cf sethi %hi(0x2033c00), %l7
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201bf4c: a8 15 23 ff or %l4, 0x3ff, %l4
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
201bf50: aa 15 60 b8 or %l5, 0xb8, %l5
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if ((rc > 0) && (rc != ENXIO))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
201bf54: ac 15 a1 60 or %l6, 0x160, %l6
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
201bf58: ae 15 e0 68 or %l7, 0x68, %l7
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
201bf5c: 80 a6 20 00 cmp %i0, 0
201bf60: 12 80 00 17 bne 201bfbc <rtems_rfs_dir_lookup_ino+0x4c8> <== NEVER TAKEN
201bf64: c2 07 bf a0 ld [ %fp + -96 ], %g1
201bf68: 80 a0 60 00 cmp %g1, 0
201bf6c: 12 bf ff 34 bne 201bc3c <rtems_rfs_dir_lookup_ino+0x148> <== ALWAYS TAKEN
201bf70: 90 10 20 00 clr %o0
201bf74: 30 80 00 15 b,a 201bfc8 <rtems_rfs_dir_lookup_ino+0x4d4> <== NOT EXECUTED
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
201bf78: 40 00 1c 6f call 2023134 <strerror> <== NOT EXECUTED
201bf7c: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
201bf80: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201bf84: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201bf88: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED
201bf8c: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201bf90: 40 00 17 fd call 2021f84 <printf> <== NOT EXECUTED
201bf94: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 2033db0 <CSWTCH.2+0x8d0> <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
201bf98: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
201bf9c: 92 07 bf a4 add %fp, -92, %o1
201bfa0: 7f ff fe cb call 201bacc <rtems_rfs_buffer_handle_close>
201bfa4: 90 10 00 10 mov %l0, %o0
rtems_rfs_block_map_close (fs, &map);
201bfa8: 90 10 00 10 mov %l0, %o0
201bfac: 7f ff f9 87 call 201a5c8 <rtems_rfs_block_map_close>
201bfb0: 92 07 bf b0 add %fp, -80, %o1
201bfb4: 81 c7 e0 08 ret
201bfb8: 81 e8 00 00 restore
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
201bfbc: a2 10 00 18 mov %i0, %l1 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
201bfc0: 10 bf ff f7 b 201bf9c <rtems_rfs_dir_lookup_ino+0x4a8>
201bfc4: b0 10 00 11 mov %l1, %i0
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201bfc8: 7f ff dd d0 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201bfcc: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201bfd0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201bfd4: 32 bf ff e9 bne,a 201bf78 <rtems_rfs_dir_lookup_ino+0x484><== NOT EXECUTED
201bfd8: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
201bfdc: 10 bf ff f0 b 201bf9c <rtems_rfs_dir_lookup_ino+0x4a8> <== NOT EXECUTED
201bfe0: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
201bfe4: 81 c7 e0 08 ret <== NOT EXECUTED
201bfe8: 81 e8 00 00 restore <== NOT EXECUTED
0201c770 <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)
{
201c770: 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))
201c774: 90 10 20 00 clr %o0
201c778: 7f ff db e4 call 2013708 <rtems_rfs_trace>
201c77c: 13 20 00 00 sethi %hi(0x80000000), %o1
201c780: 80 8a 20 ff btst 0xff, %o0
201c784: 22 80 00 09 be,a 201c7a8 <rtems_rfs_dir_read+0x38> <== ALWAYS TAKEN
201c788: c0 27 40 00 clr [ %i5 ]
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
201c78c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201c790: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c794: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201c798: 90 12 20 d0 or %o0, 0xd0, %o0 <== NOT EXECUTED
201c79c: 40 00 15 fa call 2021f84 <printf> <== NOT EXECUTED
201c7a0: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), offset);
*length = 0;
201c7a4: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
201c7a8: 90 10 00 18 mov %i0, %o0
201c7ac: 92 10 00 19 mov %i1, %o1
201c7b0: 7f ff f7 25 call 201a444 <rtems_rfs_block_map_open>
201c7b4: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
201c7b8: a0 92 20 00 orcc %o0, 0, %l0
201c7bc: 14 80 00 d1 bg 201cb00 <rtems_rfs_dir_read+0x390> <== NEVER TAKEN
201c7c0: 90 10 00 1a mov %i2, %o0
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
201c7c4: e0 06 20 08 ld [ %i0 + 8 ], %l0
201c7c8: a2 10 00 10 mov %l0, %l1
201c7cc: 92 10 00 1b mov %i3, %o1
201c7d0: a0 10 20 00 clr %l0
201c7d4: 96 10 00 11 mov %l1, %o3
201c7d8: 40 00 48 47 call 202e8f4 <__moddi3>
201c7dc: 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) -
201c7e0: 92 a4 40 09 subcc %l1, %o1, %o1
201c7e4: 90 64 00 08 subx %l0, %o0, %o0
201c7e8: 80 a2 20 00 cmp %o0, 0
201c7ec: 34 80 00 17 bg,a 201c848 <rtems_rfs_dir_read+0xd8> <== NEVER TAKEN
201c7f0: a2 07 bf b0 add %fp, -80, %l1 <== NOT EXECUTED
201c7f4: 80 a2 20 00 cmp %o0, 0
201c7f8: 12 80 00 06 bne 201c810 <rtems_rfs_dir_read+0xa0> <== NEVER TAKEN
201c7fc: 90 10 00 1a mov %i2, %o0
201c800: 80 a2 60 0a cmp %o1, 0xa
201c804: 38 80 00 11 bgu,a 201c848 <rtems_rfs_dir_read+0xd8> <== ALWAYS TAKEN
201c808: a2 07 bf b0 add %fp, -80, %l1
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
201c80c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
201c810: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201c814: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
201c818: 40 00 47 4c call 202e548 <__divdi3> <== NOT EXECUTED
201c81c: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
201c820: 86 82 60 01 addcc %o1, 1, %g3 <== NOT EXECUTED
201c824: 84 42 20 00 addx %o0, 0, %g2 <== NOT EXECUTED
201c828: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
201c82c: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
201c830: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
201c834: 40 00 47 01 call 202e438 <__muldi3> <== NOT EXECUTED
201c838: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
201c83c: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
201c840: b6 10 00 09 mov %o1, %i3 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
201c844: a2 07 bf b0 add %fp, -80, %l1 <== NOT EXECUTED
201c848: a4 07 bf a0 add %fp, -96, %l2
201c84c: 90 10 00 18 mov %i0, %o0
201c850: 92 10 00 11 mov %l1, %o1
201c854: 94 10 00 1a mov %i2, %o2
201c858: 96 10 00 1b mov %i3, %o3
201c85c: 7f ff f8 2b call 201a908 <rtems_rfs_block_map_seek>
201c860: 98 10 00 12 mov %l2, %o4
if (rc > 0)
201c864: a0 92 20 00 orcc %o0, 0, %l0
201c868: 04 80 00 07 ble 201c884 <rtems_rfs_dir_read+0x114> <== ALWAYS TAKEN
201c86c: 80 a4 20 06 cmp %l0, 6
{
if (rc == ENXIO)
201c870: 22 80 00 02 be,a 201c878 <rtems_rfs_dir_read+0x108> <== NOT EXECUTED
201c874: a0 10 20 02 mov 2, %l0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
201c878: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c87c: 10 80 00 9f b 201caf8 <rtems_rfs_dir_read+0x388> <== NOT EXECUTED
201c880: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
201c884: 2b 00 00 3f sethi %hi(0xfc00), %l5
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
201c888: 2d 00 80 d0 sethi %hi(0x2034000), %l6
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201c88c: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201c890: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201c894: 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)
201c898: aa 15 63 ff or %l5, 0x3ff, %l5
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
201c89c: ac 15 a1 80 or %l6, 0x180, %l6
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201c8a0: ae 10 00 11 mov %l1, %l7
201c8a4: a8 10 00 12 mov %l2, %l4
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
201c8a8: d4 07 bf a0 ld [ %fp + -96 ], %o2
201c8ac: 90 10 00 18 mov %i0, %o0
201c8b0: 92 07 bf a4 add %fp, -92, %o1
201c8b4: 7f ff fa d1 call 201b3f8 <rtems_rfs_buffer_handle_request>
201c8b8: 96 10 20 01 mov 1, %o3
if (rc > 0)
201c8bc: a0 92 20 00 orcc %o0, 0, %l0
201c8c0: 04 80 00 04 ble 201c8d0 <rtems_rfs_dir_read+0x160> <== ALWAYS TAKEN
201c8c4: c2 07 bf ac ld [ %fp + -84 ], %g1
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201c8c8: 10 80 00 88 b 201cae8 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
201c8cc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
201c8d0: e6 07 bf c4 ld [ %fp + -60 ], %l3
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
201c8d4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
entry += map.bpos.boff;
201c8d8: a2 00 40 13 add %g1, %l3, %l1
elength = rtems_rfs_dir_entry_length (entry);
201c8dc: c4 0c 60 09 ldub [ %l1 + 9 ], %g2
201c8e0: e4 0c 60 08 ldub [ %l1 + 8 ], %l2
eino = rtems_rfs_dir_entry_ino (entry);
201c8e4: c8 08 40 13 ldub [ %g1 + %l3 ], %g4
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
201c8e8: a5 2c a0 08 sll %l2, 8, %l2
eino = rtems_rfs_dir_entry_ino (entry);
201c8ec: c6 0c 60 01 ldub [ %l1 + 1 ], %g3
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
201c8f0: a4 14 80 02 or %l2, %g2, %l2
eino = rtems_rfs_dir_entry_ino (entry);
201c8f4: c2 0c 60 02 ldub [ %l1 + 2 ], %g1
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
201c8f8: 80 a4 80 15 cmp %l2, %l5
201c8fc: 02 80 00 5d be 201ca70 <rtems_rfs_dir_read+0x300>
201c900: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
201c904: a9 29 20 18 sll %g4, 0x18, %l4
201c908: 86 08 e0 ff and %g3, 0xff, %g3
201c90c: 84 08 a0 ff and %g2, 0xff, %g2
201c910: 87 28 e0 10 sll %g3, 0x10, %g3
201c914: 82 08 60 ff and %g1, 0xff, %g1
201c918: a8 15 00 03 or %l4, %g3, %l4
201c91c: 83 28 60 08 sll %g1, 8, %g1
201c920: a8 15 00 02 or %l4, %g2, %l4
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201c924: 80 a4 a0 0a cmp %l2, 0xa
201c928: 04 80 00 0d ble 201c95c <rtems_rfs_dir_read+0x1ec> <== NEVER TAKEN
201c92c: a8 15 00 01 or %l4, %g1, %l4
201c930: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
201c934: 80 a4 80 01 cmp %l2, %g1
201c938: 1a 80 00 0a bcc 201c960 <rtems_rfs_dir_read+0x1f0> <== NEVER TAKEN
201c93c: 90 10 20 00 clr %o0
201c940: 80 a5 20 00 cmp %l4, 0
201c944: 02 80 00 08 be 201c964 <rtems_rfs_dir_read+0x1f4> <== NEVER TAKEN
201c948: 13 20 00 00 sethi %hi(0x80000000), %o1
201c94c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
201c950: 80 a5 00 01 cmp %l4, %g1
201c954: 08 80 00 12 bleu 201c99c <rtems_rfs_dir_read+0x22c> <== ALWAYS TAKEN
201c958: 90 10 00 1c mov %i4, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201c95c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c960: 13 20 00 00 sethi %hi(0x80000000), %o1 <== NOT EXECUTED
201c964: 7f ff db 69 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201c968: a0 10 20 05 mov 5, %l0 <== NOT EXECUTED
201c96c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c970: 22 80 00 5e be,a 201cae8 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
201c974: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
201c978: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201c97c: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
201c980: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c984: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
201c988: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
201c98c: 40 00 15 7e call 2021f84 <printf> <== NOT EXECUTED
201c990: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201c994: 10 80 00 55 b 201cae8 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
201c998: 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));
201c99c: 92 10 20 00 clr %o1
201c9a0: 40 00 14 fb call 2021d8c <memset>
201c9a4: 94 10 21 18 mov 0x118, %o2
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
201c9a8: 82 10 21 18 mov 0x118, %g1
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
201c9ac: f4 3f 20 08 std %i2, [ %i4 + 8 ]
dirent->d_reclen = sizeof (struct dirent);
201c9b0: c2 37 20 10 sth %g1, [ %i4 + 0x10 ]
*length += elength;
201c9b4: c2 07 40 00 ld [ %i5 ], %g1
201c9b8: 82 04 80 01 add %l2, %g1, %g1
201c9bc: c2 27 40 00 st %g1, [ %i5 ]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
201c9c0: c4 06 20 08 ld [ %i0 + 8 ], %g2
201c9c4: a6 20 80 13 sub %g2, %l3, %l3
201c9c8: a6 24 c0 12 sub %l3, %l2, %l3
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
201c9cc: 80 a4 e0 0a cmp %l3, 0xa
201c9d0: 14 80 00 04 bg 201c9e0 <rtems_rfs_dir_read+0x270> <== ALWAYS TAKEN
201c9d4: a4 04 bf f6 add %l2, -10, %l2
*length += remaining;
201c9d8: 82 04 c0 01 add %l3, %g1, %g1 <== NOT EXECUTED
201c9dc: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED
201c9e0: 80 a4 a0 ff cmp %l2, 0xff
201c9e4: 34 80 00 02 bg,a 201c9ec <rtems_rfs_dir_read+0x27c> <== NEVER TAKEN
201c9e8: a4 10 20 ff mov 0xff, %l2 <== NOT EXECUTED
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
201c9ec: 92 04 60 0a add %l1, 0xa, %o1
201c9f0: 94 10 00 12 mov %l2, %o2
201c9f4: ba 07 20 14 add %i4, 0x14, %i5
201c9f8: 40 00 14 56 call 2021b50 <memcpy>
201c9fc: 90 10 00 1d mov %i5, %o0
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
201ca00: c4 0c 40 00 ldub [ %l1 ], %g2
201ca04: c2 0c 60 01 ldub [ %l1 + 1 ], %g1
201ca08: 85 28 a0 18 sll %g2, 0x18, %g2
201ca0c: 83 28 60 10 sll %g1, 0x10, %g1
201ca10: 82 10 80 01 or %g2, %g1, %g1
201ca14: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201ca18: 90 10 20 00 clr %o0
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
201ca1c: 82 10 40 02 or %g1, %g2, %g1
201ca20: c4 0c 60 02 ldub [ %l1 + 2 ], %g2
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201ca24: 13 20 00 00 sethi %hi(0x80000000), %o1
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
201ca28: 85 28 a0 08 sll %g2, 8, %g2
201ca2c: 82 10 40 02 or %g1, %g2, %g1
dirent->d_namlen = elength;
201ca30: e4 37 20 12 sth %l2, [ %i4 + 0x12 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201ca34: 7f ff db 35 call 2013708 <rtems_rfs_trace>
201ca38: c2 27 00 00 st %g1, [ %i4 ]
201ca3c: 80 8a 20 ff btst 0xff, %o0
201ca40: 22 80 00 2a be,a 201cae8 <rtems_rfs_dir_read+0x378> <== ALWAYS TAKEN
201ca44: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
201ca48: c4 1f 20 08 ldd [ %i4 + 8 ], %g2 <== NOT EXECUTED
201ca4c: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
201ca50: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201ca54: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
201ca58: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
201ca5c: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
201ca60: 40 00 15 49 call 2021f84 <printf> <== NOT EXECUTED
201ca64: 90 12 21 48 or %o0, 0x148, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201ca68: 10 80 00 20 b 201cae8 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
201ca6c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
201ca70: c2 06 20 08 ld [ %i0 + 8 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201ca74: 90 10 20 00 clr %o0
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
201ca78: a6 20 40 13 sub %g1, %l3, %l3
201ca7c: c2 07 40 00 ld [ %i5 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201ca80: 13 20 00 00 sethi %hi(0x80000000), %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
201ca84: a6 00 40 13 add %g1, %l3, %l3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201ca88: 7f ff db 20 call 2013708 <rtems_rfs_trace>
201ca8c: e6 27 40 00 st %l3, [ %i5 ]
201ca90: 80 8a 20 ff btst 0xff, %o0
201ca94: 02 80 00 08 be 201cab4 <rtems_rfs_dir_read+0x344> <== ALWAYS TAKEN
201ca98: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
201ca9c: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
201caa0: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
201caa4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201caa8: 40 00 15 37 call 2021f84 <printf> <== NOT EXECUTED
201caac: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201cab0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201cab4: 92 10 00 17 mov %l7, %o1
201cab8: 7f ff f7 b1 call 201a97c <rtems_rfs_block_map_next_block>
201cabc: 94 10 00 14 mov %l4, %o2
if (rc == ENXIO)
201cac0: 80 a2 20 06 cmp %o0, 6
201cac4: 02 80 00 07 be 201cae0 <rtems_rfs_dir_read+0x370> <== ALWAYS TAKEN
201cac8: 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)
201cacc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201cad0: 02 bf ff 77 be 201c8ac <rtems_rfs_dir_read+0x13c> <== NOT EXECUTED
201cad4: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201cad8: 10 80 00 04 b 201cae8 <rtems_rfs_dir_read+0x378> <== NOT EXECUTED
201cadc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
201cae0: a0 10 20 02 mov 2, %l0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201cae4: 92 07 bf a4 add %fp, -92, %o1
201cae8: 7f ff fb f9 call 201bacc <rtems_rfs_buffer_handle_close>
201caec: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
201caf0: 90 10 00 18 mov %i0, %o0
201caf4: 92 07 bf b0 add %fp, -80, %o1
201caf8: 7f ff f6 b4 call 201a5c8 <rtems_rfs_block_map_close>
201cafc: 01 00 00 00 nop
return rc;
}
201cb00: 81 c7 e0 08 ret
201cb04: 91 e8 00 10 restore %g0, %l0, %o0
0201cd5c <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
201cd5c: 9d e3 bf a0 save %sp, -96, %sp
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
201cd60: 90 10 20 10 mov 0x10, %o0
201cd64: 7f ff da 69 call 2013708 <rtems_rfs_trace>
201cd68: 92 10 20 00 clr %o1
201cd6c: 80 8a 20 ff btst 0xff, %o0
201cd70: 22 80 00 08 be,a 201cd90 <rtems_rfs_file_close+0x34> <== ALWAYS TAKEN
201cd74: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
201cd78: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
201cd7c: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201cd80: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED
201cd84: 40 00 14 80 call 2021f84 <printf> <== NOT EXECUTED
201cd88: 90 12 22 20 or %o0, 0x220, %o0 <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
201cd8c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED
201cd90: c2 02 60 08 ld [ %o1 + 8 ], %g1
201cd94: 80 a0 60 00 cmp %g1, 0
201cd98: 04 80 00 03 ble 201cda4 <rtems_rfs_file_close+0x48> <== NEVER TAKEN
201cd9c: 82 00 7f ff add %g1, -1, %g1
handle->shared->references--;
201cda0: c2 22 60 08 st %g1, [ %o1 + 8 ]
if (handle->shared->references == 0)
201cda4: c2 02 60 08 ld [ %o1 + 8 ], %g1
201cda8: 80 a0 60 00 cmp %g1, 0
201cdac: 12 80 00 7e bne 201cfa4 <rtems_rfs_file_close+0x248> <== NEVER TAKEN
201cdb0: ba 10 20 00 clr %i5
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
201cdb4: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
201cdb8: 80 a0 60 00 cmp %g1, 0
201cdbc: 32 80 00 09 bne,a 201cde0 <rtems_rfs_file_close+0x84> <== NEVER TAKEN
201cdc0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
201cdc4: 90 10 00 18 mov %i0, %o0
201cdc8: 7f ff d3 9a call 2011c30 <rtems_rfs_inode_load>
201cdcc: 92 02 60 0c add %o1, 0xc, %o1
if (rrc == 0)
201cdd0: ba 92 20 00 orcc %o0, 0, %i5
201cdd4: 32 80 00 3f bne,a 201ced0 <rtems_rfs_file_close+0x174> <== NEVER TAKEN
201cdd8: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
201cddc: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
201cde0: c4 00 60 8c ld [ %g1 + 0x8c ], %g2
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
201cde4: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
201cde8: 89 30 a0 18 srl %g2, 0x18, %g4
201cdec: c8 28 e0 10 stb %g4, [ %g3 + 0x10 ]
201cdf0: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
201cdf4: 89 30 a0 10 srl %g2, 0x10, %g4
201cdf8: c8 28 e0 11 stb %g4, [ %g3 + 0x11 ]
201cdfc: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
201ce00: 89 30 a0 08 srl %g2, 8, %g4
201ce04: c8 28 e0 12 stb %g4, [ %g3 + 0x12 ]
201ce08: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
201ce0c: c4 28 e0 13 stb %g2, [ %g3 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201ce10: 86 10 20 01 mov 1, %g3
201ce14: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
201ce18: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
201ce1c: c4 00 60 90 ld [ %g1 + 0x90 ], %g2
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
201ce20: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201ce24: bb 30 a0 18 srl %g2, 0x18, %i5
201ce28: fa 29 20 14 stb %i5, [ %g4 + 0x14 ]
201ce2c: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201ce30: bb 30 a0 10 srl %g2, 0x10, %i5
201ce34: fa 29 20 15 stb %i5, [ %g4 + 0x15 ]
201ce38: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201ce3c: bb 30 a0 08 srl %g2, 8, %i5
201ce40: fa 29 20 16 stb %i5, [ %g4 + 0x16 ]
201ce44: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201ce48: c4 29 20 17 stb %g2, [ %g4 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201ce4c: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
201ce50: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
201ce54: c4 00 60 94 ld [ %g1 + 0x94 ], %g2
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
201ce58: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201ce5c: bb 30 a0 18 srl %g2, 0x18, %i5
201ce60: fa 29 20 18 stb %i5, [ %g4 + 0x18 ]
201ce64: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201ce68: bb 30 a0 10 srl %g2, 0x10, %i5
201ce6c: fa 29 20 19 stb %i5, [ %g4 + 0x19 ]
201ce70: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201ce74: bb 30 a0 08 srl %g2, 8, %i5
201ce78: fa 29 20 1a stb %i5, [ %g4 + 0x1a ]
201ce7c: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201ce80: c4 29 20 1b stb %g2, [ %g4 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201ce84: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
201ce88: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
201ce8c: c4 00 60 84 ld [ %g1 + 0x84 ], %g2
201ce90: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
201ce94: 80 a0 80 03 cmp %g2, %g3
201ce98: 32 80 00 08 bne,a 201ceb8 <rtems_rfs_file_close+0x15c> <== NEVER TAKEN
201ce9c: c4 20 60 3c st %g2, [ %g1 + 0x3c ] <== NOT EXECUTED
201cea0: c8 00 60 88 ld [ %g1 + 0x88 ], %g4
201cea4: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
201cea8: 80 a1 00 03 cmp %g4, %g3
201ceac: 02 80 00 08 be 201cecc <rtems_rfs_file_close+0x170> <== ALWAYS TAKEN
201ceb0: ba 10 20 00 clr %i5
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
201ceb4: c4 20 60 3c st %g2, [ %g1 + 0x3c ] <== NOT EXECUTED
201ceb8: c4 00 60 88 ld [ %g1 + 0x88 ], %g2 <== NOT EXECUTED
map->dirty = true;
201cebc: ba 10 20 00 clr %i5 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
201cec0: c4 20 60 40 st %g2, [ %g1 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
201cec4: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
201cec8: c4 28 60 34 stb %g2, [ %g1 + 0x34 ] <== NOT EXECUTED
&handle->shared->map.size))
rtems_rfs_block_map_set_size (&handle->shared->map,
&handle->shared->size);
}
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
201cecc: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
201ced0: 90 10 00 18 mov %i0, %o0
201ced4: 7f ff f5 bd call 201a5c8 <rtems_rfs_block_map_close>
201ced8: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
201cedc: b8 92 20 00 orcc %o0, 0, %i4
201cee0: 04 80 00 14 ble 201cf30 <rtems_rfs_file_close+0x1d4> <== ALWAYS TAKEN
201cee4: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
201cee8: 7f ff da 08 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201ceec: 92 10 20 00 clr %o1 <== NOT EXECUTED
201cef0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201cef4: 02 80 00 0d be 201cf28 <rtems_rfs_file_close+0x1cc> <== NOT EXECUTED
201cef8: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
201cefc: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
201cf00: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201cf04: 40 00 18 8c call 2023134 <strerror> <== NOT EXECUTED
201cf08: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
201cf0c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201cf10: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201cf14: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201cf18: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201cf1c: 40 00 14 1a call 2021f84 <printf> <== NOT EXECUTED
201cf20: 90 12 22 48 or %o0, 0x248, %o0 ! 2034248 <CSWTCH.2+0xd68> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
201cf24: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
201cf28: 22 80 00 02 be,a 201cf30 <rtems_rfs_file_close+0x1d4> <== NOT EXECUTED
201cf2c: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
201cf30: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
201cf34: 90 10 00 18 mov %i0, %o0
201cf38: 7f ff d3 dd call 2011eac <rtems_rfs_inode_close>
201cf3c: 92 02 60 0c add %o1, 0xc, %o1
if (rc > 0)
201cf40: b8 92 20 00 orcc %o0, 0, %i4
201cf44: 04 80 00 14 ble 201cf94 <rtems_rfs_file_close+0x238> <== ALWAYS TAKEN
201cf48: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
201cf4c: 7f ff d9 ef call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201cf50: 92 10 20 00 clr %o1 <== NOT EXECUTED
201cf54: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201cf58: 02 80 00 0d be 201cf8c <rtems_rfs_file_close+0x230> <== NOT EXECUTED
201cf5c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
201cf60: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
201cf64: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201cf68: 40 00 18 73 call 2023134 <strerror> <== NOT EXECUTED
201cf6c: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
201cf70: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201cf74: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201cf78: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201cf7c: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201cf80: 40 00 14 01 call 2021f84 <printf> <== NOT EXECUTED
201cf84: 90 12 22 88 or %o0, 0x288, %o0 ! 2034288 <CSWTCH.2+0xda8> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
201cf88: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
201cf8c: 22 80 00 02 be,a 201cf94 <rtems_rfs_file_close+0x238> <== NOT EXECUTED
201cf90: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
201cf94: 7f ff ec a1 call 2018218 <_Chain_Extract>
201cf98: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
201cf9c: 7f ff ac 12 call 2007fe4 <free>
201cfa0: 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);
201cfa4: 90 10 00 18 mov %i0, %o0
201cfa8: 7f ff f8 a0 call 201b228 <rtems_rfs_buffer_handle_release>
201cfac: 92 06 60 04 add %i1, 4, %o1
handle->dirty = false;
201cfb0: c0 2e 60 04 clrb [ %i1 + 4 ]
handle->bnum = 0;
201cfb4: 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)
201cfb8: 80 a7 60 00 cmp %i5, 0
201cfbc: 04 80 00 0f ble 201cff8 <rtems_rfs_file_close+0x29c> <== ALWAYS TAKEN
201cfc0: c0 26 60 0c clr [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
201cfc4: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED
201cfc8: 7f ff d9 d0 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201cfcc: 92 10 20 00 clr %o1 <== NOT EXECUTED
201cfd0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201cfd4: 22 80 00 0a be,a 201cffc <rtems_rfs_file_close+0x2a0> <== NOT EXECUTED
201cfd8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
201cfdc: 40 00 18 56 call 2023134 <strerror> <== NOT EXECUTED
201cfe0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201cfe4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201cfe8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201cfec: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201cff0: 40 00 13 e5 call 2021f84 <printf> <== NOT EXECUTED
201cff4: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 20342c8 <CSWTCH.2+0xde8> <== NOT EXECUTED
}
free (handle);
201cff8: 90 10 00 19 mov %i1, %o0
201cffc: 7f ff ab fa call 2007fe4 <free>
201d000: b0 10 00 1d mov %i5, %i0
return rrc;
}
201d004: 81 c7 e0 08 ret
201d008: 81 e8 00 00 restore
0201d230 <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
201d230: 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))
201d234: 90 10 20 20 mov 0x20, %o0
201d238: 92 10 20 00 clr %o1
201d23c: 7f ff d9 33 call 2013708 <rtems_rfs_trace>
201d240: ba 10 00 18 mov %i0, %i5
201d244: 80 8a 20 ff btst 0xff, %o0
201d248: 22 80 00 0e be,a 201d280 <rtems_rfs_file_io_end+0x50> <== ALWAYS TAKEN
201d24c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
201d250: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
201d254: 22 80 00 05 be,a 201d268 <rtems_rfs_file_io_end+0x38> <== NOT EXECUTED
201d258: 13 00 80 d0 sethi %hi(0x2034000), %o1 <== NOT EXECUTED
201d25c: 13 00 80 cc sethi %hi(0x2033000), %o1 <== NOT EXECUTED
201d260: 10 80 00 03 b 201d26c <rtems_rfs_file_io_end+0x3c> <== NOT EXECUTED
201d264: 92 12 60 a8 or %o1, 0xa8, %o1 ! 20330a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
201d268: 92 12 62 f0 or %o1, 0x2f0, %o1 <== NOT EXECUTED
201d26c: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201d270: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
201d274: 40 00 13 44 call 2021f84 <printf> <== NOT EXECUTED
201d278: 90 12 23 b0 or %o0, 0x3b0, %o0 <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
201d27c: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
201d280: 80 a0 60 00 cmp %g1, 0
201d284: 02 80 00 1e be 201d2fc <rtems_rfs_file_io_end+0xcc> <== NEVER TAKEN
201d288: 80 a6 a0 00 cmp %i2, 0
{
if (!read)
201d28c: 32 80 00 05 bne,a 201d2a0 <rtems_rfs_file_io_end+0x70>
201d290: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
201d294: 82 10 20 01 mov 1, %g1
201d298: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201d29c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
201d2a0: 92 07 60 04 add %i5, 4, %o1
201d2a4: 7f ff f7 e1 call 201b228 <rtems_rfs_buffer_handle_release>
201d2a8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
rtems_rfs_file_buffer (handle));
if (rc > 0)
201d2ac: b0 92 20 00 orcc %o0, 0, %i0
201d2b0: 04 80 00 14 ble 201d300 <rtems_rfs_file_io_end+0xd0> <== ALWAYS TAKEN
201d2b4: 80 a6 a0 00 cmp %i2, 0
{
printf (
201d2b8: 22 80 00 05 be,a 201d2cc <rtems_rfs_file_io_end+0x9c> <== NOT EXECUTED
201d2bc: 3b 00 80 d0 sethi %hi(0x2034000), %i5 <== NOT EXECUTED
201d2c0: 3b 00 80 cc sethi %hi(0x2033000), %i5 <== NOT EXECUTED
201d2c4: 10 80 00 03 b 201d2d0 <rtems_rfs_file_io_end+0xa0> <== NOT EXECUTED
201d2c8: ba 17 60 a8 or %i5, 0xa8, %i5 ! 20330a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
201d2cc: ba 17 62 f0 or %i5, 0x2f0, %i5 <== NOT EXECUTED
201d2d0: 40 00 17 99 call 2023134 <strerror> <== NOT EXECUTED
201d2d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201d2d8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201d2dc: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
201d2e0: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
201d2e4: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201d2e8: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
201d2ec: 40 00 13 26 call 2021f84 <printf> <== NOT EXECUTED
201d2f0: 90 12 23 d8 or %o0, 0x3d8, %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;
201d2f4: 81 c7 e0 08 ret <== NOT EXECUTED
201d2f8: 81 e8 00 00 restore <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
201d2fc: b0 10 20 00 clr %i0 <== NOT EXECUTED
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
201d300: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
201d304: b2 06 40 01 add %i1, %g1, %i1
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
201d308: 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;
201d30c: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
201d310: c4 00 60 98 ld [ %g1 + 0x98 ], %g2
201d314: 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 >=
201d318: 80 a6 40 02 cmp %i1, %g2
201d31c: 0a 80 00 07 bcs 201d338 <rtems_rfs_file_io_end+0x108>
201d320: 80 a6 a0 00 cmp %i2, 0
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
201d324: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201d328: 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++;
201d32c: 86 00 e0 01 inc %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201d330: 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++;
201d334: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
}
length = false;
mtime = false;
if (!read &&
201d338: 12 80 00 19 bne 201d39c <rtems_rfs_file_io_end+0x16c>
201d33c: 84 10 20 00 clr %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
201d340: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
}
length = false;
mtime = false;
if (!read &&
201d344: 80 a0 e0 00 cmp %g3, 0
201d348: 02 80 00 05 be 201d35c <rtems_rfs_file_io_end+0x12c>
201d34c: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
201d350: 80 a0 a0 00 cmp %g2, 0
201d354: 22 80 00 0f be,a 201d390 <rtems_rfs_file_io_end+0x160> <== NEVER TAKEN
201d358: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 <== NOT EXECUTED
201d35c: 80 a0 c0 02 cmp %g3, %g2
201d360: 3a 80 00 0c bcc,a 201d390 <rtems_rfs_file_io_end+0x160>
201d364: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
201d368: 88 00 bf ff add %g2, -1, %g4
201d36c: 80 a0 c0 04 cmp %g3, %g4
201d370: 12 80 00 0b bne 201d39c <rtems_rfs_file_io_end+0x16c>
201d374: 84 10 20 00 clr %g2
201d378: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
201d37c: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
201d380: 80 a1 00 03 cmp %g4, %g3
201d384: 28 80 00 07 bleu,a 201d3a0 <rtems_rfs_file_io_end+0x170>
201d388: c2 07 40 00 ld [ %i5 ], %g1
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
201d38c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
201d390: c4 20 60 40 st %g2, [ %g1 + 0x40 ]
map->dirty = true;
201d394: 84 10 20 01 mov 1, %g2
201d398: c4 28 60 34 stb %g2, [ %g1 + 0x34 ]
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
201d39c: c2 07 40 00 ld [ %i5 ], %g1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
201d3a0: b8 10 20 00 clr %i4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
201d3a4: a2 08 60 01 and %g1, 1, %l1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
201d3a8: 80 88 60 02 btst 2, %g1
201d3ac: a2 1c 60 01 xor %l1, 1, %l1
201d3b0: 12 80 00 03 bne 201d3bc <rtems_rfs_file_io_end+0x18c> <== NEVER TAKEN
201d3b4: a0 10 00 11 mov %l1, %l0
201d3b8: b8 08 a0 ff and %g2, 0xff, %i4
201d3bc: b2 0f 20 01 and %i4, 1, %i1
length = rtems_rfs_file_update_length (handle) && length;
201d3c0: 80 88 60 04 btst 4, %g1
201d3c4: 12 80 00 03 bne 201d3d0 <rtems_rfs_file_io_end+0x1a0> <== NEVER TAKEN
201d3c8: b6 10 20 00 clr %i3
201d3cc: b6 08 a0 ff and %g2, 0xff, %i3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d3d0: 90 10 20 20 mov 0x20, %o0
201d3d4: 92 10 20 00 clr %o1
201d3d8: 7f ff d8 cc call 2013708 <rtems_rfs_trace>
201d3dc: b6 0e e0 01 and %i3, 1, %i3
201d3e0: 80 8a 20 ff btst 0xff, %o0
201d3e4: 22 80 00 17 be,a 201d440 <rtems_rfs_file_io_end+0x210> <== ALWAYS TAKEN
201d3e8: b8 17 00 11 or %i4, %l1, %i4
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
201d3ec: 82 0c 20 ff and %l0, 0xff, %g1 <== NOT EXECUTED
201d3f0: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
201d3f4: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
201d3f8: 96 40 3f ff addx %g0, -1, %o3 <== NOT EXECUTED
201d3fc: 82 0e 60 ff and %i1, 0xff, %g1 <== NOT EXECUTED
201d400: d4 07 60 14 ld [ %i5 + 0x14 ], %o2 <== NOT EXECUTED
201d404: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
201d408: 82 0e e0 ff and %i3, 0xff, %g1 <== NOT EXECUTED
201d40c: 98 40 3f ff addx %g0, -1, %o4 <== NOT EXECUTED
201d410: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
201d414: 96 0a ff ec and %o3, -20, %o3 <== NOT EXECUTED
201d418: 98 0b 3f e0 and %o4, -32, %o4 <== NOT EXECUTED
201d41c: 9a 40 3f ff addx %g0, -1, %o5 <== NOT EXECUTED
201d420: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d424: 9a 0b 7f e1 and %o5, -31, %o5 <== NOT EXECUTED
201d428: 90 12 20 20 or %o0, 0x20, %o0 <== NOT EXECUTED
201d42c: 96 02 e0 41 add %o3, 0x41, %o3 <== NOT EXECUTED
201d430: 98 03 20 4d add %o4, 0x4d, %o4 <== NOT EXECUTED
201d434: 40 00 12 d4 call 2021f84 <printf> <== NOT EXECUTED
201d438: 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)
201d43c: b8 17 00 11 or %i4, %l1, %i4 <== NOT EXECUTED
201d440: 80 8f 20 01 btst 1, %i4
201d444: 02 80 00 13 be 201d490 <rtems_rfs_file_io_end+0x260> <== NEVER TAKEN
201d448: 80 8e e0 ff btst 0xff, %i3
{
time_t now = time (NULL);
201d44c: 40 00 22 ea call 2025ff4 <time>
201d450: 90 10 20 00 clr %o0
if (read && atime)
201d454: 80 a6 a0 00 cmp %i2, 0
201d458: 02 80 00 07 be 201d474 <rtems_rfs_file_io_end+0x244>
201d45c: 80 8e 60 ff btst 0xff, %i1
201d460: 80 8c 20 ff btst 0xff, %l0
201d464: 02 80 00 04 be 201d474 <rtems_rfs_file_io_end+0x244> <== NEVER TAKEN
201d468: 80 8e 60 ff btst 0xff, %i1
handle->shared->atime = now;
201d46c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
201d470: d0 20 60 8c st %o0, [ %g1 + 0x8c ]
if (!read && mtime)
201d474: 02 80 00 07 be 201d490 <rtems_rfs_file_io_end+0x260>
201d478: 80 8e e0 ff btst 0xff, %i3
201d47c: 80 a6 a0 01 cmp %i2, 1
201d480: 02 80 00 04 be 201d490 <rtems_rfs_file_io_end+0x260> <== NEVER TAKEN
201d484: 80 8e e0 ff btst 0xff, %i3
handle->shared->mtime = now;
201d488: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
201d48c: d0 20 60 90 st %o0, [ %g1 + 0x90 ]
}
if (length)
201d490: 02 80 00 07 be 201d4ac <rtems_rfs_file_io_end+0x27c>
201d494: 01 00 00 00 nop
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
201d498: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
201d49c: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
201d4a0: c4 20 60 84 st %g2, [ %g1 + 0x84 ]
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
201d4a4: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
201d4a8: c4 20 60 88 st %g2, [ %g1 + 0x88 ]
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
201d4ac: 81 c7 e0 08 ret
201d4b0: 81 e8 00 00 restore
0201d4b4 <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))
201d4b4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
201d4b8: 80 a0 60 00 cmp %g1, 0
201d4bc: 02 80 00 08 be 201d4dc <rtems_rfs_file_io_release+0x28> <== ALWAYS TAKEN
201d4c0: 92 10 00 08 mov %o0, %o1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201d4c4: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED
201d4c8: 92 02 60 04 add %o1, 4, %o1 <== NOT EXECUTED
201d4cc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
201d4d0: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
201d4d4: 7f ff f7 55 call 201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201d4d8: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
201d4dc: 81 c3 e0 08 retl
201d4e0: 90 10 20 00 clr %o0
0201d00c <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
201d00c: 9d e3 bf 98 save %sp, -104, %sp
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d010: 90 10 20 20 mov 0x20, %o0
201d014: 92 10 20 00 clr %o1
201d018: 7f ff d9 bc call 2013708 <rtems_rfs_trace>
201d01c: ba 10 00 18 mov %i0, %i5
201d020: 80 8a 20 ff btst 0xff, %o0
201d024: 22 80 00 0f be,a 201d060 <rtems_rfs_file_io_start+0x54> <== ALWAYS TAKEN
201d028: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
201d02c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
201d030: 22 80 00 05 be,a 201d044 <rtems_rfs_file_io_start+0x38> <== NOT EXECUTED
201d034: 13 00 80 d0 sethi %hi(0x2034000), %o1 <== NOT EXECUTED
201d038: 13 00 80 cc sethi %hi(0x2033000), %o1 <== NOT EXECUTED
201d03c: 10 80 00 03 b 201d048 <rtems_rfs_file_io_start+0x3c> <== NOT EXECUTED
201d040: 92 12 60 a8 or %o1, 0xa8, %o1 ! 20330a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
201d044: 92 12 62 f0 or %o1, 0x2f0, %o1 <== NOT EXECUTED
201d048: d4 07 60 10 ld [ %i5 + 0x10 ], %o2 <== NOT EXECUTED
201d04c: d6 07 60 14 ld [ %i5 + 0x14 ], %o3 <== NOT EXECUTED
201d050: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201d054: 40 00 13 cc call 2021f84 <printf> <== NOT EXECUTED
201d058: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 20342f8 <CSWTCH.2+0xe18> <== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
201d05c: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
201d060: 80 a0 60 00 cmp %g1, 0
201d064: 12 80 00 4f bne 201d1a0 <rtems_rfs_file_io_start+0x194>
201d068: 80 a6 a0 00 cmp %i2, 0
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
201d06c: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
201d070: 94 07 60 10 add %i5, 0x10, %o2
201d074: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201d078: 96 07 bf fc add %fp, -4, %o3
201d07c: 7f ff f5 c7 call 201a798 <rtems_rfs_block_map_find>
201d080: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
201d084: b0 92 20 00 orcc %o0, 0, %i0
201d088: 04 80 00 1e ble 201d100 <rtems_rfs_file_io_start+0xf4>
201d08c: 80 a6 20 06 cmp %i0, 6
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
201d090: 32 80 00 66 bne,a 201d228 <rtems_rfs_file_io_start+0x21c><== NEVER TAKEN
201d094: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
201d098: 80 a6 a0 00 cmp %i2, 0
201d09c: 22 80 00 05 be,a 201d0b0 <rtems_rfs_file_io_start+0xa4> <== ALWAYS TAKEN
201d0a0: 80 a6 20 06 cmp %i0, 6
{
*available = 0;
201d0a4: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
return 0;
201d0a8: 81 c7 e0 08 ret <== NOT EXECUTED
201d0ac: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
if (rc != ENXIO)
201d0b0: 12 80 00 5e bne 201d228 <rtems_rfs_file_io_start+0x21c> <== NEVER TAKEN
201d0b4: 90 10 20 20 mov 0x20, %o0
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d0b8: 7f ff d9 94 call 2013708 <rtems_rfs_trace>
201d0bc: 92 10 20 00 clr %o1
201d0c0: 80 8a 20 ff btst 0xff, %o0
201d0c4: 22 80 00 06 be,a 201d0dc <rtems_rfs_file_io_start+0xd0> <== ALWAYS TAKEN
201d0c8: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
printf ("rtems-rfs: file-io: start: grow\n");
201d0cc: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201d0d0: 40 00 14 45 call 20221e4 <puts> <== NOT EXECUTED
201d0d4: 90 12 23 28 or %o0, 0x328, %o0 ! 2034328 <CSWTCH.2+0xe48> <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
201d0d8: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
201d0dc: 94 10 20 01 mov 1, %o2
201d0e0: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201d0e4: 96 07 bf fc add %fp, -4, %o3
201d0e8: 7f ff f6 32 call 201a9b0 <rtems_rfs_block_map_grow>
201d0ec: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
201d0f0: b0 92 20 00 orcc %o0, 0, %i0
201d0f4: 14 80 00 4d bg 201d228 <rtems_rfs_file_io_start+0x21c>
201d0f8: b8 10 20 00 clr %i4
201d0fc: 30 80 00 0f b,a 201d138 <rtems_rfs_file_io_start+0x12c>
/*
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
201d100: 80 a6 a0 00 cmp %i2, 0
201d104: 12 80 00 0d bne 201d138 <rtems_rfs_file_io_start+0x12c>
201d108: b8 10 00 1a mov %i2, %i4
201d10c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
201d110: 80 a0 60 00 cmp %g1, 0
201d114: 12 80 00 09 bne 201d138 <rtems_rfs_file_io_start+0x12c>
201d118: b8 10 20 01 mov 1, %i4
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
201d11c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
(rtems_rfs_file_block_offset (handle) ||
201d120: c4 06 40 00 ld [ %i1 ], %g2
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
201d124: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
(rtems_rfs_file_block_offset (handle) ||
201d128: c2 00 60 08 ld [ %g1 + 8 ], %g1
201d12c: 80 a0 80 01 cmp %g2, %g1
201d130: 3a 80 00 02 bcc,a 201d138 <rtems_rfs_file_io_start+0x12c><== NEVER TAKEN
201d134: b8 10 20 00 clr %i4 <== NOT EXECUTED
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d138: 90 10 20 20 mov 0x20, %o0
201d13c: 7f ff d9 73 call 2013708 <rtems_rfs_trace>
201d140: 92 10 20 00 clr %o1
201d144: 80 8a 20 ff btst 0xff, %o0
201d148: 22 80 00 0e be,a 201d180 <rtems_rfs_file_io_start+0x174> <== ALWAYS TAKEN
201d14c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
201d150: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
201d154: 02 80 00 05 be 201d168 <rtems_rfs_file_io_start+0x15c> <== NOT EXECUTED
201d158: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
201d15c: 15 00 80 ca sethi %hi(0x2032800), %o2 <== NOT EXECUTED
201d160: 10 80 00 04 b 201d170 <rtems_rfs_file_io_start+0x164> <== NOT EXECUTED
201d164: 94 12 a3 28 or %o2, 0x328, %o2 ! 2032b28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
201d168: 15 00 80 c3 sethi %hi(0x2030c00), %o2 <== NOT EXECUTED
201d16c: 94 12 a0 10 or %o2, 0x10, %o2 ! 2030c10 <__FUNCTION__.7127+0x538><== NOT EXECUTED
201d170: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201d174: 40 00 13 84 call 2021f84 <printf> <== NOT EXECUTED
201d178: 90 12 23 48 or %o0, 0x348, %o0 ! 2034348 <CSWTCH.2+0xe68> <== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
201d17c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
201d180: d4 07 bf fc ld [ %fp + -4 ], %o2
201d184: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201d188: 92 07 60 04 add %i5, 4, %o1
201d18c: 7f ff f8 9b call 201b3f8 <rtems_rfs_buffer_handle_request>
201d190: 96 0f 20 ff and %i4, 0xff, %o3
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
201d194: b0 92 20 00 orcc %o0, 0, %i0
201d198: 14 80 00 24 bg 201d228 <rtems_rfs_file_io_start+0x21c> <== NEVER TAKEN
201d19c: 80 a6 a0 00 cmp %i2, 0
return rc;
}
if (read
201d1a0: 02 80 00 12 be 201d1e8 <rtems_rfs_file_io_start+0x1dc>
201d1a4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
201d1a8: c4 00 60 44 ld [ %g1 + 0x44 ], %g2
201d1ac: 80 a0 a0 00 cmp %g2, 0
201d1b0: 12 80 00 05 bne 201d1c4 <rtems_rfs_file_io_start+0x1b8>
201d1b4: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
201d1b8: 80 a0 e0 00 cmp %g3, 0
201d1bc: 22 80 00 07 be,a 201d1d8 <rtems_rfs_file_io_start+0x1cc> <== NEVER TAKEN
201d1c0: f8 00 60 40 ld [ %g1 + 0x40 ], %i4 <== NOT EXECUTED
201d1c4: 86 00 ff ff add %g3, -1, %g3
201d1c8: 80 a0 80 03 cmp %g2, %g3
201d1cc: 32 80 00 07 bne,a 201d1e8 <rtems_rfs_file_io_start+0x1dc>
201d1d0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
201d1d4: f8 00 60 40 ld [ %g1 + 0x40 ], %i4
201d1d8: 80 a7 20 00 cmp %i4, 0
201d1dc: 32 80 00 06 bne,a 201d1f4 <rtems_rfs_file_io_start+0x1e8>
201d1e0: 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));
201d1e4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
201d1e8: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
201d1ec: f8 00 60 08 ld [ %g1 + 8 ], %i4
*available = size - rtems_rfs_file_block_offset (handle);
201d1f0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d1f4: 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);
201d1f8: 82 27 00 01 sub %i4, %g1, %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d1fc: 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);
201d200: c2 26 40 00 st %g1, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d204: 7f ff d9 41 call 2013708 <rtems_rfs_trace>
201d208: b0 10 20 00 clr %i0
201d20c: 80 8a 20 ff btst 0xff, %o0
201d210: 02 80 00 06 be 201d228 <rtems_rfs_file_io_start+0x21c> <== ALWAYS TAKEN
201d214: 11 00 80 d0 sethi %hi(0x2034000), %o0
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
201d218: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
201d21c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201d220: 40 00 13 59 call 2021f84 <printf> <== NOT EXECUTED
201d224: 90 12 23 80 or %o0, 0x380, %o0 <== NOT EXECUTED
*available, size);
return 0;
}
201d228: 81 c7 e0 08 ret
201d22c: 81 e8 00 00 restore
0201d93c <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)
{
201d93c: 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))
201d940: 90 10 20 08 mov 8, %o0
201d944: 7f ff d7 71 call 2013708 <rtems_rfs_trace>
201d948: 92 10 20 00 clr %o1
201d94c: 80 8a 20 ff btst 0xff, %o0
201d950: 22 80 00 07 be,a 201d96c <rtems_rfs_file_open+0x30> <== ALWAYS TAKEN
201d954: c0 26 c0 00 clr [ %i3 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
201d958: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d95c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201d960: 40 00 11 89 call 2021f84 <printf> <== NOT EXECUTED
201d964: 90 12 20 a0 or %o0, 0xa0, %o0 <== NOT EXECUTED
*file = NULL;
201d968: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
/*
* Allocate a new handle and initialise it. Do this before we deal with the
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
201d96c: 90 10 20 20 mov 0x20, %o0
201d970: 7f ff ab 2e call 2008628 <malloc>
201d974: a0 10 20 0c mov 0xc, %l0
if (!handle)
201d978: 80 a2 20 00 cmp %o0, 0
201d97c: 02 80 00 a4 be 201dc0c <rtems_rfs_file_open+0x2d0> <== NEVER TAKEN
201d980: ba 10 00 08 mov %o0, %i5
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
201d984: 92 10 20 00 clr %o1
201d988: 40 00 11 01 call 2021d8c <memset>
201d98c: 94 10 20 20 mov 0x20, %o2
/*
* Scan the file system data list of open files for this ino. If found up
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
201d990: 90 10 00 18 mov %i0, %o0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201d994: c0 2f 60 04 clrb [ %i5 + 4 ]
handle->bnum = 0;
201d998: c0 27 60 08 clr [ %i5 + 8 ]
handle->buffer = NULL;
201d99c: c0 27 60 0c clr [ %i5 + 0xc ]
201d9a0: 7f ff ff d9 call 201d904 <rtems_rfs_file_get_shared>
201d9a4: 92 10 00 19 mov %i1, %o1
if (shared)
201d9a8: b8 92 20 00 orcc %o0, 0, %i4
201d9ac: 02 80 00 0d be 201d9e0 <rtems_rfs_file_open+0xa4> <== ALWAYS TAKEN
201d9b0: 90 10 20 08 mov 8, %o0
{
shared->references++;
201d9b4: c2 07 20 08 ld [ %i4 + 8 ], %g1 <== NOT EXECUTED
201d9b8: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201d9bc: 92 10 20 00 clr %o1 <== NOT EXECUTED
201d9c0: 7f ff d7 52 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201d9c4: c2 27 20 08 st %g1, [ %i4 + 8 ] <== NOT EXECUTED
201d9c8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d9cc: 22 80 00 8d be,a 201dc00 <rtems_rfs_file_open+0x2c4> <== NOT EXECUTED
201d9d0: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
201d9d4: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d9d8: 10 80 00 87 b 201dbf4 <rtems_rfs_file_open+0x2b8> <== NOT EXECUTED
201d9dc: 90 12 20 c0 or %o0, 0xc0, %o0 ! 20344c0 <CSWTCH.2+0xfe0> <== NOT EXECUTED
{
/*
* None exists so create. Copy in the shared parts of the inode we hold in
* memory.
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
201d9e0: 7f ff ab 12 call 2008628 <malloc>
201d9e4: 90 10 20 9c mov 0x9c, %o0
if (!shared)
201d9e8: b8 92 20 00 orcc %o0, 0, %i4
201d9ec: 12 80 00 04 bne 201d9fc <rtems_rfs_file_open+0xc0> <== ALWAYS TAKEN
201d9f0: 92 10 20 00 clr %o1
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
201d9f4: 10 80 00 34 b 201dac4 <rtems_rfs_file_open+0x188> <== NOT EXECUTED
201d9f8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
201d9fc: 40 00 10 e4 call 2021d8c <memset>
201da00: 94 10 20 9c mov 0x9c, %o2
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
201da04: a2 07 20 0c add %i4, 0xc, %l1
201da08: 90 10 00 18 mov %i0, %o0
201da0c: 92 10 00 19 mov %i1, %o1
201da10: 94 10 00 11 mov %l1, %o2
201da14: 7f ff d0 b4 call 2011ce4 <rtems_rfs_inode_open>
201da18: 96 10 20 01 mov 1, %o3
if (rc > 0)
201da1c: a0 92 20 00 orcc %o0, 0, %l0
201da20: 04 80 00 0f ble 201da5c <rtems_rfs_file_open+0x120> <== ALWAYS TAKEN
201da24: 90 10 20 08 mov 8, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201da28: 7f ff d7 38 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201da2c: 92 10 20 00 clr %o1 <== NOT EXECUTED
201da30: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201da34: 02 80 00 21 be 201dab8 <rtems_rfs_file_open+0x17c> <== NOT EXECUTED
201da38: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
201da3c: 40 00 15 be call 2023134 <strerror> <== NOT EXECUTED
201da40: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
201da44: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201da48: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201da4c: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201da50: 40 00 11 4d call 2021f84 <printf> <== NOT EXECUTED
201da54: 90 12 20 e8 or %o0, 0xe8, %o0 ! 20344e8 <CSWTCH.2+0x1008> <== NOT EXECUTED
201da58: 30 80 00 18 b,a 201dab8 <rtems_rfs_file_open+0x17c> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
201da5c: 90 10 00 18 mov %i0, %o0
201da60: 92 10 00 11 mov %l1, %o1
201da64: 7f ff f2 78 call 201a444 <rtems_rfs_block_map_open>
201da68: 94 07 20 34 add %i4, 0x34, %o2
if (rc > 0)
201da6c: a0 92 20 00 orcc %o0, 0, %l0
201da70: 04 80 00 1e ble 201dae8 <rtems_rfs_file_open+0x1ac> <== ALWAYS TAKEN
201da74: 82 10 20 01 mov 1, %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201da78: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
201da7c: 7f ff d7 23 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201da80: 92 10 20 00 clr %o1 <== NOT EXECUTED
201da84: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201da88: 22 80 00 0a be,a 201dab0 <rtems_rfs_file_open+0x174> <== NOT EXECUTED
201da8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
201da90: 40 00 15 a9 call 2023134 <strerror> <== NOT EXECUTED
201da94: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
201da98: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201da9c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201daa0: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201daa4: 40 00 11 38 call 2021f84 <printf> <== NOT EXECUTED
201daa8: 90 12 21 20 or %o0, 0x120, %o0 ! 2034520 <CSWTCH.2+0x1040><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
201daac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201dab0: 7f ff d0 ff call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201dab4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
free (shared);
201dab8: 7f ff a9 4b call 2007fe4 <free> <== NOT EXECUTED
201dabc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201dac0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201dac4: 7f ff f5 d9 call 201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201dac8: 92 07 60 04 add %i5, 4, %o1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
201dacc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
201dad0: c0 2f 60 04 clrb [ %i5 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
201dad4: c0 27 60 08 clr [ %i5 + 8 ] <== NOT EXECUTED
201dad8: 7f ff a9 43 call 2007fe4 <free> <== NOT EXECUTED
201dadc: c0 27 60 0c clr [ %i5 + 0xc ] <== NOT EXECUTED
return rc;
201dae0: 81 c7 e0 08 ret <== NOT EXECUTED
201dae4: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
}
shared->references = 1;
201dae8: c2 27 20 08 st %g1, [ %i4 + 8 ]
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
201daec: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
201daf0: 90 06 20 74 add %i0, 0x74, %o0
201daf4: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
201daf8: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
201dafc: 87 28 e0 18 sll %g3, 0x18, %g3
201db00: 85 28 a0 10 sll %g2, 0x10, %g2
201db04: 84 10 c0 02 or %g3, %g2, %g2
201db08: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
201db0c: 92 10 00 1c mov %i4, %o1
201db10: 84 10 80 03 or %g2, %g3, %g2
201db14: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
201db18: 87 28 e0 08 sll %g3, 8, %g3
201db1c: 84 10 80 03 or %g2, %g3, %g2
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
201db20: c4 27 20 84 st %g2, [ %i4 + 0x84 ]
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
201db24: 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);
201db28: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
201db2c: 85 28 a0 08 sll %g2, 8, %g2
201db30: 84 10 c0 02 or %g3, %g2, %g2
201db34: c4 27 20 88 st %g2, [ %i4 + 0x88 ]
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
201db38: c6 08 60 10 ldub [ %g1 + 0x10 ], %g3
201db3c: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
201db40: 87 28 e0 18 sll %g3, 0x18, %g3
201db44: 85 28 a0 10 sll %g2, 0x10, %g2
201db48: 84 10 c0 02 or %g3, %g2, %g2
201db4c: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
201db50: 84 10 80 03 or %g2, %g3, %g2
201db54: c6 08 60 12 ldub [ %g1 + 0x12 ], %g3
201db58: 87 28 e0 08 sll %g3, 8, %g3
201db5c: 84 10 80 03 or %g2, %g3, %g2
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
201db60: c4 27 20 8c st %g2, [ %i4 + 0x8c ]
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
201db64: c6 08 60 14 ldub [ %g1 + 0x14 ], %g3
201db68: c4 08 60 15 ldub [ %g1 + 0x15 ], %g2
201db6c: 87 28 e0 18 sll %g3, 0x18, %g3
201db70: 85 28 a0 10 sll %g2, 0x10, %g2
201db74: 84 10 c0 02 or %g3, %g2, %g2
201db78: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
201db7c: 84 10 80 03 or %g2, %g3, %g2
201db80: c6 08 60 16 ldub [ %g1 + 0x16 ], %g3
201db84: 87 28 e0 08 sll %g3, 8, %g3
201db88: 84 10 80 03 or %g2, %g3, %g2
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
201db8c: c4 27 20 90 st %g2, [ %i4 + 0x90 ]
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
201db90: c4 08 60 19 ldub [ %g1 + 0x19 ], %g2
201db94: c6 08 60 18 ldub [ %g1 + 0x18 ], %g3
201db98: 85 28 a0 10 sll %g2, 0x10, %g2
201db9c: 87 28 e0 18 sll %g3, 0x18, %g3
201dba0: 86 10 c0 02 or %g3, %g2, %g3
201dba4: c4 08 60 1b ldub [ %g1 + 0x1b ], %g2
201dba8: 86 10 c0 02 or %g3, %g2, %g3
201dbac: c4 08 60 1a ldub [ %g1 + 0x1a ], %g2
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
shared->fs = fs;
201dbb0: f0 27 20 98 st %i0, [ %i4 + 0x98 ]
201dbb4: 85 28 a0 08 sll %g2, 8, %g2
201dbb8: 82 10 c0 02 or %g3, %g2, %g1
201dbbc: 7f ff be 66 call 200d554 <_Chain_Append>
201dbc0: c2 27 20 94 st %g1, [ %i4 + 0x94 ]
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
201dbc4: 92 10 00 11 mov %l1, %o1
201dbc8: 94 10 20 00 clr %o2
201dbcc: 7f ff d0 7c call 2011dbc <rtems_rfs_inode_unload>
201dbd0: 90 10 00 18 mov %i0, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201dbd4: 90 10 20 08 mov 8, %o0
201dbd8: 7f ff d6 cc call 2013708 <rtems_rfs_trace>
201dbdc: 92 10 20 00 clr %o1
201dbe0: 80 8a 20 ff btst 0xff, %o0
201dbe4: 22 80 00 07 be,a 201dc00 <rtems_rfs_file_open+0x2c4> <== ALWAYS TAKEN
201dbe8: f4 27 40 00 st %i2, [ %i5 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
201dbec: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201dbf0: 90 12 21 58 or %o0, 0x158, %o0 ! 2034558 <CSWTCH.2+0x1078><== NOT EXECUTED
201dbf4: 40 00 10 e4 call 2021f84 <printf> <== NOT EXECUTED
201dbf8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
}
handle->flags = oflag;
201dbfc: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
handle->shared = shared;
201dc00: f8 27 60 1c st %i4, [ %i5 + 0x1c ]
*file = handle;
201dc04: fa 26 c0 00 st %i5, [ %i3 ]
return 0;
201dc08: a0 10 20 00 clr %l0
}
201dc0c: b0 10 00 10 mov %l0, %i0
201dc10: 81 c7 e0 08 ret
201dc14: 81 e8 00 00 restore
0201d4e4 <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
201d4e4: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d4e8: 90 10 20 20 mov 0x20, %o0
201d4ec: 7f ff d8 87 call 2013708 <rtems_rfs_trace>
201d4f0: 92 10 20 00 clr %o1
201d4f4: 80 8a 20 ff btst 0xff, %o0
201d4f8: 22 80 00 08 be,a 201d518 <rtems_rfs_file_seek+0x34> <== ALWAYS TAKEN
201d4fc: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
201d500: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d504: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201d508: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED
201d50c: 40 00 12 9e call 2021f84 <printf> <== NOT EXECUTED
201d510: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
* file, this function does not itself extend the size of the file."
*
* This means the file needs to set the file size to the pos only when a
* write occurs.
*/
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
201d514: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
201d518: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201d51c: 7f ff f3 b2 call 201a3e4 <rtems_rfs_block_get_size>
201d520: 92 02 60 84 add %o1, 0x84, %o1
201d524: 80 a6 40 08 cmp %i1, %o0
201d528: 18 80 00 23 bgu 201d5b4 <rtems_rfs_file_seek+0xd0> <== NEVER TAKEN
201d52c: 01 00 00 00 nop
201d530: 32 80 00 06 bne,a 201d548 <rtems_rfs_file_seek+0x64> <== NEVER TAKEN
201d534: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
201d538: 80 a6 80 09 cmp %i2, %o1
201d53c: 18 80 00 1e bgu 201d5b4 <rtems_rfs_file_seek+0xd0>
201d540: 01 00 00 00 nop
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
201d544: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
201d548: b8 06 20 10 add %i0, 0x10, %i4
201d54c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201d550: 92 10 00 19 mov %i1, %o1
201d554: 94 10 00 1a mov %i2, %o2
201d558: 7f ff f3 73 call 201a324 <rtems_rfs_block_get_bpos>
201d55c: 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))
201d560: c2 06 20 0c ld [ %i0 + 0xc ], %g1
201d564: 80 a0 60 00 cmp %g1, 0
201d568: 02 80 00 18 be 201d5c8 <rtems_rfs_file_seek+0xe4>
201d56c: 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),
201d570: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
201d574: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201d578: 96 07 bf fc add %fp, -4, %o3
201d57c: 7f ff f4 87 call 201a798 <rtems_rfs_block_map_find>
201d580: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
201d584: 80 a2 20 00 cmp %o0, 0
201d588: 14 80 00 13 bg 201d5d4 <rtems_rfs_file_seek+0xf0> <== NEVER TAKEN
201d58c: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
201d590: c4 06 20 08 ld [ %i0 + 8 ], %g2
201d594: 80 a0 80 01 cmp %g2, %g1
201d598: 02 80 00 0c be 201d5c8 <rtems_rfs_file_seek+0xe4> <== ALWAYS TAKEN
201d59c: 92 06 20 04 add %i0, 4, %o1
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201d5a0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
201d5a4: 7f ff f7 21 call 201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201d5a8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
/*
* The seek is outside the current file so release any buffer. A write will
* extend the file.
*/
int rc = rtems_rfs_file_io_release (handle);
if (rc > 0)
201d5ac: 10 80 00 05 b 201d5c0 <rtems_rfs_file_seek+0xdc> <== NOT EXECUTED
201d5b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
{
/*
* The seek is outside the current file so release any buffer. A write will
* extend the file.
*/
int rc = rtems_rfs_file_io_release (handle);
201d5b4: 7f ff ff c0 call 201d4b4 <rtems_rfs_file_io_release>
201d5b8: 90 10 00 18 mov %i0, %o0
if (rc > 0)
201d5bc: 80 a2 20 00 cmp %o0, 0
201d5c0: 14 80 00 05 bg 201d5d4 <rtems_rfs_file_seek+0xf0> <== NEVER TAKEN
201d5c4: 01 00 00 00 nop
return rc;
}
*new_pos = pos;
201d5c8: f2 26 c0 00 st %i1, [ %i3 ]
201d5cc: f4 26 e0 04 st %i2, [ %i3 + 4 ]
return 0;
201d5d0: 90 10 20 00 clr %o0
}
201d5d4: 81 c7 e0 08 ret
201d5d8: 91 e8 00 08 restore %g0, %o0, %o0
0201d5dc <rtems_rfs_file_set_size>:
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
201d5dc: 9d e3 bf 90 save %sp, -112, %sp
201d5e0: ba 10 00 1a mov %i2, %i5
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
201d5e4: f4 06 20 1c ld [ %i0 + 0x1c ], %i2
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
201d5e8: b6 10 00 18 mov %i0, %i3
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d5ec: 90 10 20 20 mov 0x20, %o0
201d5f0: 92 10 20 00 clr %o1
201d5f4: 7f ff d8 45 call 2013708 <rtems_rfs_trace>
201d5f8: b8 10 00 19 mov %i1, %i4
201d5fc: 80 8a 20 ff btst 0xff, %o0
201d600: 02 80 00 07 be 201d61c <rtems_rfs_file_set_size+0x40> <== ALWAYS TAKEN
201d604: b0 06 a0 34 add %i2, 0x34, %i0
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
201d608: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d60c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201d610: 90 12 20 78 or %o0, 0x78, %o0 <== NOT EXECUTED
201d614: 40 00 12 5c call 2021f84 <printf> <== NOT EXECUTED
201d618: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
size = rtems_rfs_file_size (handle);
201d61c: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
201d620: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201d624: 7f ff f3 70 call 201a3e4 <rtems_rfs_block_get_size>
201d628: 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)
201d62c: 80 a2 00 1c cmp %o0, %i4
201d630: 12 80 00 07 bne 201d64c <rtems_rfs_file_set_size+0x70> <== NEVER TAKEN
201d634: 80 97 00 1d orcc %i4, %i5, %g0
201d638: 80 a2 40 1d cmp %o1, %i5
201d63c: 12 80 00 04 bne 201d64c <rtems_rfs_file_set_size+0x70>
201d640: 80 97 00 1d orcc %i4, %i5, %g0
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
}
return 0;
201d644: 10 80 00 ad b 201d8f8 <rtems_rfs_file_set_size+0x31c>
201d648: 90 10 20 00 clr %o0
if (size != new_size)
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
201d64c: 12 80 00 0a bne 201d674 <rtems_rfs_file_set_size+0x98>
201d650: f2 06 e0 1c ld [ %i3 + 0x1c ], %i1
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
201d654: d0 06 60 98 ld [ %i1 + 0x98 ], %o0
201d658: 7f ff f6 90 call 201b098 <rtems_rfs_block_map_free_all>
201d65c: 92 10 00 18 mov %i0, %o1
if (rc > 0)
201d660: 80 a2 20 00 cmp %o0, 0
201d664: 14 80 00 a6 bg 201d8fc <rtems_rfs_file_set_size+0x320> <== NEVER TAKEN
201d668: b0 10 00 08 mov %o0, %i0
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
201d66c: 10 80 00 97 b 201d8c8 <rtems_rfs_file_set_size+0x2ec>
201d670: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
201d674: 80 a7 00 08 cmp %i4, %o0
201d678: 38 80 00 09 bgu,a 201d69c <rtems_rfs_file_set_size+0xc0> <== NEVER TAKEN
201d67c: c2 06 60 98 ld [ %i1 + 0x98 ], %g1 <== NOT EXECUTED
201d680: 80 a7 00 08 cmp %i4, %o0
201d684: 32 80 00 58 bne,a 201d7e4 <rtems_rfs_file_set_size+0x208><== NEVER TAKEN
201d688: e0 06 60 98 ld [ %i1 + 0x98 ], %l0 <== NOT EXECUTED
201d68c: 80 a7 40 09 cmp %i5, %o1
201d690: 28 80 00 55 bleu,a 201d7e4 <rtems_rfs_file_set_size+0x208>
201d694: e0 06 60 98 ld [ %i1 + 0x98 ], %l0
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201d698: c2 06 60 98 ld [ %i1 + 0x98 ], %g1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
201d69c: ba a7 40 09 subcc %i5, %o1, %i5
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201d6a0: f2 00 60 08 ld [ %g1 + 8 ], %i1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
201d6a4: b8 67 00 08 subx %i4, %o0, %i4
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
201d6a8: a2 10 20 00 clr %l1
201d6ac: a0 10 20 01 mov 1, %l0
while (count)
201d6b0: 10 80 00 48 b 201d7d0 <rtems_rfs_file_set_size+0x1f4>
201d6b4: a4 06 e0 04 add %i3, 4, %l2
/*
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
201d6b8: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
201d6bc: c4 27 bf f8 st %g2, [ %fp + -8 ]
201d6c0: c2 27 bf f4 st %g1, [ %fp + -12 ]
201d6c4: 80 a0 a0 00 cmp %g2, 0
201d6c8: 02 80 00 04 be 201d6d8 <rtems_rfs_file_set_size+0xfc>
201d6cc: c0 27 bf fc clr [ %fp + -4 ]
201d6d0: 82 00 7f ff add %g1, -1, %g1
201d6d4: c2 27 bf f4 st %g1, [ %fp + -12 ]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
201d6d8: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
201d6dc: 92 10 00 18 mov %i0, %o1
201d6e0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201d6e4: 94 07 bf f4 add %fp, -12, %o2
201d6e8: 7f ff f4 2c call 201a798 <rtems_rfs_block_map_find>
201d6ec: 96 07 bf f0 add %fp, -16, %o3
map, &bpos, &block);
if (rc > 0)
201d6f0: 80 a2 20 00 cmp %o0, 0
201d6f4: 14 80 00 0b bg 201d720 <rtems_rfs_file_set_size+0x144>
201d6f8: 80 a2 20 06 cmp %o0, 6
map, 1, &block);
if (rc > 0)
return rc;
}
if (count < (length - bpos.boff))
201d6fc: c2 07 bf f8 ld [ %fp + -8 ], %g1
201d700: 80 a7 20 00 cmp %i4, 0
201d704: 12 80 00 17 bne 201d760 <rtems_rfs_file_set_size+0x184> <== NEVER TAKEN
201d708: 84 26 40 01 sub %i1, %g1, %g2
201d70c: 80 a0 80 1d cmp %g2, %i5
201d710: 38 80 00 10 bgu,a 201d750 <rtems_rfs_file_set_size+0x174>
201d714: b2 00 40 1d add %g1, %i5, %i1
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
201d718: 10 80 00 13 b 201d764 <rtems_rfs_file_set_size+0x188>
201d71c: c0 26 a0 40 clr [ %i2 + 0x40 ]
if (rc > 0)
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
201d720: 12 80 00 76 bne 201d8f8 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
201d724: 92 10 00 18 mov %i0, %o1
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
201d728: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
201d72c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201d730: 94 10 20 01 mov 1, %o2
201d734: 7f ff f4 9f call 201a9b0 <rtems_rfs_block_map_grow>
201d738: 96 07 bf f0 add %fp, -16, %o3
map, 1, &block);
if (rc > 0)
201d73c: 80 a2 20 00 cmp %o0, 0
201d740: 04 bf ff f0 ble 201d700 <rtems_rfs_file_set_size+0x124> <== ALWAYS TAKEN
201d744: c2 07 bf f8 ld [ %fp + -8 ], %g1
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
}
return 0;
}
201d748: 81 c7 e0 08 ret <== NOT EXECUTED
201d74c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
map->dirty = true;
201d750: e0 2e a0 34 stb %l0, [ %i2 + 0x34 ]
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
201d754: f2 26 a0 40 st %i1, [ %i2 + 0x40 ]
}
if (count < (length - bpos.boff))
{
length = count + bpos.boff;
read_block = true;
201d758: 10 80 00 04 b 201d768 <rtems_rfs_file_set_size+0x18c>
201d75c: a2 10 20 01 mov 1, %l1
201d760: c0 26 a0 40 clr [ %i2 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
201d764: e0 2e a0 34 stb %l0, [ %i2 + 0x34 ]
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
201d768: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
201d76c: d4 07 bf f0 ld [ %fp + -16 ], %o2
201d770: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201d774: 92 10 00 12 mov %l2, %o1
201d778: 7f ff f7 20 call 201b3f8 <rtems_rfs_buffer_handle_request>
201d77c: 96 0c 60 01 and %l1, 1, %o3
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
201d780: 80 a2 20 00 cmp %o0, 0
201d784: 14 80 00 5d bg 201d8f8 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
201d788: d4 07 bf f8 ld [ %fp + -8 ], %o2
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
201d78c: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
memset (dst + bpos.boff, 0, length - bpos.boff);
201d790: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
201d794: 92 10 20 00 clr %o1
201d798: 90 02 00 0a add %o0, %o2, %o0
201d79c: 40 00 11 7c call 2021d8c <memset>
201d7a0: 94 26 40 0a sub %i1, %o2, %o2
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201d7a4: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
memset (dst + bpos.boff, 0, length - bpos.boff);
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
201d7a8: e0 2e e0 04 stb %l0, [ %i3 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201d7ac: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201d7b0: 7f ff f6 9e call 201b228 <rtems_rfs_buffer_handle_release>
201d7b4: 92 10 00 12 mov %l2, %o1
rtems_rfs_file_buffer (handle));
if (rc > 0)
201d7b8: 80 a2 20 00 cmp %o0, 0
201d7bc: 14 80 00 4f bg 201d8f8 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
201d7c0: c2 07 bf f8 ld [ %fp + -8 ], %g1
return rc;
count -= length - bpos.boff;
201d7c4: 82 26 40 01 sub %i1, %g1, %g1
201d7c8: ba a7 40 01 subcc %i5, %g1, %i5
201d7cc: 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)
201d7d0: 80 97 00 1d orcc %i4, %i5, %g0
201d7d4: 32 bf ff b9 bne,a 201d6b8 <rtems_rfs_file_set_size+0xdc>
201d7d8: c4 06 a0 40 ld [ %i2 + 0x40 ], %g2
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
201d7dc: 10 80 00 3b b 201d8c8 <rtems_rfs_file_set_size+0x2ec>
201d7e0: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
201d7e4: 92 87 7f ff addcc %i5, -1, %o1
201d7e8: e2 04 20 08 ld [ %l0 + 8 ], %l1
201d7ec: 90 47 3f ff addx %i4, -1, %o0
201d7f0: 94 10 20 00 clr %o2
201d7f4: 40 00 45 34 call 202ecc4 <__udivdi3>
201d7f8: 96 10 00 11 mov %l1, %o3
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
201d7fc: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
201d800: 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));
201d804: 90 10 00 1c mov %i4, %o0
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
201d808: b0 02 40 01 add %o1, %g1, %i0
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201d80c: 94 10 20 00 clr %o2
201d810: 92 10 00 1d mov %i5, %o1
201d814: 40 00 46 00 call 202f014 <__umoddi3>
201d818: 96 10 00 11 mov %l1, %o3
if (blocks)
201d81c: 80 a6 20 00 cmp %i0, 0
201d820: 12 80 00 0b bne 201d84c <rtems_rfs_file_set_size+0x270>
201d824: 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),
201d828: c4 06 e0 10 ld [ %i3 + 0x10 ], %g2
201d82c: 82 10 20 01 mov 1, %g1
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
201d830: fa 26 a0 40 st %i5, [ %i2 + 0x40 ]
map->dirty = true;
201d834: c2 2e a0 34 stb %g1, [ %i2 + 0x34 ]
201d838: 80 a0 a0 00 cmp %g2, 0
201d83c: 12 80 00 0d bne 201d870 <rtems_rfs_file_set_size+0x294>
201d840: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
201d844: 10 80 00 0f b 201d880 <rtems_rfs_file_set_size+0x2a4>
201d848: 80 a0 80 01 cmp %g2, %g1
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
201d84c: 90 10 00 10 mov %l0, %o0
201d850: 92 06 60 34 add %i1, 0x34, %o1
201d854: 7f ff f5 47 call 201ad70 <rtems_rfs_block_map_shrink>
201d858: 94 10 00 18 mov %i0, %o2
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
201d85c: 80 a2 20 00 cmp %o0, 0
201d860: 34 80 00 27 bg,a 201d8fc <rtems_rfs_file_set_size+0x320> <== NEVER TAKEN
201d864: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
201d868: 10 bf ff f1 b 201d82c <rtems_rfs_file_set_size+0x250>
201d86c: c4 06 e0 10 ld [ %i3 + 0x10 ], %g2
201d870: 80 a0 60 00 cmp %g1, 0
201d874: 22 80 00 0e be,a 201d8ac <rtems_rfs_file_set_size+0x2d0> <== NEVER TAKEN
201d878: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
201d87c: 80 a0 80 01 cmp %g2, %g1
201d880: 3a 80 00 0b bcc,a 201d8ac <rtems_rfs_file_set_size+0x2d0><== NEVER TAKEN
201d884: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
201d888: 86 00 7f ff add %g1, -1, %g3
201d88c: 80 a0 80 03 cmp %g2, %g3
201d890: 32 80 00 0e bne,a 201d8c8 <rtems_rfs_file_set_size+0x2ec><== NEVER TAKEN
201d894: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5 <== NOT EXECUTED
201d898: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
201d89c: 80 a0 80 1d cmp %g2, %i5
201d8a0: 28 80 00 0a bleu,a 201d8c8 <rtems_rfs_file_set_size+0x2ec>
201d8a4: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
201d8a8: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
201d8ac: fa 26 e0 14 st %i5, [ %i3 + 0x14 ]
201d8b0: 80 a7 60 00 cmp %i5, 0
201d8b4: 02 80 00 04 be 201d8c4 <rtems_rfs_file_set_size+0x2e8> <== NEVER TAKEN
201d8b8: c0 26 e0 18 clr [ %i3 + 0x18 ]
201d8bc: 82 00 7f ff add %g1, -1, %g1
201d8c0: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
201d8c4: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
201d8c8: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
201d8cc: c2 27 60 84 st %g1, [ %i5 + 0x84 ]
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
201d8d0: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1
201d8d4: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
if (rtems_rfs_file_update_mtime (handle))
201d8d8: c2 06 c0 00 ld [ %i3 ], %g1
201d8dc: 80 88 60 02 btst 2, %g1
201d8e0: 12 80 00 06 bne 201d8f8 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
201d8e4: 90 10 20 00 clr %o0
handle->shared->mtime = time (NULL);
201d8e8: 40 00 21 c3 call 2025ff4 <time>
201d8ec: 90 10 20 00 clr %o0
201d8f0: d0 27 60 90 st %o0, [ %i5 + 0x90 ]
}
return 0;
201d8f4: 90 10 20 00 clr %o0
}
201d8f8: b0 10 00 08 mov %o0, %i0
201d8fc: 81 c7 e0 08 ret
201d900: 81 e8 00 00 restore
020107f0 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
20107f0: 9d e3 be c0 save %sp, -320, %sp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
20107f4: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
20107f8: 80 a0 60 00 cmp %g1, 0
20107fc: 22 80 00 07 be,a 2010818 <rtems_rfs_format+0x28> <== ALWAYS TAKEN
2010800: 92 10 20 00 clr %o1
printf ("rtems-rfs: format: %s\n", name);
2010804: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010808: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201080c: 40 00 45 de call 2021f84 <printf> <== NOT EXECUTED
2010810: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
2010814: 92 10 20 00 clr %o1 <== NOT EXECUTED
2010818: 94 10 20 84 mov 0x84, %o2
201081c: 40 00 45 5c call 2021d8c <memset>
2010820: 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;
2010824: 82 07 bf c4 add %fp, -60, %g1
2010828: c2 27 bf c0 st %g1, [ %fp + -64 ]
head->previous = NULL;
tail->previous = head;
201082c: 82 07 bf c0 add %fp, -64, %g1
2010830: 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;
2010834: 82 07 bf d4 add %fp, -44, %g1
2010838: c2 27 bf d0 st %g1, [ %fp + -48 ]
head->previous = NULL;
tail->previous = head;
201083c: 82 07 bf d0 add %fp, -48, %g1
2010840: 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;
2010844: 82 07 bf e4 add %fp, -28, %g1
2010848: c2 27 bf e0 st %g1, [ %fp + -32 ]
head->previous = NULL;
tail->previous = head;
201084c: 82 07 bf e0 add %fp, -32, %g1
2010850: 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;
2010854: 82 07 bf f4 add %fp, -12, %g1
2010858: c2 27 bf f0 st %g1, [ %fp + -16 ]
head->previous = NULL;
tail->previous = head;
201085c: 82 07 bf f0 add %fp, -16, %g1
2010860: 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;
2010864: 82 10 20 05 mov 5, %g1
2010868: 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;
201086c: 82 10 20 02 mov 2, %g1
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
2010870: 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;
2010874: c2 27 bf 7c st %g1, [ %fp + -132 ]
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
2010878: 40 00 2b 86 call 201b690 <rtems_rfs_buffer_open>
201087c: 92 07 bf 7c add %fp, -132, %o1
if (rc > 0)
2010880: ba 92 20 00 orcc %o0, 0, %i5
2010884: 04 80 00 08 ble 20108a4 <rtems_rfs_format+0xb4> <== ALWAYS TAKEN
2010888: c2 07 bf 8c ld [ %fp + -116 ], %g1
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
201088c: 40 00 4a 2a call 2023134 <strerror> <== NOT EXECUTED
2010890: 01 00 00 00 nop <== NOT EXECUTED
2010894: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2010898: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
201089c: 10 80 03 0e b 20114d4 <rtems_rfs_format+0xce4> <== NOT EXECUTED
20108a0: 90 12 20 60 or %o0, 0x60, %o0 ! 2032060 <_CPU_Trap_slot_template+0x28><== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
20108a4: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
20108a8: 80 a0 60 00 cmp %g1, 0
20108ac: 32 80 00 08 bne,a 20108cc <rtems_rfs_format+0xdc> <== ALWAYS TAKEN
20108b0: c2 06 40 00 ld [ %i1 ], %g1
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
20108b4: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
20108b8: 92 10 20 00 clr %o1 <== NOT EXECUTED
20108bc: 40 00 45 b2 call 2021f84 <printf> <== NOT EXECUTED
20108c0: 90 12 20 90 or %o0, 0x90, %o0 <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
20108c4: 81 c7 e0 08 ret <== NOT EXECUTED
20108c8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
if (!fs->block_size)
20108cc: 80 a0 60 00 cmp %g1, 0
20108d0: 12 80 00 2a bne 2010978 <rtems_rfs_format+0x188>
20108d4: c2 27 bf 84 st %g1, [ %fp + -124 ]
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
20108d8: 40 00 34 e3 call 201dc64 <rtems_rfs_fs_media_size>
20108dc: 90 07 bf 7c add %fp, -132, %o0
if (total_size >= GIGS (1))
20108e0: 80 a2 20 00 cmp %o0, 0
20108e4: 12 80 00 08 bne 2010904 <rtems_rfs_format+0x114> <== NEVER TAKEN
20108e8: 37 00 04 00 sethi %hi(0x100000), %i3
20108ec: 03 00 03 ff sethi %hi(0xffc00), %g1
20108f0: 82 10 63 ff or %g1, 0x3ff, %g1 ! fffff <PROM_START+0xfffff>
20108f4: 80 a2 40 01 cmp %o1, %g1
20108f8: 08 80 00 16 bleu 2010950 <rtems_rfs_format+0x160> <== ALWAYS TAKEN
20108fc: c2 07 bf 84 ld [ %fp + -124 ], %g1
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
2010900: 37 00 04 00 sethi %hi(0x100000), %i3 <== NOT EXECUTED
2010904: ba 82 40 1b addcc %o1, %i3, %i5 <== NOT EXECUTED
2010908: 83 37 60 14 srl %i5, 0x14, %g1 <== NOT EXECUTED
201090c: b4 10 20 00 clr %i2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
2010910: 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);
2010914: b8 42 00 1a addx %o0, %i2, %i4 <== NOT EXECUTED
2010918: 85 2f 20 0c sll %i4, 0xc, %g2 <== NOT EXECUTED
201091c: 84 10 80 01 or %g2, %g1, %g2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
2010920: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
2010924: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
2010928: 80 89 00 02 btst %g4, %g2 <== NOT EXECUTED
201092c: 32 80 00 06 bne,a 2010944 <rtems_rfs_format+0x154> <== NOT EXECUTED
2010930: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
2010934: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
2010938: 12 bf ff fc bne 2010928 <rtems_rfs_format+0x138> <== NOT EXECUTED
201093c: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
2010940: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
2010944: 83 28 80 01 sll %g2, %g1, %g1 <== NOT EXECUTED
2010948: c2 27 bf 84 st %g1, [ %fp + -124 ] <== NOT EXECUTED
}
if (fs->block_size < 512)
201094c: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
2010950: 80 a0 61 ff cmp %g1, 0x1ff
2010954: 18 80 00 05 bgu 2010968 <rtems_rfs_format+0x178> <== NEVER TAKEN
2010958: c4 07 bf 84 ld [ %fp + -124 ], %g2
fs->block_size = 512;
201095c: 82 10 22 00 mov 0x200, %g1
2010960: c2 27 bf 84 st %g1, [ %fp + -124 ]
if (fs->block_size > (4 * 1024))
2010964: c4 07 bf 84 ld [ %fp + -124 ], %g2
2010968: 03 00 00 04 sethi %hi(0x1000), %g1
201096c: 80 a0 80 01 cmp %g2, %g1
2010970: 38 80 00 02 bgu,a 2010978 <rtems_rfs_format+0x188> <== NEVER TAKEN
2010974: c2 27 bf 84 st %g1, [ %fp + -124 ] <== NOT EXECUTED
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
2010978: c2 07 bf 8c ld [ %fp + -116 ], %g1
201097c: fa 07 bf 84 ld [ %fp + -124 ], %i5
2010980: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
2010984: 90 10 00 1d mov %i5, %o0
2010988: 40 00 76 00 call 202e188 <.urem>
201098c: 92 10 00 1c mov %i4, %o1
2010990: 80 a2 20 00 cmp %o0, 0
2010994: 22 80 00 07 be,a 20109b0 <rtems_rfs_format+0x1c0> <== ALWAYS TAKEN
2010998: c2 06 60 04 ld [ %i1 + 4 ], %g1
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
201099c: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
20109a0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20109a4: 90 12 20 b8 or %o0, 0xb8, %o0 <== NOT EXECUTED
20109a8: 10 80 02 cc b 20114d8 <rtems_rfs_format+0xce8> <== NOT EXECUTED
20109ac: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
if (!fs->group_blocks)
20109b0: 80 a0 60 00 cmp %g1, 0
20109b4: 02 80 00 04 be 20109c4 <rtems_rfs_format+0x1d4> <== ALWAYS TAKEN
20109b8: bb 2f 60 03 sll %i5, 3, %i5
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
20109bc: 10 80 00 03 b 20109c8 <rtems_rfs_format+0x1d8> <== NOT EXECUTED
20109c0: c2 27 bf a4 st %g1, [ %fp + -92 ] <== NOT EXECUTED
{
/*
* The number of blocks per group is defined by the number of bits in a
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
20109c4: fa 27 bf a4 st %i5, [ %fp + -92 ]
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
20109c8: c2 07 bf a4 ld [ %fp + -92 ], %g1
20109cc: 80 a0 40 1d cmp %g1, %i5
20109d0: 08 80 00 04 bleu 20109e0 <rtems_rfs_format+0x1f0> <== ALWAYS TAKEN
20109d4: 11 00 80 c8 sethi %hi(0x2032000), %o0
{
printf ("group block count is higher than bits in block\n");
20109d8: 10 80 01 2f b 2010e94 <rtems_rfs_format+0x6a4> <== NOT EXECUTED
20109dc: 90 12 20 f8 or %o0, 0xf8, %o0 ! 20320f8 <_CPU_Trap_slot_template+0xc0><== NOT EXECUTED
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
20109e0: 40 00 34 a1 call 201dc64 <rtems_rfs_fs_media_size>
20109e4: 90 07 bf 7c add %fp, -132, %o0
20109e8: fa 07 bf 84 ld [ %fp + -124 ], %i5
20109ec: 94 10 20 00 clr %o2
20109f0: 40 00 78 b5 call 202ecc4 <__udivdi3>
20109f4: 96 10 00 1d mov %i5, %o3
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
20109f8: b9 2f 60 03 sll %i5, 3, %i4
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
20109fc: d2 27 bf 80 st %o1, [ %fp + -128 ]
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
2010a00: 90 10 00 09 mov %o1, %o0
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
2010a04: b6 10 00 09 mov %o1, %i3
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
2010a08: 7f ff ff 6f call 20107c4 <rtems_rfs_rup_quotient>
2010a0c: 92 10 00 1c mov %i4, %o1
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
2010a10: c2 06 60 08 ld [ %i1 + 8 ], %g1
/*
* The bits per block sets the upper limit for the number of blocks in a
* group. The disk will be divided into groups which are the number of bits
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
2010a14: d0 27 bf a0 st %o0, [ %fp + -96 ]
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
2010a18: c2 27 bf a8 st %g1, [ %fp + -88 ]
if (!fs->group_inodes)
2010a1c: 80 a0 60 00 cmp %g1, 0
2010a20: 12 80 00 14 bne 2010a70 <rtems_rfs_format+0x280> <== NEVER TAKEN
2010a24: b4 10 00 08 mov %o0, %i2
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
/*
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
2010a28: d0 06 60 0c ld [ %i1 + 0xc ], %o0
2010a2c: 80 a2 20 00 cmp %o0, 0
2010a30: 22 80 00 02 be,a 2010a38 <rtems_rfs_format+0x248> <== ALWAYS TAKEN
2010a34: 90 10 20 01 mov 1, %o0
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
2010a38: 7f ff c6 d7 call 2002594 <.umul>
2010a3c: 92 06 ff ff add %i3, -1, %o1
2010a40: 7f ff c7 0f call 200267c <.udiv>
2010a44: 92 10 20 64 mov 0x64, %o1
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
2010a48: 7f ff ff 5f call 20107c4 <rtems_rfs_rup_quotient>
2010a4c: 92 10 00 1a mov %i2, %o1
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
2010a50: 92 10 20 38 mov 0x38, %o1
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
2010a54: b6 10 00 08 mov %o0, %i3
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
2010a58: 7f ff c7 09 call 200267c <.udiv>
2010a5c: 90 10 00 1d mov %i5, %o0
2010a60: 92 10 00 08 mov %o0, %o1
2010a64: 7f ff c6 cc call 2002594 <.umul>
2010a68: 90 10 00 1b mov %i3, %o0
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
inode_overhead = config->inode_overhead;
fs->group_inodes = rtems_rfs_inodes_from_percent (fs, inode_overhead);
2010a6c: d0 27 bf a8 st %o0, [ %fp + -88 ]
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
2010a70: 90 10 00 1d mov %i5, %o0
2010a74: 7f ff c7 02 call 200267c <.udiv>
2010a78: 92 10 20 38 mov 0x38, %o1
2010a7c: ba 10 00 08 mov %o0, %i5
2010a80: d0 27 bf ac st %o0, [ %fp + -84 ]
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
2010a84: d0 07 bf a8 ld [ %fp + -88 ], %o0
2010a88: 7f ff ff 4f call 20107c4 <rtems_rfs_rup_quotient>
2010a8c: 92 10 00 1d mov %i5, %o1
fs->inodes_per_block) * fs->inodes_per_block;
2010a90: 7f ff c6 c1 call 2002594 <.umul>
2010a94: 92 10 00 1d mov %i5, %o1
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
2010a98: 80 a2 00 1c cmp %o0, %i4
2010a9c: 38 80 00 03 bgu,a 2010aa8 <rtems_rfs_format+0x2b8> <== NEVER TAKEN
2010aa0: f8 27 bf a8 st %i4, [ %fp + -88 ] <== NOT EXECUTED
2010aa4: d0 27 bf a8 st %o0, [ %fp + -88 ]
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
2010aa8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
if (!fs->max_name_length)
2010aac: 80 a0 60 00 cmp %g1, 0
2010ab0: 22 80 02 90 be,a 20114f0 <rtems_rfs_format+0xd00> <== ALWAYS TAKEN
2010ab4: 82 10 22 00 mov 0x200, %g1
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
2010ab8: 10 80 02 8f b 20114f4 <rtems_rfs_format+0xd04> <== NOT EXECUTED
2010abc: c2 27 bf 98 st %g1, [ %fp + -104 ] <== NOT EXECUTED
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
2010ac0: 40 00 34 69 call 201dc64 <rtems_rfs_fs_media_size> <== NOT EXECUTED
2010ac4: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
2010ac8: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
2010acc: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
2010ad0: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010ad4: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
2010ad8: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
2010adc: 40 00 45 2a call 2021f84 <printf> <== NOT EXECUTED
2010ae0: 90 12 21 28 or %o0, 0x128, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
2010ae4: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
2010ae8: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010aec: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
2010af0: 40 00 45 25 call 2021f84 <printf> <== NOT EXECUTED
2010af4: 90 12 21 50 or %o0, 0x150, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
2010af8: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
2010afc: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010b00: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 <== NOT EXECUTED
2010b04: 40 00 45 20 call 2021f84 <printf> <== NOT EXECUTED
2010b08: 90 12 21 78 or %o0, 0x178, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
2010b0c: 40 00 34 4d call 201dc40 <rtems_rfs_fs_size> <== NOT EXECUTED
2010b10: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
2010b14: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
2010b18: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
2010b1c: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010b20: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
2010b24: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
2010b28: 40 00 45 17 call 2021f84 <printf> <== NOT EXECUTED
2010b2c: 90 12 21 a8 or %o0, 0x1a8, %o0 <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
2010b30: d2 07 bf 80 ld [ %fp + -128 ], %o1 <== NOT EXECUTED
2010b34: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010b38: 40 00 45 13 call 2021f84 <printf> <== NOT EXECUTED
2010b3c: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 20321c8 <_CPU_Trap_slot_template+0x190><== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
2010b40: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
2010b44: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010b48: 40 00 45 0f call 2021f84 <printf> <== NOT EXECUTED
2010b4c: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 20321f0 <_CPU_Trap_slot_template+0x1b8><== NOT EXECUTED
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
2010b50: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
2010b54: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010b58: 93 2a 60 03 sll %o1, 3, %o1 <== NOT EXECUTED
2010b5c: 40 00 45 0a call 2021f84 <printf> <== NOT EXECUTED
2010b60: 90 12 22 18 or %o0, 0x218, %o0 <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
2010b64: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
2010b68: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010b6c: 40 00 45 06 call 2021f84 <printf> <== NOT EXECUTED
2010b70: 90 12 22 40 or %o0, 0x240, %o0 ! 2032240 <_CPU_Trap_slot_template+0x208><== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
2010b74: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
2010b78: 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",
2010b7c: 7f ff c6 86 call 2002594 <.umul> <== NOT EXECUTED
2010b80: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
rtems_rfs_fs_block_size (fs));
2010b84: f8 07 bf 84 ld [ %fp + -124 ], %i4 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
2010b88: 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,
2010b8c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2010b90: 91 2f 60 03 sll %i5, 3, %o0 <== NOT EXECUTED
2010b94: bb 2f 60 06 sll %i5, 6, %i5 <== NOT EXECUTED
2010b98: 7f ff ff 0b call 20107c4 <rtems_rfs_rup_quotient> <== NOT EXECUTED
2010b9c: 90 27 40 08 sub %i5, %o0, %o0 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
2010ba0: 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));
2010ba4: 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))
2010ba8: 92 00 7f ff add %g1, -1, %o1 <== NOT EXECUTED
2010bac: 80 a7 00 09 cmp %i4, %o1 <== NOT EXECUTED
2010bb0: 28 80 00 02 bleu,a 2010bb8 <rtems_rfs_format+0x3c8> <== NOT EXECUTED
2010bb4: 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;
2010bb8: 84 02 20 01 add %o0, 1, %g2 <== NOT EXECUTED
2010bbc: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED
2010bc0: 89 28 a0 07 sll %g2, 7, %g4 <== NOT EXECUTED
2010bc4: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
2010bc8: 90 00 c0 02 add %g3, %g2, %o0 <== NOT EXECUTED
2010bcc: 7f ff c6 ae call 2002684 <.div> <== NOT EXECUTED
2010bd0: 91 2a 20 03 sll %o0, 3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
2010bd4: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
2010bd8: 7f ff c6 ab call 2002684 <.div> <== NOT EXECUTED
2010bdc: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
2010be0: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
2010be4: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
2010be8: 40 00 75 6a call 202e190 <.rem> <== NOT EXECUTED
2010bec: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2010bf0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2010bf4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2010bf8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2010bfc: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010c00: 40 00 44 e1 call 2021f84 <printf> <== NOT EXECUTED
2010c04: 90 12 22 68 or %o0, 0x268, %o0 ! 2032268 <_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);
2010c08: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
2010c0c: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010c10: 40 00 44 dd call 2021f84 <printf> <== NOT EXECUTED
2010c14: 90 12 22 98 or %o0, 0x298, %o0 ! 2032298 <_CPU_Trap_slot_template+0x260><== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
2010c18: d2 07 bf a4 ld [ %fp + -92 ], %o1 <== NOT EXECUTED
2010c1c: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010c20: 40 00 44 d9 call 2021f84 <printf> <== NOT EXECUTED
2010c24: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 20322b8 <_CPU_Trap_slot_template+0x280><== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
2010c28: d2 07 bf a8 ld [ %fp + -88 ], %o1 <== NOT EXECUTED
2010c2c: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010c30: 40 00 44 d5 call 2021f84 <printf> <== NOT EXECUTED
2010c34: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 20322e0 <_CPU_Trap_slot_template+0x2a8><== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
2010c38: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
2010c3c: 40 00 2b 35 call 201b910 <rtems_rfs_buffer_setblksize>
2010c40: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
2010c44: ba 92 20 00 orcc %o0, 0, %i5
2010c48: 24 80 00 08 ble,a 2010c68 <rtems_rfs_format+0x478> <== ALWAYS TAKEN
2010c4c: c0 2f bf 30 clrb [ %fp + -208 ]
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
2010c50: 40 00 49 39 call 2023134 <strerror> <== NOT EXECUTED
2010c54: 01 00 00 00 nop <== NOT EXECUTED
2010c58: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2010c5c: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010c60: 10 80 02 1d b 20114d4 <rtems_rfs_format+0xce4> <== NOT EXECUTED
2010c64: 90 12 23 08 or %o0, 0x308, %o0 ! 2032308 <_CPU_Trap_slot_template+0x2d0><== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
2010c68: c0 27 bf 34 clr [ %fp + -204 ]
handle->buffer = NULL;
2010c6c: 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);
2010c70: 90 07 bf 7c add %fp, -132, %o0
2010c74: 92 07 bf 30 add %fp, -208, %o1
2010c78: 94 10 20 00 clr %o2
2010c7c: 40 00 29 df call 201b3f8 <rtems_rfs_buffer_handle_request>
2010c80: 96 10 20 00 clr %o3
if (rc > 0)
2010c84: ba 92 20 00 orcc %o0, 0, %i5
2010c88: 04 80 00 0a ble 2010cb0 <rtems_rfs_format+0x4c0> <== ALWAYS TAKEN
2010c8c: 92 07 bf 30 add %fp, -208, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
2010c90: 7f ff fe c3 call 201079c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2010c94: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
2010c98: 40 00 49 27 call 2023134 <strerror> <== NOT EXECUTED
2010c9c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2010ca0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2010ca4: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010ca8: 10 80 00 73 b 2010e74 <rtems_rfs_format+0x684> <== NOT EXECUTED
2010cac: 90 12 23 40 or %o0, 0x340, %o0 ! 2032340 <_CPU_Trap_slot_template+0x308><== NOT EXECUTED
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
2010cb0: 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));
2010cb4: 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);
2010cb8: 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));
2010cbc: 92 10 20 ff mov 0xff, %o1
2010cc0: 40 00 44 33 call 2021d8c <memset>
2010cc4: 90 10 00 1d mov %i5, %o0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
2010cc8: 82 10 20 28 mov 0x28, %g1
2010ccc: c2 2f 40 00 stb %g1, [ %i5 ]
2010cd0: 82 10 20 09 mov 9, %g1
2010cd4: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
2010cd8: 82 10 20 20 mov 0x20, %g1
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
2010cdc: 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);
2010ce0: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
2010ce4: c0 2f 60 05 clrb [ %i5 + 5 ]
2010ce8: c0 2f 60 06 clrb [ %i5 + 6 ]
2010cec: 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);
2010cf0: 84 10 20 01 mov 1, %g2
2010cf4: c4 2f 60 03 stb %g2, [ %i5 + 3 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
2010cf8: c2 07 bf 80 ld [ %fp + -128 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
2010cfc: 92 07 bf 30 add %fp, -208, %o1
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
2010d00: 87 30 60 18 srl %g1, 0x18, %g3
2010d04: c6 2f 60 0c stb %g3, [ %i5 + 0xc ]
2010d08: 87 30 60 10 srl %g1, 0x10, %g3
2010d0c: c2 2f 60 0f stb %g1, [ %i5 + 0xf ]
2010d10: c6 2f 60 0d stb %g3, [ %i5 + 0xd ]
2010d14: 87 30 60 08 srl %g1, 8, %g3
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
2010d18: c2 0f bf 84 ldub [ %fp + -124 ], %g1
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
2010d1c: c6 2f 60 0e stb %g3, [ %i5 + 0xe ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
2010d20: c2 2f 60 08 stb %g1, [ %i5 + 8 ]
2010d24: c2 17 bf 84 lduh [ %fp + -124 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
2010d28: 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));
2010d2c: c2 2f 60 09 stb %g1, [ %i5 + 9 ]
2010d30: c2 07 bf 84 ld [ %fp + -124 ], %g1
2010d34: 83 30 60 08 srl %g1, 8, %g1
2010d38: c2 2f 60 0a stb %g1, [ %i5 + 0xa ]
2010d3c: c2 07 bf 84 ld [ %fp + -124 ], %g1
2010d40: c2 2f 60 0b stb %g1, [ %i5 + 0xb ]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
2010d44: c2 0f bf 94 ldub [ %fp + -108 ], %g1
2010d48: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
2010d4c: c2 17 bf 94 lduh [ %fp + -108 ], %g1
2010d50: c2 2f 60 11 stb %g1, [ %i5 + 0x11 ]
2010d54: c2 07 bf 94 ld [ %fp + -108 ], %g1
2010d58: 83 30 60 08 srl %g1, 8, %g1
2010d5c: c2 2f 60 12 stb %g1, [ %i5 + 0x12 ]
2010d60: c2 07 bf 94 ld [ %fp + -108 ], %g1
2010d64: c2 2f 60 13 stb %g1, [ %i5 + 0x13 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
2010d68: c2 0f bf 98 ldub [ %fp + -104 ], %g1
2010d6c: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
2010d70: c2 17 bf 98 lduh [ %fp + -104 ], %g1
2010d74: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
2010d78: c2 07 bf 98 ld [ %fp + -104 ], %g1
2010d7c: 83 30 60 08 srl %g1, 8, %g1
2010d80: c2 2f 60 16 stb %g1, [ %i5 + 0x16 ]
2010d84: c2 07 bf 98 ld [ %fp + -104 ], %g1
2010d88: c2 2f 60 17 stb %g1, [ %i5 + 0x17 ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
2010d8c: c2 0f bf a0 ldub [ %fp + -96 ], %g1
2010d90: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ]
2010d94: c2 17 bf a0 lduh [ %fp + -96 ], %g1
2010d98: c2 2f 60 19 stb %g1, [ %i5 + 0x19 ]
2010d9c: c2 07 bf a0 ld [ %fp + -96 ], %g1
2010da0: 83 30 60 08 srl %g1, 8, %g1
2010da4: c2 2f 60 1a stb %g1, [ %i5 + 0x1a ]
2010da8: c2 07 bf a0 ld [ %fp + -96 ], %g1
2010dac: c2 2f 60 1b stb %g1, [ %i5 + 0x1b ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
2010db0: c2 0f bf a4 ldub [ %fp + -92 ], %g1
2010db4: c2 2f 60 1c stb %g1, [ %i5 + 0x1c ]
2010db8: c2 17 bf a4 lduh [ %fp + -92 ], %g1
2010dbc: c2 2f 60 1d stb %g1, [ %i5 + 0x1d ]
2010dc0: c2 07 bf a4 ld [ %fp + -92 ], %g1
2010dc4: 83 30 60 08 srl %g1, 8, %g1
2010dc8: c2 2f 60 1e stb %g1, [ %i5 + 0x1e ]
2010dcc: c2 07 bf a4 ld [ %fp + -92 ], %g1
2010dd0: c2 2f 60 1f stb %g1, [ %i5 + 0x1f ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
2010dd4: c2 0f bf a8 ldub [ %fp + -88 ], %g1
2010dd8: c2 2f 60 20 stb %g1, [ %i5 + 0x20 ]
2010ddc: c2 17 bf a8 lduh [ %fp + -88 ], %g1
2010de0: c2 2f 60 21 stb %g1, [ %i5 + 0x21 ]
2010de4: c2 07 bf a8 ld [ %fp + -88 ], %g1
2010de8: 83 30 60 08 srl %g1, 8, %g1
2010dec: c2 2f 60 22 stb %g1, [ %i5 + 0x22 ]
2010df0: c2 07 bf a8 ld [ %fp + -88 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
2010df4: 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);
2010df8: c2 2f 60 23 stb %g1, [ %i5 + 0x23 ]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
2010dfc: c0 2f 60 25 clrb [ %i5 + 0x25 ]
2010e00: c0 2f 60 26 clrb [ %i5 + 0x26 ]
2010e04: 82 10 20 38 mov 0x38, %g1
2010e08: c2 2f 60 27 stb %g1, [ %i5 + 0x27 ]
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
2010e0c: 40 00 29 07 call 201b228 <rtems_rfs_buffer_handle_release>
2010e10: c4 2f bf 30 stb %g2, [ %fp + -208 ]
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
2010e14: 92 07 bf 30 add %fp, -208, %o1
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
2010e18: ba 10 00 08 mov %o0, %i5
if (rc > 0)
2010e1c: 80 a7 60 00 cmp %i5, 0
2010e20: 04 80 00 0a ble 2010e48 <rtems_rfs_format+0x658> <== ALWAYS TAKEN
2010e24: 90 07 bf 7c add %fp, -132, %o0
{
rtems_rfs_buffer_handle_close (fs, &handle);
2010e28: 7f ff fe 5d call 201079c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2010e2c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
2010e30: 40 00 48 c1 call 2023134 <strerror> <== NOT EXECUTED
2010e34: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2010e38: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2010e3c: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010e40: 10 80 00 0d b 2010e74 <rtems_rfs_format+0x684> <== NOT EXECUTED
2010e44: 90 12 23 78 or %o0, 0x378, %o0 ! 2032378 <_CPU_Trap_slot_template+0x340><== NOT EXECUTED
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
2010e48: 7f ff fe 55 call 201079c <rtems_rfs_buffer_handle_close>
2010e4c: 01 00 00 00 nop
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
}
return true;
2010e50: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1>
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
2010e54: 80 a2 20 00 cmp %o0, 0
2010e58: 04 80 00 0a ble 2010e80 <rtems_rfs_format+0x690> <== ALWAYS TAKEN
2010e5c: ba 10 00 08 mov %o0, %i5
{
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
2010e60: 40 00 48 b5 call 2023134 <strerror> <== NOT EXECUTED
2010e64: 01 00 00 00 nop <== NOT EXECUTED
2010e68: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2010e6c: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010e70: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 20323b8 <_CPU_Trap_slot_template+0x380><== NOT EXECUTED
2010e74: 40 00 44 44 call 2021f84 <printf> <== NOT EXECUTED
2010e78: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
return false;
2010e7c: 82 10 20 00 clr %g1 <== NOT EXECUTED
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
2010e80: 80 88 60 ff btst 0xff, %g1
2010e84: 12 80 00 f3 bne 2011250 <rtems_rfs_format+0xa60> <== ALWAYS TAKEN
2010e88: ba 10 20 00 clr %i5
{
printf ("rtems-rfs: format: superblock write failed\n");
2010e8c: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010e90: 90 12 20 00 mov %o0, %o0 ! 2032400 <_CPU_Trap_slot_template+0x3c8><== NOT EXECUTED
2010e94: 40 00 44 d4 call 20221e4 <puts> <== NOT EXECUTED
2010e98: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2010e9c: 30 80 01 93 b,a 20114e8 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
2010ea0: f8 07 bf a4 ld [ %fp + -92 ], %i4
2010ea4: 90 10 00 1d mov %i5, %o0
2010ea8: 7f ff c5 bb call 2002594 <.umul>
2010eac: 92 10 00 1c mov %i4, %o1
if (group_base > rtems_rfs_fs_blocks (fs))
2010eb0: c2 07 bf 80 ld [ %fp + -128 ], %g1
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
2010eb4: a0 02 20 01 add %o0, 1, %l0
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
2010eb8: ec 0e 60 14 ldub [ %i1 + 0x14 ], %l6
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
2010ebc: 80 a4 00 01 cmp %l0, %g1
2010ec0: 08 80 00 08 bleu 2010ee0 <rtems_rfs_format+0x6f0> <== ALWAYS TAKEN
2010ec4: b4 10 00 08 mov %o0, %i2
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
2010ec8: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010ecc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2010ed0: 40 00 44 2d call 2021f84 <printf> <== NOT EXECUTED
2010ed4: 90 12 20 30 or %o0, 0x30, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
2010ed8: 10 80 00 d9 b 201123c <rtems_rfs_format+0xa4c> <== NOT EXECUTED
2010edc: 82 10 20 00 clr %g1 <== NOT EXECUTED
/*
* Be nice to strange sizes of disks. These are embedded systems after all
* and nice numbers do not always work out. Let the last block pick up the
* remainder of the blocks.
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
2010ee0: 84 04 00 1c add %l0, %i4, %g2
2010ee4: 80 a0 80 01 cmp %g2, %g1
2010ee8: 38 80 00 02 bgu,a 2010ef0 <rtems_rfs_format+0x700> <== ALWAYS TAKEN
2010eec: b8 20 40 10 sub %g1, %l0, %i4
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
2010ef0: 80 8d e0 ff btst 0xff, %l7
2010ef4: 22 80 00 09 be,a 2010f18 <rtems_rfs_format+0x728> <== ALWAYS TAKEN
2010ef8: c0 2f bf 30 clrb [ %fp + -208 ]
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
2010efc: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010f00: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2010f04: 90 12 20 70 or %o0, 0x70, %o0 <== NOT EXECUTED
2010f08: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2010f0c: 40 00 44 1e call 2021f84 <printf> <== NOT EXECUTED
2010f10: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
2010f14: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
2010f18: c0 27 bf 34 clr [ %fp + -204 ]
printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
if (verbose)
2010f1c: 80 8d e0 ff btst 0xff, %l7
2010f20: 02 80 00 05 be 2010f34 <rtems_rfs_format+0x744> <== ALWAYS TAKEN
2010f24: c0 27 bf 38 clr [ %fp + -200 ]
printf (", blocks");
2010f28: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010f2c: 40 00 44 16 call 2021f84 <printf> <== NOT EXECUTED
2010f30: 90 12 20 a8 or %o0, 0xa8, %o0 ! 20324a8 <_CPU_Trap_slot_template+0x470><== NOT EXECUTED
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
2010f34: 98 10 00 10 mov %l0, %o4
2010f38: b6 07 bf 3c add %fp, -196, %i3
2010f3c: 92 07 bf 7c add %fp, -132, %o1
2010f40: 90 10 00 1b mov %i3, %o0
2010f44: 94 07 bf 30 add %fp, -208, %o2
2010f48: 40 00 24 28 call 2019fe8 <rtems_rfs_bitmap_open>
2010f4c: 96 10 00 1c mov %i4, %o3
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
2010f50: a0 92 20 00 orcc %o0, 0, %l0
2010f54: 04 80 00 0a ble 2010f7c <rtems_rfs_format+0x78c> <== ALWAYS TAKEN
2010f58: 92 07 bf 30 add %fp, -208, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
2010f5c: 7f ff fe 10 call 201079c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2010f60: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
2010f64: 40 00 48 74 call 2023134 <strerror> <== NOT EXECUTED
2010f68: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2010f6c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2010f70: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010f74: 10 80 00 17 b 2010fd0 <rtems_rfs_format+0x7e0> <== NOT EXECUTED
2010f78: 90 12 20 b8 or %o0, 0xb8, %o0 ! 20324b8 <_CPU_Trap_slot_template+0x480><== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
2010f7c: c2 07 bf 38 ld [ %fp + -200 ], %g1
2010f80: d4 07 bf 84 ld [ %fp + -124 ], %o2
2010f84: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2010f88: 40 00 43 81 call 2021d8c <memset>
2010f8c: 92 10 20 ff mov 0xff, %o1
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
2010f90: 40 00 23 6f call 2019d4c <rtems_rfs_bitmap_map_clear_all>
2010f94: 90 10 00 1b mov %i3, %o0
2010f98: a0 10 00 08 mov %o0, %l0
if (rc > 0)
2010f9c: 80 a4 20 00 cmp %l0, 0
2010fa0: 04 80 00 0f ble 2010fdc <rtems_rfs_format+0x7ec> <== ALWAYS TAKEN
2010fa4: 90 10 00 1b mov %i3, %o0
{
rtems_rfs_bitmap_close (&bitmap);
2010fa8: 40 00 24 21 call 201a02c <rtems_rfs_bitmap_close> <== NOT EXECUTED
2010fac: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
2010fb0: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
2010fb4: 7f ff fd fa call 201079c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2010fb8: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
2010fbc: 40 00 48 5e call 2023134 <strerror> <== NOT EXECUTED
2010fc0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2010fc4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2010fc8: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010fcc: 90 12 21 00 or %o0, 0x100, %o0 ! 2032500 <_CPU_Trap_slot_template+0x4c8><== NOT EXECUTED
2010fd0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2010fd4: 10 80 00 5e b 201114c <rtems_rfs_format+0x95c> <== NOT EXECUTED
2010fd8: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
2010fdc: 40 00 22 d8 call 2019b3c <rtems_rfs_bitmap_map_set>
2010fe0: 92 10 20 00 clr %o1
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
2010fe4: 92 10 20 01 mov 1, %o1
2010fe8: 40 00 22 d5 call 2019b3c <rtems_rfs_bitmap_map_set>
2010fec: 90 10 00 1b mov %i3, %o0
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
2010ff0: d0 07 bf a8 ld [ %fp + -88 ], %o0
2010ff4: d2 07 bf ac ld [ %fp + -84 ], %o1
2010ff8: 7f ff fd f3 call 20107c4 <rtems_rfs_rup_quotient>
2010ffc: a2 10 20 00 clr %l1
2011000: 10 80 00 05 b 2011014 <rtems_rfs_format+0x824>
2011004: a0 10 00 08 mov %o0, %l0
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
2011008: 92 04 60 02 add %l1, 2, %o1
201100c: 40 00 22 cc call 2019b3c <rtems_rfs_bitmap_map_set>
2011010: a2 04 60 01 inc %l1
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
2011014: 80 a4 40 10 cmp %l1, %l0
2011018: 06 bf ff fc bl 2011008 <rtems_rfs_format+0x818>
201101c: 90 10 00 1b mov %i3, %o0
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
2011020: 40 00 24 03 call 201a02c <rtems_rfs_bitmap_close>
2011024: 01 00 00 00 nop
if (rc > 0)
2011028: b6 92 20 00 orcc %o0, 0, %i3
201102c: 24 80 00 0d ble,a 2011060 <rtems_rfs_format+0x870> <== ALWAYS TAKEN
2011030: 82 10 20 01 mov 1, %g1
{
rtems_rfs_buffer_handle_close (fs, &handle);
2011034: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
2011038: 7f ff fd d9 call 201079c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201103c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
2011040: 40 00 48 3d call 2023134 <strerror> <== NOT EXECUTED
2011044: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2011048: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201104c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2011050: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2011054: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2011058: 10 80 00 3d b 201114c <rtems_rfs_format+0x95c> <== NOT EXECUTED
201105c: 90 12 21 50 or %o0, 0x150, %o0 ! 2032550 <_CPU_Trap_slot_template+0x518><== NOT EXECUTED
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
2011060: 80 8d e0 ff btst 0xff, %l7
2011064: 02 80 00 05 be 2011078 <rtems_rfs_format+0x888> <== ALWAYS TAKEN
2011068: c2 2f bf 30 stb %g1, [ %fp + -208 ]
printf (", inodes");
201106c: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2011070: 40 00 43 c5 call 2021f84 <printf> <== NOT EXECUTED
2011074: 90 12 21 98 or %o0, 0x198, %o0 ! 2032598 <_CPU_Trap_slot_template+0x560><== NOT EXECUTED
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
2011078: 96 10 00 1c mov %i4, %o3
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
201107c: ae 07 bf 7c add %fp, -132, %l7
printf (", inodes");
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
2011080: b6 07 bf 30 add %fp, -208, %i3
2011084: 90 07 bf 3c add %fp, -196, %o0
2011088: 92 10 00 17 mov %l7, %o1
201108c: 94 10 00 1b mov %i3, %o2
2011090: 40 00 23 d6 call 2019fe8 <rtems_rfs_bitmap_open>
2011094: 98 06 a0 02 add %i2, 2, %o4
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
2011098: b8 92 20 00 orcc %o0, 0, %i4
201109c: 04 80 00 09 ble 20110c0 <rtems_rfs_format+0x8d0> <== ALWAYS TAKEN
20110a0: 92 10 00 1b mov %i3, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
20110a4: 7f ff fd be call 201079c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
20110a8: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
20110ac: 40 00 48 22 call 2023134 <strerror> <== NOT EXECUTED
20110b0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20110b4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20110b8: 10 80 00 23 b 2011144 <rtems_rfs_format+0x954> <== NOT EXECUTED
20110bc: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
20110c0: c2 07 bf 38 ld [ %fp + -200 ], %g1
20110c4: d4 07 bf 84 ld [ %fp + -124 ], %o2
20110c8: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
20110cc: 40 00 43 30 call 2021d8c <memset>
20110d0: 92 10 20 00 clr %o1
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
20110d4: 40 00 23 1e call 2019d4c <rtems_rfs_bitmap_map_clear_all>
20110d8: 90 07 bf 3c add %fp, -196, %o0
20110dc: b8 10 00 08 mov %o0, %i4
if (rc > 0)
20110e0: 80 a7 20 00 cmp %i4, 0
20110e4: 04 80 00 0c ble 2011114 <rtems_rfs_format+0x924> <== ALWAYS TAKEN
20110e8: 90 07 bf 3c add %fp, -196, %o0
{
rtems_rfs_bitmap_close (&bitmap);
20110ec: 40 00 23 d0 call 201a02c <rtems_rfs_bitmap_close> <== NOT EXECUTED
20110f0: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
20110f4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20110f8: 7f ff fd a9 call 201079c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
20110fc: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
2011100: 40 00 48 0d call 2023134 <strerror> <== NOT EXECUTED
2011104: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2011108: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201110c: 10 80 00 0e b 2011144 <rtems_rfs_format+0x954> <== NOT EXECUTED
2011110: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
2011114: 40 00 23 c6 call 201a02c <rtems_rfs_bitmap_close>
2011118: 01 00 00 00 nop
if (rc > 0)
201111c: b8 92 20 00 orcc %o0, 0, %i4
2011120: 24 80 00 0f ble,a 201115c <rtems_rfs_format+0x96c> <== ALWAYS TAKEN
2011124: 82 10 20 01 mov 1, %g1
{
rtems_rfs_buffer_handle_close (fs, &handle);
2011128: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201112c: 7f ff fd 9c call 201079c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2011130: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
2011134: 40 00 48 00 call 2023134 <strerror> <== NOT EXECUTED
2011138: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201113c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2011140: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
2011144: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2011148: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201114c: 40 00 43 8e call 2021f84 <printf> <== NOT EXECUTED
2011150: 01 00 00 00 nop <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
2011154: 10 80 00 3a b 201123c <rtems_rfs_format+0xa4c> <== NOT EXECUTED
2011158: 82 10 20 00 clr %g1 ! 0 <PROM_START> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
" bitmap failed: %d: %s\n", group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
201115c: c2 2f bf 30 stb %g1, [ %fp + -208 ]
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
2011160: 80 8d a0 ff btst 0xff, %l6
2011164: 12 80 00 27 bne 2011200 <rtems_rfs_format+0xa10> <== NEVER TAKEN
2011168: a2 10 20 00 clr %l1
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
201116c: 90 07 bf 7c add %fp, -132, %o0
2011170: 7f ff fd 8b call 201079c <rtems_rfs_buffer_handle_close>
2011174: 92 07 bf 30 add %fp, -208, %o1
if (rc > 0)
2011178: b8 92 20 00 orcc %o0, 0, %i4
201117c: 04 80 00 30 ble 201123c <rtems_rfs_format+0xa4c> <== ALWAYS TAKEN
2011180: 82 10 20 01 mov 1, %g1
2011184: 30 80 00 27 b,a 2011220 <rtems_rfs_format+0xa30> <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
2011188: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
201118c: b8 00 40 11 add %g1, %l1, %i4 <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
2011190: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2011194: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2011198: 40 00 28 98 call 201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201119c: 96 10 20 00 clr %o3 <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
20111a0: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
20111a4: 04 80 00 10 ble 20111e4 <rtems_rfs_format+0x9f4> <== NOT EXECUTED
20111a8: c4 07 bf 38 ld [ %fp + -200 ], %g2 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
20111ac: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20111b0: 7f ff fd 7b call 201079c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
20111b4: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
20111b8: 40 00 47 df call 2023134 <strerror> <== NOT EXECUTED
20111bc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
20111c0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20111c4: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
20111c8: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
20111cc: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
20111d0: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
20111d4: 40 00 43 6c call 2021f84 <printf> <== NOT EXECUTED
20111d8: 90 12 22 88 or %o0, 0x288, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
20111dc: 10 80 00 18 b 201123c <rtems_rfs_format+0xa4c> <== NOT EXECUTED
20111e0: 82 10 20 00 clr %g1 <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
20111e4: d4 07 bf 84 ld [ %fp + -124 ], %o2 <== NOT EXECUTED
20111e8: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0 <== NOT EXECUTED
20111ec: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
20111f0: 40 00 42 e7 call 2021d8c <memset> <== NOT EXECUTED
20111f4: a2 04 60 01 inc %l1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
20111f8: 10 80 00 05 b 201120c <rtems_rfs_format+0xa1c> <== NOT EXECUTED
20111fc: ec 2f bf 30 stb %l6, [ %fp + -208 ] <== NOT EXECUTED
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
2011200: b4 06 a0 03 add %i2, 3, %i2 <== NOT EXECUTED
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
rtems_rfs_buffer_mark_dirty (&handle);
2011204: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
2011208: f4 27 bf 24 st %i2, [ %fp + -220 ] <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
201120c: 80 a4 40 10 cmp %l1, %l0 <== NOT EXECUTED
2011210: 06 bf ff de bl 2011188 <rtems_rfs_format+0x998> <== NOT EXECUTED
2011214: c2 07 bf 24 ld [ %fp + -220 ], %g1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
2011218: 10 bf ff d6 b 2011170 <rtems_rfs_format+0x980> <== NOT EXECUTED
201121c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
2011220: 40 00 47 c5 call 2023134 <strerror> <== NOT EXECUTED
2011224: 01 00 00 00 nop <== NOT EXECUTED
2011228: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201122c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011230: 40 00 43 55 call 2021f84 <printf> <== NOT EXECUTED
2011234: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rc, strerror (rc));
return false;
2011238: 82 10 20 00 clr %g1 <== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
201123c: 80 88 60 ff btst 0xff, %g1
2011240: 02 80 00 a9 be 20114e4 <rtems_rfs_format+0xcf4> <== NEVER TAKEN
2011244: ba 07 60 01 inc %i5
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
2011248: 10 80 00 0b b 2011274 <rtems_rfs_format+0xa84>
201124c: c2 07 bf a0 ld [ %fp + -96 ], %g1
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
2011250: 25 00 80 c9 sethi %hi(0x2032400), %l2
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
2011254: 27 00 80 c9 sethi %hi(0x2032400), %l3
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
{
rtems_rfs_bitmap_close (&bitmap);
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
2011258: 29 00 80 c9 sethi %hi(0x2032400), %l4
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
201125c: 2b 00 80 c9 sethi %hi(0x2032400), %l5
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
2011260: a4 14 a2 d0 or %l2, 0x2d0, %l2
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
2011264: a6 14 e2 40 or %l3, 0x240, %l3
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
{
rtems_rfs_bitmap_close (&bitmap);
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
2011268: a8 15 21 f0 or %l4, 0x1f0, %l4
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
201126c: aa 15 61 a8 or %l5, 0x1a8, %l5
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
2011270: c2 07 bf a0 ld [ %fp + -96 ], %g1
2011274: 80 a7 40 01 cmp %i5, %g1
2011278: 06 bf ff 0a bl 2010ea0 <rtems_rfs_format+0x6b0>
201127c: ee 0e 60 15 ldub [ %i1 + 0x15 ], %l7
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
2011280: 80 8d e0 ff btst 0xff, %l7
2011284: 02 80 00 04 be 2011294 <rtems_rfs_format+0xaa4> <== ALWAYS TAKEN
2011288: 01 00 00 00 nop
printf ("\n");
201128c: 40 00 43 a8 call 202212c <putchar> <== NOT EXECUTED
2011290: 90 10 20 0a mov 0xa, %o0 ! a <PROM_START+0xa> <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
2011294: 40 00 29 da call 201b9fc <rtems_rfs_buffer_close>
2011298: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
201129c: ba 92 20 00 orcc %o0, 0, %i5
20112a0: 24 80 00 08 ble,a 20112c0 <rtems_rfs_format+0xad0> <== ALWAYS TAKEN
20112a4: 90 10 00 18 mov %i0, %o0
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
20112a8: 40 00 47 a3 call 2023134 <strerror> <== NOT EXECUTED
20112ac: 01 00 00 00 nop <== NOT EXECUTED
20112b0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20112b4: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
20112b8: 10 80 00 87 b 20114d4 <rtems_rfs_format+0xce4> <== NOT EXECUTED
20112bc: 90 12 23 10 or %o0, 0x310, %o0 ! 2032710 <_CPU_Trap_slot_template+0x6d8><== NOT EXECUTED
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
20112c0: 92 10 20 00 clr %o1
20112c4: 94 10 20 06 mov 6, %o2
20112c8: 96 10 20 00 clr %o3
20112cc: 40 00 32 70 call 201dc8c <rtems_rfs_fs_open>
20112d0: 98 07 bf 28 add %fp, -216, %o4
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
20112d4: 80 a2 20 00 cmp %o0, 0
20112d8: 36 80 00 0e bge,a 2011310 <rtems_rfs_format+0xb20> <== ALWAYS TAKEN
20112dc: d0 07 bf 28 ld [ %fp + -216 ], %o0
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
20112e0: 40 00 3d d0 call 2020a20 <__errno> <== NOT EXECUTED
20112e4: b0 10 20 00 clr %i0 <== NOT EXECUTED
20112e8: 40 00 3d ce call 2020a20 <__errno> <== NOT EXECUTED
20112ec: 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",
20112f0: 40 00 47 91 call 2023134 <strerror> <== NOT EXECUTED
20112f4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20112f8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20112fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011300: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2011304: 40 00 43 20 call 2021f84 <printf> <== NOT EXECUTED
2011308: 90 12 23 40 or %o0, 0x340, %o0 ! 2032740 <_CPU_Trap_slot_template+0x708><== NOT EXECUTED
201130c: 30 80 00 77 b,a 20114e8 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
2011310: 92 10 20 01 mov 1, %o1
2011314: 40 00 02 38 call 2011bf4 <rtems_rfs_inode_alloc>
2011318: 94 07 bf 2c add %fp, -212, %o2
if (rc > 0)
201131c: ba 92 20 00 orcc %o0, 0, %i5
2011320: 04 80 00 0a ble 2011348 <rtems_rfs_format+0xb58> <== ALWAYS TAKEN
2011324: d2 07 bf 2c ld [ %fp + -212 ], %o1
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
2011328: 40 00 47 83 call 2023134 <strerror> <== NOT EXECUTED
201132c: 01 00 00 00 nop <== NOT EXECUTED
2011330: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2011334: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011338: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
201133c: 40 00 43 12 call 2021f84 <printf> <== NOT EXECUTED
2011340: 90 12 23 78 or %o0, 0x378, %o0 ! 2032778 <_CPU_Trap_slot_template+0x740><== NOT EXECUTED
2011344: 30 80 00 06 b,a 201135c <rtems_rfs_format+0xb6c> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
2011348: 80 a2 60 01 cmp %o1, 1
201134c: 02 80 00 08 be 201136c <rtems_rfs_format+0xb7c> <== ALWAYS TAKEN
2011350: 11 00 80 c9 sethi %hi(0x2032400), %o0
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
2011354: 40 00 43 0c call 2021f84 <printf> <== NOT EXECUTED
2011358: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 20327b0 <_CPU_Trap_slot_template+0x778><== NOT EXECUTED
rtems_rfs_fs_close (fs);
201135c: 40 00 34 47 call 201e478 <rtems_rfs_fs_close> <== NOT EXECUTED
2011360: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
2011364: 10 80 00 55 b 20114b8 <rtems_rfs_format+0xcc8> <== NOT EXECUTED
2011368: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
201136c: d0 07 bf 28 ld [ %fp + -216 ], %o0
2011370: 92 10 20 01 mov 1, %o1
2011374: 94 07 bf 54 add %fp, -172, %o2
2011378: 40 00 02 5b call 2011ce4 <rtems_rfs_inode_open>
201137c: 96 10 20 01 mov 1, %o3
if (rc > 0)
2011380: ba 92 20 00 orcc %o0, 0, %i5
2011384: 24 80 00 0e ble,a 20113bc <rtems_rfs_format+0xbcc> <== ALWAYS TAKEN
2011388: 90 07 bf 54 add %fp, -172, %o0
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
201138c: 40 00 47 6a call 2023134 <strerror> <== NOT EXECUTED
2011390: 01 00 00 00 nop <== NOT EXECUTED
2011394: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2011398: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201139c: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
20113a0: 40 00 42 f9 call 2021f84 <printf> <== NOT EXECUTED
20113a4: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 20327e8 <_CPU_Trap_slot_template+0x7b0><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
20113a8: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
20113ac: d4 07 bf 2c ld [ %fp + -212 ], %o2 <== NOT EXECUTED
20113b0: 40 00 01 7c call 20119a0 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
20113b4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
20113b8: 30 bf ff e9 b,a 201135c <rtems_rfs_format+0xb6c> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
20113bc: 92 10 20 00 clr %o1
20113c0: 15 00 00 10 sethi %hi(0x4000), %o2
20113c4: 96 10 20 00 clr %o3
20113c8: 94 12 a1 c9 or %o2, 0x1c9, %o2
20113cc: 40 00 03 39 call 20120b0 <rtems_rfs_inode_initialise>
20113d0: 98 10 20 00 clr %o4
(RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
0, 0);
if (rc > 0)
20113d4: ba 92 20 00 orcc %o0, 0, %i5
20113d8: 24 80 00 0a ble,a 2011400 <rtems_rfs_format+0xc10> <== ALWAYS TAKEN
20113dc: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
20113e0: 40 00 47 55 call 2023134 <strerror> <== NOT EXECUTED
20113e4: 01 00 00 00 nop <== NOT EXECUTED
20113e8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20113ec: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20113f0: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
20113f4: 40 00 42 e4 call 2021f84 <printf> <== NOT EXECUTED
20113f8: 90 12 20 18 or %o0, 0x18, %o0 ! 2032818 <_CPU_Trap_slot_template+0x7e0><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
20113fc: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
2011400: d8 07 bf 2c ld [ %fp + -212 ], %o4
2011404: 92 07 bf 54 add %fp, -172, %o1
2011408: 15 00 80 c0 sethi %hi(0x2030000), %o2
201140c: 96 10 20 01 mov 1, %o3
2011410: 40 00 2a f7 call 201bfec <rtems_rfs_dir_add_entry>
2011414: 94 12 a3 30 or %o2, 0x330, %o2
if (rc > 0)
2011418: ba 92 20 00 orcc %o0, 0, %i5
201141c: 24 80 00 0a ble,a 2011444 <rtems_rfs_format+0xc54> <== ALWAYS TAKEN
2011420: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
2011424: 40 00 47 44 call 2023134 <strerror> <== NOT EXECUTED
2011428: 01 00 00 00 nop <== NOT EXECUTED
201142c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2011430: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011434: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011438: 40 00 42 d3 call 2021f84 <printf> <== NOT EXECUTED
201143c: 90 12 20 50 or %o0, 0x50, %o0 ! 2032850 <_CPU_Trap_slot_template+0x818><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
2011440: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
2011444: 40 00 02 9a call 2011eac <rtems_rfs_inode_close>
2011448: 92 07 bf 54 add %fp, -172, %o1
if (rc > 0)
201144c: ba 92 20 00 orcc %o0, 0, %i5
2011450: 04 80 00 09 ble 2011474 <rtems_rfs_format+0xc84> <== ALWAYS TAKEN
2011454: 01 00 00 00 nop
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
2011458: 40 00 47 37 call 2023134 <strerror> <== NOT EXECUTED
201145c: 01 00 00 00 nop <== NOT EXECUTED
2011460: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2011464: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011468: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
201146c: 40 00 42 c6 call 2021f84 <printf> <== NOT EXECUTED
2011470: 90 12 20 88 or %o0, 0x88, %o0 ! 2032888 <_CPU_Trap_slot_template+0x850><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
2011474: 40 00 34 01 call 201e478 <rtems_rfs_fs_close>
2011478: d0 07 bf 28 ld [ %fp + -216 ], %o0
if (rc < 0)
201147c: ba 92 20 00 orcc %o0, 0, %i5
2011480: 16 80 00 0e bge 20114b8 <rtems_rfs_format+0xcc8> <== ALWAYS TAKEN
2011484: 80 a7 60 00 cmp %i5, 0
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
2011488: 40 00 3d 66 call 2020a20 <__errno> <== NOT EXECUTED
201148c: 01 00 00 00 nop <== NOT EXECUTED
2011490: 40 00 3d 64 call 2020a20 <__errno> <== NOT EXECUTED
2011494: f8 02 00 00 ld [ %o0 ], %i4 <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
2011498: 40 00 47 27 call 2023134 <strerror> <== NOT EXECUTED
201149c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20114a0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
20114a4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20114a8: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
20114ac: 40 00 42 b6 call 2021f84 <printf> <== NOT EXECUTED
20114b0: 90 12 20 b8 or %o0, 0xb8, %o0 ! 20328b8 <_CPU_Trap_slot_template+0x880><== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
20114b4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
20114b8: 24 80 00 0c ble,a 20114e8 <rtems_rfs_format+0xcf8> <== ALWAYS TAKEN
20114bc: b0 10 20 00 clr %i0
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
20114c0: 40 00 47 1d call 2023134 <strerror> <== NOT EXECUTED
20114c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20114c8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20114cc: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
20114d0: 90 12 20 f0 or %o0, 0xf0, %o0 ! 20328f0 <_CPU_Trap_slot_template+0x8b8><== NOT EXECUTED
20114d4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20114d8: 40 00 42 ab call 2021f84 <printf> <== NOT EXECUTED
20114dc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20114e0: 30 80 00 02 b,a 20114e8 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
20114e4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20114e8: 81 c7 e0 08 ret
20114ec: 81 e8 00 00 restore
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
20114f0: c2 27 bf 98 st %g1, [ %fp + -104 ]
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
20114f4: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
20114f8: 80 a0 60 00 cmp %g1, 0
20114fc: 02 bf fd d0 be 2010c3c <rtems_rfs_format+0x44c> <== ALWAYS TAKEN
2011500: d2 07 bf 84 ld [ %fp + -124 ], %o1
2011504: 30 bf fd 6f b,a 2010ac0 <rtems_rfs_format+0x2d0> <== NOT EXECUTED
0201e478 <rtems_rfs_fs_close>:
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
201e478: 9d e3 bf a0 save %sp, -96, %sp
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
201e47c: 90 10 20 00 clr %o0
201e480: 7f ff d4 a2 call 2013708 <rtems_rfs_trace>
201e484: 92 10 20 02 mov 2, %o1
201e488: 80 8a 20 ff btst 0xff, %o0
201e48c: 22 80 00 06 be,a 201e4a4 <rtems_rfs_fs_close+0x2c> <== ALWAYS TAKEN
201e490: b8 10 20 00 clr %i4
printf ("rtems-rfs: close\n");
201e494: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e498: 40 00 0f 53 call 20221e4 <puts> <== NOT EXECUTED
201e49c: 90 12 20 c8 or %o0, 0xc8, %o0 ! 20348c8 <CSWTCH.2+0x13e8> <== NOT EXECUTED
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
201e4a0: b8 10 20 00 clr %i4 <== NOT EXECUTED
201e4a4: 10 80 00 07 b 201e4c0 <rtems_rfs_fs_close+0x48>
201e4a8: ba 10 20 00 clr %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
rtems_rfs_group_close (fs, &fs->groups[group]);
201e4ac: 90 10 00 18 mov %i0, %o0
201e4b0: 92 02 40 1c add %o1, %i4, %o1
201e4b4: 7f ff cc 93 call 2011700 <rtems_rfs_group_close>
201e4b8: ba 07 60 01 inc %i5
201e4bc: b8 07 20 50 add %i4, 0x50, %i4
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
201e4c0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
201e4c4: 80 a7 40 01 cmp %i5, %g1
201e4c8: 26 bf ff f9 bl,a 201e4ac <rtems_rfs_fs_close+0x34>
201e4cc: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
201e4d0: 7f ff f5 4b call 201b9fc <rtems_rfs_buffer_close>
201e4d4: 90 10 00 18 mov %i0, %o0
free (fs);
201e4d8: 90 10 00 18 mov %i0, %o0
201e4dc: 7f ff a6 c2 call 2007fe4 <free>
201e4e0: b0 10 20 00 clr %i0
return 0;
}
201e4e4: 81 c7 e0 08 ret
201e4e8: 81 e8 00 00 restore
0201dc8c <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)
{
201dc8c: 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))
201dc90: 90 10 20 00 clr %o0
201dc94: 7f ff d6 9d call 2013708 <rtems_rfs_trace>
201dc98: 92 10 20 01 mov 1, %o1
201dc9c: 80 8a 20 ff btst 0xff, %o0
201dca0: 02 80 00 05 be 201dcb4 <rtems_rfs_fs_open+0x28> <== ALWAYS TAKEN
201dca4: 11 00 80 d1 sethi %hi(0x2034400), %o0
printf ("rtems-rfs: open: %s\n", name);
201dca8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201dcac: 40 00 10 b6 call 2021f84 <printf> <== NOT EXECUTED
201dcb0: 90 12 21 88 or %o0, 0x188, %o0 <== NOT EXECUTED
*fs = malloc (sizeof (rtems_rfs_file_system));
201dcb4: 7f ff aa 5d call 2008628 <malloc>
201dcb8: 90 10 20 84 mov 0x84, %o0
if (!*fs)
201dcbc: 80 a2 20 00 cmp %o0, 0
201dcc0: 12 80 00 0f bne 201dcfc <rtems_rfs_fs_open+0x70> <== ALWAYS TAKEN
201dcc4: d0 27 00 00 st %o0, [ %i4 ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201dcc8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201dccc: 7f ff d6 8f call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201dcd0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201dcd4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201dcd8: 02 80 00 05 be 201dcec <rtems_rfs_fs_open+0x60> <== NOT EXECUTED
201dcdc: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
201dce0: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201dce4: 40 00 11 40 call 20221e4 <puts> <== NOT EXECUTED
201dce8: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 20345a0 <CSWTCH.2+0x10c0><== NOT EXECUTED
errno = ENOMEM;
201dcec: 40 00 0b 4d call 2020a20 <__errno> <== NOT EXECUTED
201dcf0: 01 00 00 00 nop <== NOT EXECUTED
201dcf4: 10 80 01 c5 b 201e408 <rtems_rfs_fs_open+0x77c> <== NOT EXECUTED
201dcf8: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
201dcfc: 92 10 20 00 clr %o1
201dd00: 40 00 10 23 call 2021d8c <memset>
201dd04: 94 10 20 84 mov 0x84, %o2
(*fs)->user = user;
201dd08: c2 07 00 00 ld [ %i4 ], %g1
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
201dd0c: 90 10 00 18 mov %i0, %o0
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
201dd10: f2 20 60 80 st %i1, [ %g1 + 0x80 ]
rtems_chain_initialize_empty (&(*fs)->buffers);
201dd14: 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;
201dd18: 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 );
201dd1c: 84 00 60 44 add %g1, 0x44, %g2
201dd20: 86 00 60 48 add %g1, 0x48, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
201dd24: c4 20 60 4c st %g2, [ %g1 + 0x4c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
201dd28: c6 20 60 44 st %g3, [ %g1 + 0x44 ]
rtems_chain_initialize_empty (&(*fs)->release);
201dd2c: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
201dd30: 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 );
201dd34: 84 00 60 54 add %g1, 0x54, %g2
201dd38: 86 00 60 58 add %g1, 0x58, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
201dd3c: 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;
201dd40: c6 20 60 54 st %g3, [ %g1 + 0x54 ]
rtems_chain_initialize_empty (&(*fs)->release_modified);
201dd44: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
201dd48: 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 );
201dd4c: 84 00 60 64 add %g1, 0x64, %g2
201dd50: 86 00 60 68 add %g1, 0x68, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
201dd54: c4 20 60 6c st %g2, [ %g1 + 0x6c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
201dd58: c6 20 60 64 st %g3, [ %g1 + 0x64 ]
rtems_chain_initialize_empty (&(*fs)->file_shares);
201dd5c: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
201dd60: 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 );
201dd64: 84 00 60 74 add %g1, 0x74, %g2
201dd68: 86 00 60 78 add %g1, 0x78, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
201dd6c: c4 20 60 7c st %g2, [ %g1 + 0x7c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
201dd70: c6 20 60 74 st %g3, [ %g1 + 0x74 ]
(*fs)->max_held_buffers = max_held_buffers;
201dd74: d2 07 00 00 ld [ %i4 ], %o1
201dd78: f6 22 60 40 st %i3, [ %o1 + 0x40 ]
(*fs)->buffers_count = 0;
201dd7c: c0 22 60 50 clr [ %o1 + 0x50 ]
(*fs)->release_count = 0;
201dd80: c0 22 60 60 clr [ %o1 + 0x60 ]
(*fs)->release_modified_count = 0;
201dd84: c0 22 60 70 clr [ %o1 + 0x70 ]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
201dd88: 7f ff f6 42 call 201b690 <rtems_rfs_buffer_open>
201dd8c: f4 22 40 00 st %i2, [ %o1 ]
if (rc > 0)
201dd90: ba 92 20 00 orcc %o0, 0, %i5
201dd94: 04 80 00 16 ble 201ddec <rtems_rfs_fs_open+0x160> <== ALWAYS TAKEN
201dd98: f6 07 00 00 ld [ %i4 ], %i3
{
free (*fs);
201dd9c: 7f ff a8 92 call 2007fe4 <free> <== NOT EXECUTED
201dda0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201dda4: 90 10 20 00 clr %o0 <== NOT EXECUTED
201dda8: 7f ff d6 58 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201ddac: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201ddb0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ddb4: 02 80 00 09 be 201ddd8 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
201ddb8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
201ddbc: 40 00 14 de call 2023134 <strerror> <== NOT EXECUTED
201ddc0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ddc4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201ddc8: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201ddcc: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 20345d0 <CSWTCH.2+0x10f0><== NOT EXECUTED
201ddd0: 40 00 10 6d call 2021f84 <printf> <== NOT EXECUTED
201ddd4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
201ddd8: 40 00 0b 12 call 2020a20 <__errno> <== NOT EXECUTED
201dddc: 01 00 00 00 nop <== NOT EXECUTED
201dde0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return -1;
201dde4: 81 c7 e0 08 ret <== NOT EXECUTED
201dde8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201ddec: c0 2f bf cc clrb [ %fp + -52 ]
handle->bnum = 0;
201ddf0: c0 27 bf d0 clr [ %fp + -48 ]
handle->buffer = NULL;
201ddf4: 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);
201ddf8: 90 10 00 1b mov %i3, %o0
201ddfc: 92 07 bf cc add %fp, -52, %o1
201de00: 94 10 20 00 clr %o2
201de04: 7f ff f5 7d call 201b3f8 <rtems_rfs_buffer_handle_request>
201de08: 96 10 20 01 mov 1, %o3
if (rc > 0)
201de0c: ba 92 20 00 orcc %o0, 0, %i5
201de10: 04 80 00 0d ble 201de44 <rtems_rfs_fs_open+0x1b8> <== ALWAYS TAKEN
201de14: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201de18: 7f ff d6 3c call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201de1c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201de20: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201de24: 22 80 01 2d be,a 201e2d8 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
201de28: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
201de2c: 40 00 14 c2 call 2023134 <strerror> <== NOT EXECUTED
201de30: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201de34: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201de38: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201de3c: 10 80 00 de b 201e1b4 <rtems_rfs_fs_open+0x528> <== NOT EXECUTED
201de40: 90 12 22 00 or %o0, 0x200, %o0 ! 2034600 <CSWTCH.2+0x1120><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
201de44: c2 07 bf d4 ld [ %fp + -44 ], %g1
201de48: 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)
201de4c: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
201de50: c4 0f 40 00 ldub [ %i5 ], %g2
201de54: 83 28 60 10 sll %g1, 0x10, %g1
201de58: 85 28 a0 18 sll %g2, 0x18, %g2
201de5c: 84 10 80 01 or %g2, %g1, %g2
201de60: c2 0f 60 03 ldub [ %i5 + 3 ], %g1
201de64: 84 10 80 01 or %g2, %g1, %g2
201de68: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
201de6c: 83 28 60 08 sll %g1, 8, %g1
201de70: 84 10 80 01 or %g2, %g1, %g2
201de74: 03 0a 02 48 sethi %hi(0x28092000), %g1
201de78: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_END+0x25c92001>
201de7c: 80 a0 80 01 cmp %g2, %g1
201de80: 22 80 00 0b be,a 201deac <rtems_rfs_fs_open+0x220> <== ALWAYS TAKEN
201de84: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201de88: 90 10 20 00 clr %o0 <== NOT EXECUTED
201de8c: 7f ff d6 1f call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201de90: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201de94: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201de98: 22 80 00 57 be,a 201dff4 <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
201de9c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
201dea0: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201dea4: 10 80 00 2f b 201df60 <rtems_rfs_fs_open+0x2d4> <== NOT EXECUTED
201dea8: 90 12 22 38 or %o0, 0x238, %o0 ! 2034638 <CSWTCH.2+0x1158><== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
201deac: d6 0f 60 0c ldub [ %i5 + 0xc ], %o3
201deb0: 83 28 60 10 sll %g1, 0x10, %g1
201deb4: 97 2a e0 18 sll %o3, 0x18, %o3
201deb8: 96 12 c0 01 or %o3, %g1, %o3
201debc: c2 0f 60 0f ldub [ %i5 + 0xf ], %g1
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
201dec0: 94 10 20 00 clr %o2
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
201dec4: 96 12 c0 01 or %o3, %g1, %o3
201dec8: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
201decc: 90 10 20 00 clr %o0
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
201ded0: 83 28 60 08 sll %g1, 8, %g1
201ded4: 96 12 c0 01 or %o3, %g1, %o3
201ded8: d6 26 e0 04 st %o3, [ %i3 + 4 ]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
201dedc: c2 0f 60 09 ldub [ %i5 + 9 ], %g1
201dee0: f4 0f 60 08 ldub [ %i5 + 8 ], %i2
201dee4: 83 28 60 10 sll %g1, 0x10, %g1
201dee8: b5 2e a0 18 sll %i2, 0x18, %i2
201deec: b4 16 80 01 or %i2, %g1, %i2
201def0: c2 0f 60 0b ldub [ %i5 + 0xb ], %g1
201def4: b4 16 80 01 or %i2, %g1, %i2
201def8: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
201defc: 83 28 60 08 sll %g1, 8, %g1
201df00: b4 16 80 01 or %i2, %g1, %i2
201df04: 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;
201df08: 40 00 41 4c call 202e438 <__muldi3>
201df0c: 92 10 00 1a mov %i2, %o1
201df10: b2 10 00 08 mov %o0, %i1
201df14: b0 10 00 09 mov %o1, %i0
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
201df18: 7f ff ff 53 call 201dc64 <rtems_rfs_fs_media_size>
201df1c: 90 10 00 1b mov %i3, %o0
201df20: 80 a6 40 08 cmp %i1, %o0
201df24: 38 80 00 08 bgu,a 201df44 <rtems_rfs_fs_open+0x2b8> <== NEVER TAKEN
201df28: 90 10 20 00 clr %o0 <== NOT EXECUTED
201df2c: 32 80 00 11 bne,a 201df70 <rtems_rfs_fs_open+0x2e4> <== NEVER TAKEN
201df30: c4 0f 60 24 ldub [ %i5 + 0x24 ], %g2 <== NOT EXECUTED
201df34: 80 a6 00 09 cmp %i0, %o1
201df38: 28 80 00 0e bleu,a 201df70 <rtems_rfs_fs_open+0x2e4> <== ALWAYS TAKEN
201df3c: c4 0f 60 24 ldub [ %i5 + 0x24 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201df40: 90 10 20 00 clr %o0 <== NOT EXECUTED
201df44: 7f ff d5 f1 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201df48: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201df4c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201df50: 22 80 00 29 be,a 201dff4 <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
201df54: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
201df58: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201df5c: 90 12 22 78 or %o0, 0x278, %o0 ! 2034678 <CSWTCH.2+0x1198><== NOT EXECUTED
201df60: 40 00 10 a1 call 20221e4 <puts> <== NOT EXECUTED
201df64: 01 00 00 00 nop <== NOT EXECUTED
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
201df68: 10 80 00 23 b 201dff4 <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
201df6c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
201df70: c2 0f 60 25 ldub [ %i5 + 0x25 ], %g1
201df74: 85 28 a0 18 sll %g2, 0x18, %g2
201df78: 83 28 60 10 sll %g1, 0x10, %g1
201df7c: 82 10 80 01 or %g2, %g1, %g1
201df80: c4 0f 60 27 ldub [ %i5 + 0x27 ], %g2
201df84: 82 10 40 02 or %g1, %g2, %g1
201df88: c4 0f 60 26 ldub [ %i5 + 0x26 ], %g2
201df8c: 85 28 a0 08 sll %g2, 8, %g2
201df90: 82 10 40 02 or %g1, %g2, %g1
201df94: 80 a0 60 38 cmp %g1, 0x38
201df98: 22 80 00 1b be,a 201e004 <rtems_rfs_fs_open+0x378> <== ALWAYS TAKEN
201df9c: c4 0f 60 10 ldub [ %i5 + 0x10 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201dfa0: 90 10 20 00 clr %o0 <== NOT EXECUTED
201dfa4: 7f ff d5 d9 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201dfa8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201dfac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201dfb0: 22 80 00 11 be,a 201dff4 <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
201dfb4: 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);
201dfb8: c2 0f 60 05 ldub [ %i5 + 5 ], %g1 <== NOT EXECUTED
201dfbc: d2 0f 60 04 ldub [ %i5 + 4 ], %o1 <== NOT EXECUTED
201dfc0: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
201dfc4: 93 2a 60 18 sll %o1, 0x18, %o1 <== NOT EXECUTED
201dfc8: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
201dfcc: c2 0f 60 07 ldub [ %i5 + 7 ], %g1 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
201dfd0: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
201dfd4: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
201dfd8: c2 0f 60 06 ldub [ %i5 + 6 ], %g1 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
201dfdc: 90 12 22 b8 or %o0, 0x2b8, %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
201dfe0: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
201dfe4: 94 10 20 00 clr %o2 <== NOT EXECUTED
201dfe8: 40 00 0f e7 call 2021f84 <printf> <== NOT EXECUTED
201dfec: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
201dff0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
201dff4: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
201dff8: 7f ff ff 08 call 201dc18 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201dffc: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
201e000: 30 80 00 b8 b,a 201e2e0 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
201e004: c2 0f 60 11 ldub [ %i5 + 0x11 ], %g1
201e008: 85 28 a0 18 sll %g2, 0x18, %g2
201e00c: 83 28 60 10 sll %g1, 0x10, %g1
201e010: 82 10 80 01 or %g2, %g1, %g1
201e014: c4 0f 60 13 ldub [ %i5 + 0x13 ], %g2
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
201e018: 91 36 a0 02 srl %i2, 2, %o0
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
201e01c: 82 10 40 02 or %g1, %g2, %g1
201e020: c4 0f 60 12 ldub [ %i5 + 0x12 ], %g2
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
201e024: 92 10 00 08 mov %o0, %o1
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
201e028: 85 28 a0 08 sll %g2, 8, %g2
201e02c: 82 10 40 02 or %g1, %g2, %g1
201e030: c2 26 e0 18 st %g1, [ %i3 + 0x18 ]
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
201e034: c4 0f 60 14 ldub [ %i5 + 0x14 ], %g2
201e038: c2 0f 60 15 ldub [ %i5 + 0x15 ], %g1
201e03c: 85 28 a0 18 sll %g2, 0x18, %g2
201e040: 83 28 60 10 sll %g1, 0x10, %g1
201e044: 82 10 80 01 or %g2, %g1, %g1
201e048: c4 0f 60 17 ldub [ %i5 + 0x17 ], %g2
201e04c: 82 10 40 02 or %g1, %g2, %g1
201e050: c4 0f 60 16 ldub [ %i5 + 0x16 ], %g2
201e054: 85 28 a0 08 sll %g2, 8, %g2
201e058: 82 10 40 02 or %g1, %g2, %g1
201e05c: c2 26 e0 1c st %g1, [ %i3 + 0x1c ]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
201e060: c2 0f 60 19 ldub [ %i5 + 0x19 ], %g1
201e064: f0 0f 60 18 ldub [ %i5 + 0x18 ], %i0
201e068: 83 28 60 10 sll %g1, 0x10, %g1
201e06c: b1 2e 20 18 sll %i0, 0x18, %i0
201e070: b0 16 00 01 or %i0, %g1, %i0
201e074: c2 0f 60 1b ldub [ %i5 + 0x1b ], %g1
201e078: b0 16 00 01 or %i0, %g1, %i0
201e07c: c2 0f 60 1a ldub [ %i5 + 0x1a ], %g1
201e080: 83 28 60 08 sll %g1, 8, %g1
201e084: b0 16 00 01 or %i0, %g1, %i0
201e088: f0 26 e0 24 st %i0, [ %i3 + 0x24 ]
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
201e08c: c2 0f 60 1d ldub [ %i5 + 0x1d ], %g1
201e090: f2 0f 60 1c ldub [ %i5 + 0x1c ], %i1
201e094: 83 28 60 10 sll %g1, 0x10, %g1
201e098: b3 2e 60 18 sll %i1, 0x18, %i1
201e09c: b2 16 40 01 or %i1, %g1, %i1
201e0a0: c2 0f 60 1f ldub [ %i5 + 0x1f ], %g1
201e0a4: b2 16 40 01 or %i1, %g1, %i1
201e0a8: c2 0f 60 1e ldub [ %i5 + 0x1e ], %g1
201e0ac: 83 28 60 08 sll %g1, 8, %g1
201e0b0: b2 16 40 01 or %i1, %g1, %i1
201e0b4: f2 26 e0 28 st %i1, [ %i3 + 0x28 ]
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
201e0b8: c2 0f 60 21 ldub [ %i5 + 0x21 ], %g1
201e0bc: c4 0f 60 20 ldub [ %i5 + 0x20 ], %g2
201e0c0: 83 28 60 10 sll %g1, 0x10, %g1
201e0c4: 85 28 a0 18 sll %g2, 0x18, %g2
201e0c8: 84 10 80 01 or %g2, %g1, %g2
201e0cc: c2 0f 60 23 ldub [ %i5 + 0x23 ], %g1
201e0d0: 84 10 80 01 or %g2, %g1, %g2
201e0d4: c2 0f 60 22 ldub [ %i5 + 0x22 ], %g1
fs->blocks_per_block =
201e0d8: d0 26 e0 34 st %o0, [ %i3 + 0x34 ]
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
201e0dc: 83 28 60 08 sll %g1, 8, %g1
201e0e0: ba 10 80 01 or %g2, %g1, %i5
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
201e0e4: 85 2a 20 02 sll %o0, 2, %g2
201e0e8: 84 00 80 08 add %g2, %o0, %g2
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
201e0ec: fa 26 e0 2c st %i5, [ %i3 + 0x2c ]
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
201e0f0: 7f ff 91 29 call 2002594 <.umul>
201e0f4: c4 26 e0 38 st %g2, [ %i3 + 0x38 ]
201e0f8: 83 2a 20 02 sll %o0, 2, %g1
201e0fc: 90 00 40 08 add %g1, %o0, %o0
fs->inodes = fs->group_count * fs->group_inodes;
201e100: 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 =
201e104: d0 26 e0 3c st %o0, [ %i3 + 0x3c ]
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
201e108: 7f ff 91 23 call 2002594 <.umul>
201e10c: 90 10 00 1d mov %i5, %o0
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
201e110: 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;
201e114: d0 26 e0 14 st %o0, [ %i3 + 0x14 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
201e118: 7f ff 91 59 call 200267c <.udiv>
201e11c: 90 10 00 1a mov %i2, %o0
201e120: d0 26 e0 30 st %o0, [ %i3 + 0x30 ]
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
201e124: b5 2e a0 03 sll %i2, 3, %i2
{
rtems_rfs_buffer_handle_close (fs, &handle);
201e128: 90 10 00 1b mov %i3, %o0
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
201e12c: 80 a6 40 1a cmp %i1, %i2
201e130: 08 80 00 0c bleu 201e160 <rtems_rfs_fs_open+0x4d4> <== ALWAYS TAKEN
201e134: 92 07 bf cc add %fp, -52, %o1
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
201e138: 7f ff fe b8 call 201dc18 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201e13c: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e140: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e144: 7f ff d5 71 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e148: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e14c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e150: 02 80 00 64 be 201e2e0 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
201e154: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
201e158: 10 80 00 2e b 201e210 <rtems_rfs_fs_open+0x584> <== NOT EXECUTED
201e15c: 90 12 23 00 or %o0, 0x300, %o0 ! 2034700 <CSWTCH.2+0x1220><== NOT EXECUTED
return EIO;
}
rtems_rfs_buffer_handle_close (fs, &handle);
201e160: 7f ff fe ae call 201dc18 <rtems_rfs_buffer_handle_close>
201e164: 01 00 00 00 nop
/*
* Change the block size to the value in the superblock.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
201e168: d2 06 e0 08 ld [ %i3 + 8 ], %o1
201e16c: 7f ff f5 e9 call 201b910 <rtems_rfs_buffer_setblksize>
201e170: 90 10 00 1b mov %i3, %o0
if (rc > 0)
201e174: ba 92 20 00 orcc %o0, 0, %i5
201e178: 04 80 00 13 ble 201e1c4 <rtems_rfs_fs_open+0x538> <== ALWAYS TAKEN
201e17c: 92 07 bf cc add %fp, -52, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
201e180: 7f ff fe a6 call 201dc18 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201e184: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e188: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e18c: 7f ff d5 5f call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e190: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e194: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e198: 22 80 00 50 be,a 201e2d8 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
201e19c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
201e1a0: 40 00 13 e5 call 2023134 <strerror> <== NOT EXECUTED
201e1a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e1a8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e1ac: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201e1b0: 90 12 23 48 or %o0, 0x348, %o0 ! 2034748 <CSWTCH.2+0x1268><== NOT EXECUTED
201e1b4: 40 00 0f 74 call 2021f84 <printf> <== NOT EXECUTED
201e1b8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
201e1bc: 10 80 00 47 b 201e2d8 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
201e1c0: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
201e1c4: d0 06 e0 24 ld [ %i3 + 0x24 ], %o0
201e1c8: 7f ff a6 87 call 2007be4 <calloc>
201e1cc: 92 10 20 50 mov 0x50, %o1
201e1d0: d0 26 e0 20 st %o0, [ %i3 + 0x20 ]
if (!fs->groups)
201e1d4: b2 10 20 00 clr %i1
201e1d8: 80 a2 20 00 cmp %o0, 0
201e1dc: 12 80 00 39 bne 201e2c0 <rtems_rfs_fs_open+0x634> <== ALWAYS TAKEN
201e1e0: b4 10 20 00 clr %i2
{
rtems_rfs_buffer_handle_close (fs, &handle);
201e1e4: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
201e1e8: 7f ff fe 8c call 201dc18 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201e1ec: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e1f0: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e1f4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e1f8: 7f ff d5 44 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e1fc: ba 10 20 0c mov 0xc, %i5 <== NOT EXECUTED
201e200: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e204: 02 80 00 37 be 201e2e0 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
201e208: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
201e20c: 90 12 23 90 or %o0, 0x390, %o0 ! 2034790 <CSWTCH.2+0x12b0><== NOT EXECUTED
201e210: 40 00 0f f5 call 20221e4 <puts> <== NOT EXECUTED
201e214: 01 00 00 00 nop <== NOT EXECUTED
201e218: 30 80 00 32 b,a 201e2e0 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
rtems_rfs_fs_block (fs, group, 0),
201e21c: 90 10 00 1a mov %i2, %o0
201e220: 7f ff 90 dd call 2002594 <.umul>
201e224: 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,
201e228: d8 06 e0 20 ld [ %i3 + 0x20 ], %o4
201e22c: d6 06 e0 2c ld [ %i3 + 0x2c ], %o3
rtems_rfs_fs_block (fs, group, 0),
201e230: 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,
201e234: 94 10 00 1d mov %i5, %o2
201e238: 98 03 00 19 add %o4, %i1, %o4
201e23c: 90 10 00 1b mov %i3, %o0
201e240: 7f ff cc b2 call 2011508 <rtems_rfs_group_open>
201e244: b2 06 60 50 add %i1, 0x50, %i1
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
201e248: 80 a2 20 00 cmp %o0, 0
201e24c: 04 80 00 1c ble 201e2bc <rtems_rfs_fs_open+0x630> <== ALWAYS TAKEN
201e250: ba 10 00 08 mov %o0, %i5
201e254: b0 10 20 00 clr %i0 <== NOT EXECUTED
201e258: 10 80 00 07 b 201e274 <rtems_rfs_fs_open+0x5e8> <== NOT EXECUTED
201e25c: b2 10 20 00 clr %i1 <== NOT EXECUTED
{
int g;
for (g = 0; g < group; g++)
rtems_rfs_group_close (fs, &fs->groups[g]);
201e260: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
201e264: 92 02 40 18 add %o1, %i0, %o1 <== NOT EXECUTED
201e268: 7f ff cd 26 call 2011700 <rtems_rfs_group_close> <== NOT EXECUTED
201e26c: b2 06 60 01 inc %i1 <== NOT EXECUTED
201e270: b0 06 20 50 add %i0, 0x50, %i0 <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
201e274: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
201e278: 26 bf ff fa bl,a 201e260 <rtems_rfs_fs_open+0x5d4> <== NOT EXECUTED
201e27c: d2 06 e0 20 ld [ %i3 + 0x20 ], %o1 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
rtems_rfs_buffer_handle_close (fs, &handle);
201e280: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
201e284: 7f ff fe 65 call 201dc18 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201e288: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e28c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e290: 7f ff d5 1e call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e294: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e298: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e29c: 22 80 00 0f be,a 201e2d8 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
201e2a0: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
201e2a4: 40 00 13 a4 call 2023134 <strerror> <== NOT EXECUTED
201e2a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e2ac: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e2b0: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201e2b4: 10 bf ff c0 b 201e1b4 <rtems_rfs_fs_open+0x528> <== NOT EXECUTED
201e2b8: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 20347c8 <CSWTCH.2+0x12e8><== NOT EXECUTED
/*
* Perform each phase of group initialisation at the same time. This way we
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
201e2bc: b4 06 a0 01 inc %i2
201e2c0: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
201e2c4: 80 a6 80 01 cmp %i2, %g1
201e2c8: 26 bf ff d5 bl,a 201e21c <rtems_rfs_fs_open+0x590>
201e2cc: fa 06 e0 28 ld [ %i3 + 0x28 ], %i5
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
201e2d0: 10 80 00 14 b 201e320 <rtems_rfs_fs_open+0x694>
201e2d4: d0 07 00 00 ld [ %i4 ], %o0
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
201e2d8: 22 80 00 12 be,a 201e320 <rtems_rfs_fs_open+0x694> <== NOT EXECUTED
201e2dc: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_close (*fs);
201e2e0: 7f ff f5 c7 call 201b9fc <rtems_rfs_buffer_close> <== NOT EXECUTED
201e2e4: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
201e2e8: 7f ff a7 3f call 2007fe4 <free> <== NOT EXECUTED
201e2ec: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e2f0: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e2f4: 7f ff d5 05 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e2f8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e2fc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e300: 02 bf fe b6 be 201ddd8 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
201e304: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
201e308: 40 00 13 8b call 2023134 <strerror> <== NOT EXECUTED
201e30c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e310: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e314: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e318: 10 bf fe ae b 201ddd0 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
201e31c: 90 12 20 08 or %o0, 8, %o0 ! 2034808 <CSWTCH.2+0x1328> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
201e320: 92 10 20 01 mov 1, %o1
201e324: 94 07 bf d8 add %fp, -40, %o2
201e328: 7f ff ce 6f call 2011ce4 <rtems_rfs_inode_open>
201e32c: 96 10 20 01 mov 1, %o3
if (rc > 0)
201e330: ba 92 20 00 orcc %o0, 0, %i5
201e334: 04 80 00 12 ble 201e37c <rtems_rfs_fs_open+0x6f0> <== ALWAYS TAKEN
201e338: d0 07 00 00 ld [ %i4 ], %o0
{
rtems_rfs_buffer_close (*fs);
201e33c: 7f ff f5 b0 call 201b9fc <rtems_rfs_buffer_close> <== NOT EXECUTED
201e340: 01 00 00 00 nop <== NOT EXECUTED
free (*fs);
201e344: 7f ff a7 28 call 2007fe4 <free> <== NOT EXECUTED
201e348: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e34c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e350: 7f ff d4 ee call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e354: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e358: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e35c: 02 bf fe 9f be 201ddd8 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
201e360: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
201e364: 40 00 13 74 call 2023134 <strerror> <== NOT EXECUTED
201e368: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e36c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e370: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e374: 10 bf fe 97 b 201ddd0 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
201e378: 90 12 20 38 or %o0, 0x38, %o0 ! 2034838 <CSWTCH.2+0x1358> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
201e37c: c2 02 00 00 ld [ %o0 ], %g1
201e380: 80 88 60 04 btst 4, %g1
201e384: 12 80 00 23 bne 201e410 <rtems_rfs_fs_open+0x784>
201e388: c4 07 bf e4 ld [ %fp + -28 ], %g2
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
201e38c: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
201e390: c4 08 a0 03 ldub [ %g2 + 3 ], %g2
201e394: 83 28 60 08 sll %g1, 8, %g1
201e398: 82 10 40 02 or %g1, %g2, %g1
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
201e39c: 05 3f ff c0 sethi %hi(0xffff0000), %g2
201e3a0: 87 28 60 10 sll %g1, 0x10, %g3
201e3a4: 80 a0 c0 02 cmp %g3, %g2
201e3a8: 02 80 00 07 be 201e3c4 <rtems_rfs_fs_open+0x738> <== NEVER TAKEN
201e3ac: 05 00 00 3c sethi %hi(0xf000), %g2
201e3b0: 82 08 40 02 and %g1, %g2, %g1
201e3b4: 05 00 00 10 sethi %hi(0x4000), %g2
201e3b8: 80 a0 40 02 cmp %g1, %g2
201e3bc: 02 80 00 15 be 201e410 <rtems_rfs_fs_open+0x784> <== ALWAYS TAKEN
201e3c0: 01 00 00 00 nop
{
rtems_rfs_inode_close (*fs, &inode);
201e3c4: 7f ff ce ba call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201e3c8: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
201e3cc: 7f ff f5 8c call 201b9fc <rtems_rfs_buffer_close> <== NOT EXECUTED
201e3d0: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
201e3d4: 7f ff a7 04 call 2007fe4 <free> <== NOT EXECUTED
201e3d8: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e3dc: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e3e0: 7f ff d4 ca call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e3e4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e3e8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e3ec: 02 80 00 04 be 201e3fc <rtems_rfs_fs_open+0x770> <== NOT EXECUTED
201e3f0: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
201e3f4: 40 00 0f 7c call 20221e4 <puts> <== NOT EXECUTED
201e3f8: 90 12 20 68 or %o0, 0x68, %o0 ! 2034868 <CSWTCH.2+0x1388> <== NOT EXECUTED
errno = EIO;
201e3fc: 40 00 09 89 call 2020a20 <__errno> <== NOT EXECUTED
201e400: 01 00 00 00 nop <== NOT EXECUTED
201e404: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
201e408: 10 bf fe 77 b 201dde4 <rtems_rfs_fs_open+0x158> <== NOT EXECUTED
201e40c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
201e410: 7f ff ce a7 call 2011eac <rtems_rfs_inode_close>
201e414: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
201e418: ba 92 20 00 orcc %o0, 0, %i5
201e41c: 04 80 00 12 ble 201e464 <rtems_rfs_fs_open+0x7d8> <== ALWAYS TAKEN
201e420: 01 00 00 00 nop
{
rtems_rfs_buffer_close (*fs);
201e424: 7f ff f5 76 call 201b9fc <rtems_rfs_buffer_close> <== NOT EXECUTED
201e428: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
201e42c: 7f ff a6 ee call 2007fe4 <free> <== NOT EXECUTED
201e430: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e434: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e438: 7f ff d4 b4 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e43c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e440: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e444: 02 bf fe 65 be 201ddd8 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
201e448: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
201e44c: 40 00 13 3a call 2023134 <strerror> <== NOT EXECUTED
201e450: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e454: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e458: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e45c: 10 bf fe 5d b 201ddd0 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
201e460: 90 12 20 98 or %o0, 0x98, %o0 ! 2034898 <CSWTCH.2+0x13b8> <== NOT EXECUTED
errno = rc;
return -1;
}
errno = 0;
201e464: 40 00 09 6f call 2020a20 <__errno>
201e468: b0 10 20 00 clr %i0
201e46c: c0 22 00 00 clr [ %o0 ]
return 0;
}
201e470: 81 c7 e0 08 ret
201e474: 81 e8 00 00 restore
0201dc40 <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)
{
201dc40: 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;
201dc44: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
201dc48: d6 06 20 04 ld [ %i0 + 4 ], %o3 <== NOT EXECUTED
201dc4c: 94 10 20 00 clr %o2 <== NOT EXECUTED
201dc50: 40 00 41 fa call 202e438 <__muldi3> <== NOT EXECUTED
201dc54: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
201dc58: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
201dc5c: 81 c7 e0 08 ret <== NOT EXECUTED
201dc60: 93 e8 00 09 restore %g0, %o1, %o1 <== NOT EXECUTED
02011790 <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)
{
2011790: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
2011794: 80 a6 a0 00 cmp %i2, 0
2011798: 02 80 00 05 be 20117ac <rtems_rfs_group_bitmap_alloc+0x1c>
201179c: ba 10 00 18 mov %i0, %i5
{
size = fs->group_inodes;
20117a0: e2 06 20 2c ld [ %i0 + 0x2c ], %l1
goal -= RTEMS_RFS_ROOT_INO;
20117a4: 10 80 00 03 b 20117b0 <rtems_rfs_group_bitmap_alloc+0x20>
20117a8: b2 06 7f ff add %i1, -1, %i1
}
else
size = fs->group_blocks;
20117ac: e2 06 20 28 ld [ %i0 + 0x28 ], %l1
group_start = goal / size;
20117b0: 92 10 00 11 mov %l1, %o1
20117b4: 7f ff c3 b2 call 200267c <.udiv>
20117b8: 90 10 00 19 mov %i1, %o0
bit = (rtems_rfs_bitmap_bit) (goal % size);
20117bc: 92 10 00 11 mov %l1, %o1
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
20117c0: a8 10 00 08 mov %o0, %l4
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
direction = 1;
20117c4: b8 10 20 01 mov 1, %i4
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
20117c8: 90 10 00 19 mov %i1, %o0
20117cc: 40 00 72 6f call 202e188 <.urem>
20117d0: a4 10 20 01 mov 1, %l2
offset = 0;
20117d4: a0 10 20 00 clr %l0
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
20117d8: d0 27 bf fc st %o0, [ %fp + -4 ]
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
20117dc: 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);
20117e0: 90 10 00 1c mov %i4, %o0
20117e4: 7f ff c3 6c call 2002594 <.umul>
20117e8: 92 10 00 10 mov %l0, %o1
if (offset)
20117ec: 80 a4 20 00 cmp %l0, 0
20117f0: 02 80 00 07 be 201180c <rtems_rfs_group_bitmap_alloc+0x7c>
20117f4: b2 05 00 08 add %l4, %o0, %i1
bit = direction > 0 ? 0 : size - 1;
20117f8: 80 a7 20 00 cmp %i4, 0
20117fc: 14 80 00 03 bg 2011808 <rtems_rfs_group_bitmap_alloc+0x78>
2011800: 82 10 20 00 clr %g1
2011804: 82 04 7f ff add %l1, -1, %g1
2011808: 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))
201180c: 80 a6 60 00 cmp %i1, 0
2011810: 06 80 00 07 bl 201182c <rtems_rfs_group_bitmap_alloc+0x9c>
2011814: 80 8c a0 ff btst 0xff, %l2
2011818: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
201181c: 80 a6 40 01 cmp %i1, %g1
2011820: 26 80 00 0a bl,a 2011848 <rtems_rfs_group_bitmap_alloc+0xb8>
2011824: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
{
if (!updown)
2011828: 80 8c a0 ff btst 0xff, %l2
201182c: 02 80 00 50 be 201196c <rtems_rfs_group_bitmap_alloc+0x1dc>
2011830: 80 a7 20 00 cmp %i4, 0
break;
direction = direction > 0 ? -1 : 1;
2011834: 24 80 00 03 ble,a 2011840 <rtems_rfs_group_bitmap_alloc+0xb0><== ALWAYS TAKEN
2011838: b8 10 20 01 mov 1, %i4
201183c: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
updown = false;
2011840: 10 bf ff e7 b 20117dc <rtems_rfs_group_bitmap_alloc+0x4c>
2011844: a4 10 20 00 clr %l2
2011848: a7 2e 60 04 sll %i1, 4, %l3
201184c: 85 2e 60 06 sll %i1, 6, %g2
continue;
}
if (inode)
2011850: 80 a6 a0 00 cmp %i2, 0
bitmap = &fs->groups[group].inode_bitmap;
2011854: a6 04 c0 02 add %l3, %g2, %l3
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
2011858: 02 80 00 04 be 2011868 <rtems_rfs_group_bitmap_alloc+0xd8>
201185c: a6 00 40 13 add %g1, %l3, %l3
bitmap = &fs->groups[group].inode_bitmap;
2011860: 10 80 00 03 b 201186c <rtems_rfs_group_bitmap_alloc+0xdc>
2011864: a6 04 e0 2c add %l3, 0x2c, %l3
else
bitmap = &fs->groups[group].block_bitmap;
2011868: a6 04 e0 08 add %l3, 8, %l3
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
201186c: d2 07 bf fc ld [ %fp + -4 ], %o1
2011870: 90 10 00 13 mov %l3, %o0
2011874: 94 07 bf fb add %fp, -5, %o2
2011878: 40 00 21 62 call 2019e00 <rtems_rfs_bitmap_map_alloc>
201187c: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
2011880: b0 92 20 00 orcc %o0, 0, %i0
2011884: 14 80 00 45 bg 2011998 <rtems_rfs_group_bitmap_alloc+0x208><== NEVER TAKEN
2011888: 01 00 00 00 nop
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
201188c: c2 07 40 00 ld [ %i5 ], %g1
2011890: 80 88 60 01 btst 1, %g1
2011894: 12 80 00 06 bne 20118ac <rtems_rfs_group_bitmap_alloc+0x11c><== NEVER TAKEN
2011898: c2 0f bf fb ldub [ %fp + -5 ], %g1
rtems_rfs_bitmap_release_buffer (fs, bitmap);
201189c: d2 04 c0 00 ld [ %l3 ], %o1
20118a0: 40 00 26 62 call 201b228 <rtems_rfs_buffer_handle_release>
20118a4: 90 10 00 1d mov %i5, %o0
if (allocated)
20118a8: c2 0f bf fb ldub [ %fp + -5 ], %g1
20118ac: 80 a0 60 00 cmp %g1, 0
20118b0: 02 80 00 27 be 201194c <rtems_rfs_group_bitmap_alloc+0x1bc>
20118b4: 80 8c a0 ff btst 0xff, %l2
{
if (inode)
20118b8: 80 a6 a0 00 cmp %i2, 0
20118bc: 02 80 00 09 be 20118e0 <rtems_rfs_group_bitmap_alloc+0x150>
20118c0: c2 07 bf fc ld [ %fp + -4 ], %g1
*result = rtems_rfs_group_inode (fs, group, bit);
20118c4: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
20118c8: b8 00 60 01 add %g1, 1, %i4
20118cc: 7f ff c3 32 call 2002594 <.umul>
20118d0: 90 10 00 19 mov %i1, %o0
20118d4: 90 07 00 08 add %i4, %o0, %o0
20118d8: 10 80 00 09 b 20118fc <rtems_rfs_group_bitmap_alloc+0x16c>
20118dc: d0 26 c0 00 st %o0, [ %i3 ]
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
20118e0: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
20118e4: 87 2e 60 04 sll %i1, 4, %g3
20118e8: b3 2e 60 06 sll %i1, 6, %i1
20118ec: b2 00 c0 19 add %g3, %i1, %i1
20118f0: c4 00 80 19 ld [ %g2 + %i1 ], %g2
20118f4: 82 00 40 02 add %g1, %g2, %g1
20118f8: c2 26 c0 00 st %g1, [ %i3 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
20118fc: 90 10 20 00 clr %o0
2011900: 13 00 00 80 sethi %hi(0x20000), %o1
2011904: 40 00 07 81 call 2013708 <rtems_rfs_trace>
2011908: b0 10 20 00 clr %i0
201190c: 80 8a 20 ff btst 0xff, %o0
2011910: 02 80 00 0d be 2011944 <rtems_rfs_group_bitmap_alloc+0x1b4><== ALWAYS TAKEN
2011914: 80 a6 a0 00 cmp %i2, 0
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
2011918: 22 80 00 05 be,a 201192c <rtems_rfs_group_bitmap_alloc+0x19c><== NOT EXECUTED
201191c: 13 00 80 ca sethi %hi(0x2032800), %o1 <== NOT EXECUTED
2011920: 13 00 80 ca sethi %hi(0x2032800), %o1 <== NOT EXECUTED
2011924: 10 80 00 03 b 2011930 <rtems_rfs_group_bitmap_alloc+0x1a0><== NOT EXECUTED
2011928: 92 12 62 48 or %o1, 0x248, %o1 ! 2032a48 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
201192c: 92 12 62 50 or %o1, 0x250, %o1 <== NOT EXECUTED
2011930: d4 06 c0 00 ld [ %i3 ], %o2 <== NOT EXECUTED
2011934: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
2011938: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (inode)
*result = rtems_rfs_group_inode (fs, group, bit);
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
201193c: 40 00 41 92 call 2021f84 <printf> <== NOT EXECUTED
2011940: 90 12 22 58 or %o0, 0x258, %o0 <== NOT EXECUTED
2011944: 81 c7 e0 08 ret
2011948: 81 e8 00 00 restore
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
201194c: 22 bf ff a4 be,a 20117dc <rtems_rfs_group_bitmap_alloc+0x4c><== NEVER TAKEN
2011950: a0 04 20 01 inc %l0 <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
2011954: 80 a7 20 00 cmp %i4, 0
2011958: 24 80 00 03 ble,a 2011964 <rtems_rfs_group_bitmap_alloc+0x1d4><== NEVER TAKEN
201195c: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
2011960: b8 10 3f ff mov -1, %i4
offset++;
2011964: 10 bf ff 9e b 20117dc <rtems_rfs_group_bitmap_alloc+0x4c>
2011968: a0 04 20 01 inc %l0
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
201196c: 90 10 20 00 clr %o0
2011970: 40 00 07 66 call 2013708 <rtems_rfs_trace>
2011974: 13 00 00 80 sethi %hi(0x20000), %o1
2011978: 80 8a 20 ff btst 0xff, %o0
201197c: 12 80 00 04 bne 201198c <rtems_rfs_group_bitmap_alloc+0x1fc><== NEVER TAKEN
2011980: 11 00 80 ca sethi %hi(0x2032800), %o0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
2011984: 81 c7 e0 08 ret
2011988: 91 e8 20 1c restore %g0, 0x1c, %o0
offset++;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
201198c: 40 00 42 16 call 20221e4 <puts> <== NOT EXECUTED
2011990: 90 12 22 90 or %o0, 0x290, %o0 <== NOT EXECUTED
return ENOSPC;
2011994: b0 10 20 1c mov 0x1c, %i0 <== NOT EXECUTED
}
2011998: 81 c7 e0 08 ret <== NOT EXECUTED
201199c: 81 e8 00 00 restore <== NOT EXECUTED
020119a0 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
20119a0: 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))
20119a4: 90 10 20 00 clr %o0
20119a8: 13 00 00 80 sethi %hi(0x20000), %o1
20119ac: 40 00 07 57 call 2013708 <rtems_rfs_trace>
20119b0: ba 10 00 18 mov %i0, %i5
20119b4: 80 8a 20 ff btst 0xff, %o0
20119b8: 02 80 00 0d be 20119ec <rtems_rfs_group_bitmap_free+0x4c> <== ALWAYS TAKEN
20119bc: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
20119c0: 22 80 00 05 be,a 20119d4 <rtems_rfs_group_bitmap_free+0x34><== NOT EXECUTED
20119c4: 13 00 80 ca sethi %hi(0x2032800), %o1 <== NOT EXECUTED
20119c8: 13 00 80 ca sethi %hi(0x2032800), %o1 <== NOT EXECUTED
20119cc: 10 80 00 03 b 20119d8 <rtems_rfs_group_bitmap_free+0x38> <== NOT EXECUTED
20119d0: 92 12 62 48 or %o1, 0x248, %o1 ! 2032a48 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
20119d4: 92 12 62 50 or %o1, 0x250, %o1 <== NOT EXECUTED
20119d8: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
20119dc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
20119e0: 40 00 41 69 call 2021f84 <printf> <== NOT EXECUTED
20119e4: 90 12 22 c8 or %o0, 0x2c8, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
20119e8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
20119ec: 02 80 00 04 be 20119fc <rtems_rfs_group_bitmap_free+0x5c>
20119f0: b4 06 bf ff add %i2, -1, %i2
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
20119f4: 10 80 00 03 b 2011a00 <rtems_rfs_group_bitmap_free+0x60>
20119f8: f6 07 60 2c ld [ %i5 + 0x2c ], %i3
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
20119fc: f6 07 60 28 ld [ %i5 + 0x28 ], %i3
}
group = no / size;
2011a00: 92 10 00 1b mov %i3, %o1
2011a04: 7f ff c3 1e call 200267c <.udiv>
2011a08: 90 10 00 1a mov %i2, %o0
bit = (rtems_rfs_bitmap_bit) (no % size);
2011a0c: 92 10 00 1b mov %i3, %o1
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
2011a10: b0 10 00 08 mov %o0, %i0
bit = (rtems_rfs_bitmap_bit) (no % size);
2011a14: 40 00 71 dd call 202e188 <.urem>
2011a18: 90 10 00 1a mov %i2, %o0
2011a1c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
2011a20: b9 2e 20 04 sll %i0, 4, %i4
2011a24: 92 10 00 08 mov %o0, %o1
2011a28: b1 2e 20 06 sll %i0, 6, %i0
if (inode)
2011a2c: 80 a6 60 00 cmp %i1, 0
bitmap = &fs->groups[group].inode_bitmap;
2011a30: b8 07 00 18 add %i4, %i0, %i4
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
2011a34: 02 80 00 04 be 2011a44 <rtems_rfs_group_bitmap_free+0xa4>
2011a38: b8 00 40 1c add %g1, %i4, %i4
bitmap = &fs->groups[group].inode_bitmap;
2011a3c: 10 80 00 03 b 2011a48 <rtems_rfs_group_bitmap_free+0xa8>
2011a40: b8 07 20 2c add %i4, 0x2c, %i4
else
bitmap = &fs->groups[group].block_bitmap;
2011a44: b8 07 20 08 add %i4, 8, %i4
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
2011a48: 40 00 20 62 call 2019bd0 <rtems_rfs_bitmap_map_clear>
2011a4c: 90 10 00 1c mov %i4, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2011a50: 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);
2011a54: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2011a58: 40 00 25 f4 call 201b228 <rtems_rfs_buffer_handle_release>
2011a5c: 90 10 00 1d mov %i5, %o0
return rc;
}
2011a60: 81 c7 e0 08 ret
2011a64: 81 e8 00 00 restore
02011a68 <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)
{
2011a68: 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))
2011a6c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2011a70: 13 00 00 80 sethi %hi(0x20000), %o1 <== NOT EXECUTED
2011a74: 40 00 07 25 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
2011a78: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
2011a7c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2011a80: 02 80 00 0d be 2011ab4 <rtems_rfs_group_bitmap_test+0x4c> <== NOT EXECUTED
2011a84: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
2011a88: 22 80 00 05 be,a 2011a9c <rtems_rfs_group_bitmap_test+0x34><== NOT EXECUTED
2011a8c: 13 00 80 ca sethi %hi(0x2032800), %o1 <== NOT EXECUTED
2011a90: 13 00 80 ca sethi %hi(0x2032800), %o1 <== NOT EXECUTED
2011a94: 10 80 00 03 b 2011aa0 <rtems_rfs_group_bitmap_test+0x38> <== NOT EXECUTED
2011a98: 92 12 62 48 or %o1, 0x248, %o1 ! 2032a48 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
2011a9c: 92 12 62 50 or %o1, 0x250, %o1 <== NOT EXECUTED
2011aa0: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011aa4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2011aa8: 40 00 41 37 call 2021f84 <printf> <== NOT EXECUTED
2011aac: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
2011ab0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2011ab4: 22 80 00 0b be,a 2011ae0 <rtems_rfs_group_bitmap_test+0x78><== NOT EXECUTED
2011ab8: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
2011abc: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2011ac0: 04 80 00 25 ble 2011b54 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
2011ac4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
2011ac8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
2011acc: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
2011ad0: 18 80 00 21 bgu 2011b54 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
2011ad4: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
2011ad8: 10 80 00 06 b 2011af0 <rtems_rfs_group_bitmap_test+0x88> <== NOT EXECUTED
2011adc: f0 07 60 2c ld [ %i5 + 0x2c ], %i0 <== NOT EXECUTED
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
2011ae0: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
2011ae4: 1a 80 00 1c bcc 2011b54 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
2011ae8: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
2011aec: f0 07 60 28 ld [ %i5 + 0x28 ], %i0 <== NOT EXECUTED
}
group = no / size;
2011af0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2011af4: 7f ff c2 e2 call 200267c <.udiv> <== NOT EXECUTED
2011af8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
2011afc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
2011b00: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
2011b04: 40 00 71 a1 call 202e188 <.urem> <== NOT EXECUTED
2011b08: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2011b0c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED
2011b10: b9 2c 20 04 sll %l0, 4, %i4 <== NOT EXECUTED
2011b14: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2011b18: a1 2c 20 06 sll %l0, 6, %l0 <== NOT EXECUTED
if (inode)
2011b1c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
2011b20: b8 07 00 10 add %i4, %l0, %i4 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
2011b24: 02 80 00 04 be 2011b34 <rtems_rfs_group_bitmap_test+0xcc> <== NOT EXECUTED
2011b28: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
2011b2c: 10 80 00 03 b 2011b38 <rtems_rfs_group_bitmap_test+0xd0> <== NOT EXECUTED
2011b30: b8 07 20 2c add %i4, 0x2c, %i4 <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
2011b34: b8 07 20 08 add %i4, 8, %i4 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
2011b38: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2011b3c: 40 00 20 48 call 2019c5c <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
2011b40: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2011b44: 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);
2011b48: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2011b4c: 40 00 25 b7 call 201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2011b50: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
}
2011b54: 81 c7 e0 08 ret <== NOT EXECUTED
2011b58: 81 e8 00 00 restore <== NOT EXECUTED
02011700 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
2011700: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
2011704: 90 10 20 00 clr %o0
2011708: 13 00 00 40 sethi %hi(0x10000), %o1
201170c: 40 00 07 ff call 2013708 <rtems_rfs_trace>
2011710: ba 10 00 18 mov %i0, %i5
2011714: 80 8a 20 ff btst 0xff, %o0
2011718: 02 80 00 06 be 2011730 <rtems_rfs_group_close+0x30> <== ALWAYS TAKEN
201171c: 01 00 00 00 nop
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
2011720: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2011724: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011728: 40 00 42 17 call 2021f84 <printf> <== NOT EXECUTED
201172c: 90 12 22 20 or %o0, 0x220, %o0 ! 2032a20 <_CPU_Trap_slot_template+0x9e8><== NOT EXECUTED
/*
* We need to close as much as possible and also return any error if one
* occurs but this may result in one even more important error being lost but
* we cannot OR the errors together so this is a reasonable compromise.
*/
rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
2011730: 40 00 22 3f call 201a02c <rtems_rfs_bitmap_close>
2011734: 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);
2011738: 92 06 60 44 add %i1, 0x44, %o1
201173c: b8 10 00 08 mov %o0, %i4
2011740: 40 00 26 ba call 201b228 <rtems_rfs_buffer_handle_release>
2011744: 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);
2011748: 90 06 60 08 add %i1, 8, %o0
handle->dirty = false;
201174c: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
2011750: c0 26 60 48 clr [ %i1 + 0x48 ]
2011754: 40 00 22 36 call 201a02c <rtems_rfs_bitmap_close>
2011758: c0 26 60 4c clr [ %i1 + 0x4c ]
if (rc > 0)
201175c: b0 92 20 00 orcc %o0, 0, %i0
2011760: 14 80 00 05 bg 2011774 <rtems_rfs_group_close+0x74> <== NEVER TAKEN
2011764: 90 10 00 1d mov %i5, %o0
2011768: b0 38 00 1c xnor %g0, %i4, %i0
201176c: b1 3e 20 1f sra %i0, 0x1f, %i0
2011770: b0 0f 00 18 and %i4, %i0, %i0
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
2011774: 40 00 26 ad call 201b228 <rtems_rfs_buffer_handle_release>
2011778: 92 06 60 20 add %i1, 0x20, %o1
handle->dirty = false;
201177c: c0 2e 60 20 clrb [ %i1 + 0x20 ]
handle->bnum = 0;
2011780: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->buffer = NULL;
2011784: 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;
}
2011788: 81 c7 e0 08 ret
201178c: 81 e8 00 00 restore
02011508 <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)
{
2011508: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
201150c: c2 06 20 04 ld [ %i0 + 4 ], %g1
2011510: 80 a6 40 01 cmp %i1, %g1
2011514: 0a 80 00 10 bcs 2011554 <rtems_rfs_group_open+0x4c> <== ALWAYS TAKEN
2011518: 84 06 80 19 add %i2, %i1, %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
201151c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2011520: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
2011524: 40 00 08 79 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
2011528: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
201152c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2011530: 22 80 00 72 be,a 20116f8 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
2011534: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
2011538: 40 00 46 ff call 2023134 <strerror> <== NOT EXECUTED
201153c: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
2011540: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
2011544: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011548: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
201154c: 10 80 00 36 b 2011624 <rtems_rfs_group_open+0x11c> <== NOT EXECUTED
2011550: 90 12 21 28 or %o0, 0x128, %o0 ! 2032928 <_CPU_Trap_slot_template+0x8f0><== NOT EXECUTED
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
2011554: 80 a0 80 01 cmp %g2, %g1
2011558: 3a 80 00 02 bcc,a 2011560 <rtems_rfs_group_open+0x58> <== ALWAYS TAKEN
201155c: b4 20 40 19 sub %g1, %i1, %i2
2011560: 80 a6 80 1b cmp %i2, %i3
2011564: 08 80 00 03 bleu 2011570 <rtems_rfs_group_open+0x68> <== NEVER TAKEN
2011568: a0 10 00 1a mov %i2, %l0
201156c: a0 10 00 1b mov %i3, %l0
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
2011570: 90 10 20 00 clr %o0
2011574: 40 00 08 65 call 2013708 <rtems_rfs_trace>
2011578: 13 00 00 20 sethi %hi(0x8000), %o1
201157c: 80 8a 20 ff btst 0xff, %o0
2011580: 22 80 00 09 be,a 20115a4 <rtems_rfs_group_open+0x9c> <== ALWAYS TAKEN
2011584: f2 27 00 00 st %i1, [ %i4 ]
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
2011588: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
201158c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2011590: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED
2011594: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2011598: 40 00 42 7b call 2021f84 <printf> <== NOT EXECUTED
201159c: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
base, size, inodes);
group->base = base;
20115a0: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
group->size = size;
20115a4: 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;
20115a8: c0 2f 20 20 clrb [ %i4 + 0x20 ]
handle->bnum = 0;
20115ac: c0 27 20 24 clr [ %i4 + 0x24 ]
handle->buffer = NULL;
20115b0: 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,
20115b4: a2 07 20 08 add %i4, 8, %l1
20115b8: b6 07 20 20 add %i4, 0x20, %i3
20115bc: 90 10 00 11 mov %l1, %o0
20115c0: 92 10 00 18 mov %i0, %o1
20115c4: 94 10 00 1b mov %i3, %o2
20115c8: 96 10 00 1a mov %i2, %o3
20115cc: 40 00 22 87 call 2019fe8 <rtems_rfs_bitmap_open>
20115d0: 98 10 00 19 mov %i1, %o4
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
20115d4: ba 92 20 00 orcc %o0, 0, %i5
20115d8: 04 80 00 16 ble 2011630 <rtems_rfs_group_open+0x128> <== ALWAYS TAKEN
20115dc: 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);
20115e0: 40 00 27 12 call 201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
20115e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
20115e8: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
20115ec: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
20115f0: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
20115f4: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
20115f8: 40 00 08 44 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
20115fc: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
2011600: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2011604: 22 80 00 3d be,a 20116f8 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
2011608: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
201160c: 40 00 46 ca call 2023134 <strerror> <== NOT EXECUTED
2011610: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2011614: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011618: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
201161c: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 20329a0 <_CPU_Trap_slot_template+0x968><== NOT EXECUTED
2011620: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2011624: 40 00 42 58 call 2021f84 <printf> <== NOT EXECUTED
2011628: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
201162c: 30 80 00 33 b,a 20116f8 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
2011630: 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;
2011634: c0 2f 20 44 clrb [ %i4 + 0x44 ]
handle->bnum = 0;
2011638: c0 27 20 48 clr [ %i4 + 0x48 ]
handle->buffer = NULL;
201163c: c0 27 20 4c clr [ %i4 + 0x4c ]
2011640: b4 07 20 44 add %i4, 0x44, %i2
2011644: 90 07 20 2c add %i4, 0x2c, %o0
2011648: 92 10 00 18 mov %i0, %o1
201164c: 94 10 00 1a mov %i2, %o2
2011650: 96 10 00 10 mov %l0, %o3
2011654: 40 00 22 65 call 2019fe8 <rtems_rfs_bitmap_open>
2011658: 98 03 20 01 inc %o4
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
201165c: ba 92 20 00 orcc %o0, 0, %i5
2011660: 04 80 00 1b ble 20116cc <rtems_rfs_group_open+0x1c4> <== ALWAYS TAKEN
2011664: 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);
2011668: 40 00 26 f0 call 201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201166c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
rtems_rfs_bitmap_close (&group->block_bitmap);
2011670: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
handle->dirty = false;
2011674: c0 2f 20 44 clrb [ %i4 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
2011678: c0 27 20 48 clr [ %i4 + 0x48 ] <== NOT EXECUTED
201167c: 40 00 22 6c call 201a02c <rtems_rfs_bitmap_close> <== NOT EXECUTED
2011680: 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);
2011684: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2011688: 40 00 26 e8 call 201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201168c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
2011690: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
2011694: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
2011698: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
201169c: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
20116a0: 40 00 08 1a call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
20116a4: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
20116a8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20116ac: 22 80 00 13 be,a 20116f8 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
20116b0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
20116b4: 40 00 46 a0 call 2023134 <strerror> <== NOT EXECUTED
20116b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20116bc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20116c0: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
20116c4: 10 bf ff d7 b 2011620 <rtems_rfs_group_open+0x118> <== NOT EXECUTED
20116c8: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 20329e0 <_CPU_Trap_slot_template+0x9a8><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
20116cc: c2 06 00 00 ld [ %i0 ], %g1
20116d0: 80 88 60 01 btst 1, %g1
20116d4: 12 80 00 08 bne 20116f4 <rtems_rfs_group_open+0x1ec> <== NEVER TAKEN
20116d8: ba 10 20 00 clr %i5
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
20116dc: d2 07 20 08 ld [ %i4 + 8 ], %o1
20116e0: 40 00 26 d2 call 201b228 <rtems_rfs_buffer_handle_release>
20116e4: 90 10 00 18 mov %i0, %o0
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
20116e8: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
20116ec: 40 00 26 cf call 201b228 <rtems_rfs_buffer_handle_release>
20116f0: 90 10 00 18 mov %i0, %o0
}
return 0;
}
20116f4: b0 10 00 1d mov %i5, %i0
20116f8: 81 c7 e0 08 ret
20116fc: 81 e8 00 00 restore
02011b5c <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
2011b5c: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED
*inodes = 0;
2011b60: c0 22 80 00 clr [ %o2 ] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
2011b64: 86 10 20 00 clr %g3 <== NOT EXECUTED
2011b68: 10 80 00 11 b 2011bac <rtems_rfs_group_usage+0x50> <== NOT EXECUTED
2011b6c: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
2011b70: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
2011b74: 84 00 a0 01 inc %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
2011b78: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
2011b7c: d8 00 60 14 ld [ %g1 + 0x14 ], %o4 <== NOT EXECUTED
2011b80: da 00 60 18 ld [ %g1 + 0x18 ], %o5 <== NOT EXECUTED
2011b84: 86 00 e0 50 add %g3, 0x50, %g3 <== NOT EXECUTED
2011b88: 9a 23 00 0d sub %o4, %o5, %o5 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
2011b8c: 88 01 00 0d add %g4, %o5, %g4 <== NOT EXECUTED
2011b90: c8 22 40 00 st %g4, [ %o1 ] <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
2011b94: c8 00 60 38 ld [ %g1 + 0x38 ], %g4 <== NOT EXECUTED
2011b98: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED
2011b9c: 82 21 00 01 sub %g4, %g1, %g1 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
2011ba0: c8 02 80 00 ld [ %o2 ], %g4 <== NOT EXECUTED
2011ba4: 82 01 00 01 add %g4, %g1, %g1 <== NOT EXECUTED
2011ba8: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
2011bac: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED
2011bb0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2011bb4: 06 bf ff ef bl 2011b70 <rtems_rfs_group_usage+0x14> <== NOT EXECUTED
2011bb8: c8 02 40 00 ld [ %o1 ], %g4 <== NOT EXECUTED
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
rtems_rfs_bitmap_map_free (&group->inode_bitmap);
}
if (*blocks > rtems_rfs_fs_blocks (fs))
2011bbc: c4 02 20 04 ld [ %o0 + 4 ], %g2 <== NOT EXECUTED
2011bc0: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED
2011bc4: 08 80 00 03 bleu 2011bd0 <rtems_rfs_group_usage+0x74> <== NOT EXECUTED
2011bc8: 82 10 00 04 mov %g4, %g1 <== NOT EXECUTED
2011bcc: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
2011bd0: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
2011bd4: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 <== NOT EXECUTED
2011bd8: c2 02 80 00 ld [ %o2 ], %g1 <== NOT EXECUTED
2011bdc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2011be0: 38 80 00 02 bgu,a 2011be8 <rtems_rfs_group_usage+0x8c> <== NOT EXECUTED
2011be4: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
2011be8: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
2011bec: 81 c3 e0 08 retl <== NOT EXECUTED
2011bf0: 90 10 20 00 clr %o0 <== NOT EXECUTED
02011eac <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
2011eac: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
2011eb0: 90 10 20 00 clr %o0
2011eb4: 40 00 06 15 call 2013708 <rtems_rfs_trace>
2011eb8: 13 00 02 00 sethi %hi(0x80000), %o1
2011ebc: 80 8a 20 ff btst 0xff, %o0
2011ec0: 22 80 00 07 be,a 2011edc <rtems_rfs_inode_close+0x30> <== ALWAYS TAKEN
2011ec4: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
2011ec8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2011ecc: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011ed0: 40 00 40 2d call 2021f84 <printf> <== NOT EXECUTED
2011ed4: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 2032bc8 <_CPU_Trap_slot_template+0xb90><== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
2011ed8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2011edc: 92 10 00 19 mov %i1, %o1
2011ee0: 7f ff ff b7 call 2011dbc <rtems_rfs_inode_unload>
2011ee4: 94 10 20 01 mov 1, %o2
if ((rc == 0) && (handle->loads > 0))
2011ee8: b0 92 20 00 orcc %o0, 0, %i0
2011eec: 32 80 00 11 bne,a 2011f30 <rtems_rfs_inode_close+0x84> <== NEVER TAKEN
2011ef0: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
2011ef4: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2011ef8: 80 a0 60 00 cmp %g1, 0
2011efc: 04 80 00 0c ble 2011f2c <rtems_rfs_inode_close+0x80> <== ALWAYS TAKEN
2011f00: 13 00 02 00 sethi %hi(0x80000), %o1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
2011f04: 90 10 20 00 clr %o0 <== NOT EXECUTED
2011f08: 40 00 06 00 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
2011f0c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2011f10: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2011f14: 22 80 00 07 be,a 2011f30 <rtems_rfs_inode_close+0x84> <== NOT EXECUTED
2011f18: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
2011f1c: d2 06 60 24 ld [ %i1 + 0x24 ], %o1 <== NOT EXECUTED
2011f20: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011f24: 40 00 40 18 call 2021f84 <printf> <== NOT EXECUTED
2011f28: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 2032bf0 <_CPU_Trap_slot_template+0xbb8><== NOT EXECUTED
handle->loads);
rc = EIO;
}
handle->ino = 0;
2011f2c: c0 26 60 08 clr [ %i1 + 8 ]
return rc;
}
2011f30: 81 c7 e0 08 ret
2011f34: 81 e8 00 00 restore
02012200 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
2012200: 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))
2012204: 90 10 20 00 clr %o0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
2012208: e2 07 a0 64 ld [ %fp + 0x64 ], %l1
201220c: e8 17 a0 5e lduh [ %fp + 0x5e ], %l4
2012210: e6 17 a0 62 lduh [ %fp + 0x62 ], %l3
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
2012214: 40 00 05 3d call 2013708 <rtems_rfs_trace>
2012218: 13 00 10 00 sethi %hi(0x400000), %o1
201221c: 80 8a 20 ff btst 0xff, %o0
2012220: 02 80 00 36 be 20122f8 <rtems_rfs_inode_create+0xf8> <== ALWAYS TAKEN
2012224: a4 0f 30 00 and %i4, -4096, %l2
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
2012228: 82 0f 30 00 and %i4, -4096, %g1 <== NOT EXECUTED
201222c: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
2012230: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2012234: 02 80 00 11 be 2012278 <rtems_rfs_inode_create+0x78> <== NOT EXECUTED
2012238: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
201223c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2012240: 02 80 00 11 be 2012284 <rtems_rfs_inode_create+0x84> <== NOT EXECUTED
2012244: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
2012248: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201224c: 02 80 00 11 be 2012290 <rtems_rfs_inode_create+0x90> <== NOT EXECUTED
2012250: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
2012254: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2012258: 02 80 00 11 be 201229c <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
201225c: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
2012260: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2012264: 22 80 00 11 be,a 20122a8 <rtems_rfs_inode_create+0xa8> <== NOT EXECUTED
2012268: 21 00 80 cb sethi %hi(0x2032c00), %l0 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
201226c: 21 00 80 cb sethi %hi(0x2032c00), %l0 <== NOT EXECUTED
2012270: 10 80 00 0f b 20122ac <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
2012274: a0 14 20 68 or %l0, 0x68, %l0 ! 2032c68 <_CPU_Trap_slot_template+0xc30><== NOT EXECUTED
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
2012278: 21 00 80 cb sethi %hi(0x2032c00), %l0 <== NOT EXECUTED
201227c: 10 80 00 0c b 20122ac <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
2012280: a0 14 20 50 or %l0, 0x50, %l0 ! 2032c50 <_CPU_Trap_slot_template+0xc18><== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
2012284: 21 00 80 cb sethi %hi(0x2032c00), %l0 <== NOT EXECUTED
2012288: 10 80 00 09 b 20122ac <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
201228c: a0 14 20 58 or %l0, 0x58, %l0 ! 2032c58 <_CPU_Trap_slot_template+0xc20><== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
2012290: 21 00 80 ca sethi %hi(0x2032800), %l0 <== NOT EXECUTED
2012294: 10 80 00 06 b 20122ac <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
2012298: a0 14 22 50 or %l0, 0x250, %l0 ! 2032a50 <_CPU_Trap_slot_template+0xa18><== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
201229c: 21 00 80 cb sethi %hi(0x2032c00), %l0 <== NOT EXECUTED
20122a0: 10 80 00 03 b 20122ac <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
20122a4: a0 14 20 60 or %l0, 0x60, %l0 ! 2032c60 <_CPU_Trap_slot_template+0xc28><== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
20122a8: a0 14 20 70 or %l0, 0x70, %l0 <== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
20122ac: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
20122b0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20122b4: 90 12 20 78 or %o0, 0x78, %o0 <== NOT EXECUTED
20122b8: 40 00 3f 33 call 2021f84 <printf> <== NOT EXECUTED
20122bc: a4 10 00 1a mov %i2, %l2 <== NOT EXECUTED
for (c = 0; c < length; c++)
20122c0: 10 80 00 04 b 20122d0 <rtems_rfs_inode_create+0xd0> <== NOT EXECUTED
20122c4: aa 06 80 1b add %i2, %i3, %l5 <== NOT EXECUTED
printf ("%c", name[c]);
20122c8: 40 00 3f 99 call 202212c <putchar> <== NOT EXECUTED
20122cc: a4 04 a0 01 inc %l2 <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
20122d0: 80 a4 80 15 cmp %l2, %l5 <== NOT EXECUTED
20122d4: 32 bf ff fd bne,a 20122c8 <rtems_rfs_inode_create+0xc8> <== NOT EXECUTED
20122d8: d0 4c 80 00 ldsb [ %l2 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
20122dc: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
20122e0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
20122e4: 90 12 20 a8 or %o0, 0xa8, %o0 <== NOT EXECUTED
20122e8: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
20122ec: 40 00 3f 26 call 2021f84 <printf> <== NOT EXECUTED
20122f0: 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)
20122f4: a4 0f 30 00 and %i4, -4096, %l2 <== NOT EXECUTED
20122f8: 05 00 00 18 sethi %hi(0x6000), %g2
20122fc: 80 a4 80 02 cmp %l2, %g2
2012300: 02 80 00 11 be 2012344 <rtems_rfs_inode_create+0x144> <== NEVER TAKEN
2012304: 82 10 00 12 mov %l2, %g1
2012308: 80 a4 80 02 cmp %l2, %g2
201230c: 18 80 00 08 bgu 201232c <rtems_rfs_inode_create+0x12c>
2012310: 05 00 00 20 sethi %hi(0x8000), %g2
2012314: 05 00 00 08 sethi %hi(0x2000), %g2
2012318: 80 a4 80 02 cmp %l2, %g2
201231c: 02 80 00 0a be 2012344 <rtems_rfs_inode_create+0x144> <== NEVER TAKEN
2012320: 05 00 00 10 sethi %hi(0x4000), %g2
2012324: 10 80 00 06 b 201233c <rtems_rfs_inode_create+0x13c>
2012328: 80 a0 40 02 cmp %g1, %g2
201232c: 80 a4 80 02 cmp %l2, %g2
2012330: 02 80 00 05 be 2012344 <rtems_rfs_inode_create+0x144>
2012334: 05 00 00 28 sethi %hi(0xa000), %g2
2012338: 80 a0 40 02 cmp %g1, %g2
201233c: 12 80 00 81 bne 2012540 <rtems_rfs_inode_create+0x340> <== NEVER TAKEN
2012340: a0 10 20 16 mov 0x16, %l0
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
2012344: 90 10 00 18 mov %i0, %o0
2012348: 92 10 00 19 mov %i1, %o1
201234c: 7f ff fe 2a call 2011bf4 <rtems_rfs_inode_alloc>
2012350: 94 10 00 11 mov %l1, %o2
if (rc > 0)
2012354: a0 92 20 00 orcc %o0, 0, %l0
2012358: 34 80 00 7b bg,a 2012544 <rtems_rfs_inode_create+0x344>
201235c: b0 10 00 10 mov %l0, %i0
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
2012360: d2 04 40 00 ld [ %l1 ], %o1
2012364: 90 10 00 18 mov %i0, %o0
2012368: 94 07 bf d8 add %fp, -40, %o2
201236c: 7f ff fe 5e call 2011ce4 <rtems_rfs_inode_open>
2012370: 96 10 20 01 mov 1, %o3
if (rc > 0)
2012374: a0 92 20 00 orcc %o0, 0, %l0
2012378: 04 80 00 04 ble 2012388 <rtems_rfs_inode_create+0x188> <== ALWAYS TAKEN
201237c: 90 07 bf d8 add %fp, -40, %o0
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
2012380: 10 80 00 6c b 2012530 <rtems_rfs_inode_create+0x330> <== NOT EXECUTED
2012384: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
2012388: 92 10 00 1d mov %i5, %o1
201238c: 94 10 00 1c mov %i4, %o2
2012390: 96 10 00 14 mov %l4, %o3
2012394: 7f ff ff 47 call 20120b0 <rtems_rfs_inode_initialise>
2012398: 98 10 00 13 mov %l3, %o4
if (rc > 0)
201239c: a0 92 20 00 orcc %o0, 0, %l0
20123a0: 04 80 00 07 ble 20123bc <rtems_rfs_inode_create+0x1bc> <== ALWAYS TAKEN
20123a4: 03 00 00 10 sethi %hi(0x4000), %g1
{
rtems_rfs_inode_close (fs, &inode);
20123a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20123ac: 7f ff fe c0 call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
20123b0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
20123b4: 10 80 00 5f b 2012530 <rtems_rfs_inode_create+0x330> <== NOT EXECUTED
20123b8: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED
/*
* Only handle the specifics of a directory. Let caller handle the others.
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
20123bc: 80 a4 80 01 cmp %l2, %g1
20123c0: 12 80 00 17 bne 201241c <rtems_rfs_inode_create+0x21c>
20123c4: 90 10 00 18 mov %i0, %o0
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
20123c8: d8 04 40 00 ld [ %l1 ], %o4
20123cc: 92 07 bf d8 add %fp, -40, %o1
20123d0: 15 00 80 c0 sethi %hi(0x2030000), %o2
20123d4: 96 10 20 01 mov 1, %o3
20123d8: 40 00 27 05 call 201bfec <rtems_rfs_dir_add_entry>
20123dc: 94 12 a3 30 or %o2, 0x330, %o2
if (rc == 0)
20123e0: a0 92 20 00 orcc %o0, 0, %l0
20123e4: 12 80 00 0b bne 2012410 <rtems_rfs_inode_create+0x210> <== NEVER TAKEN
20123e8: 80 a4 20 00 cmp %l0, 0
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
20123ec: 90 10 00 18 mov %i0, %o0
20123f0: 92 07 bf d8 add %fp, -40, %o1
20123f4: 15 00 80 c0 sethi %hi(0x2030000), %o2
20123f8: 96 10 20 02 mov 2, %o3
20123fc: 94 12 a3 38 or %o2, 0x338, %o2
2012400: 40 00 26 fb call 201bfec <rtems_rfs_dir_add_entry>
2012404: 98 10 00 19 mov %i1, %o4
2012408: a0 10 00 08 mov %o0, %l0
if (rc > 0)
201240c: 80 a4 20 00 cmp %l0, 0
2012410: 14 80 00 0b bg 201243c <rtems_rfs_inode_create+0x23c> <== NEVER TAKEN
2012414: 90 10 00 18 mov %i0, %o0
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
2012418: 90 10 00 18 mov %i0, %o0
201241c: 92 10 00 19 mov %i1, %o1
2012420: 94 07 bf b0 add %fp, -80, %o2
2012424: 7f ff fe 30 call 2011ce4 <rtems_rfs_inode_open>
2012428: 96 10 20 01 mov 1, %o3
201242c: a0 10 00 08 mov %o0, %l0
if (rc > 0)
2012430: 80 a4 20 00 cmp %l0, 0
2012434: 04 80 00 04 ble 2012444 <rtems_rfs_inode_create+0x244> <== ALWAYS TAKEN
2012438: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
201243c: 10 80 00 30 b 20124fc <rtems_rfs_inode_create+0x2fc> <== NOT EXECUTED
2012440: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
2012444: d8 04 40 00 ld [ %l1 ], %o4
2012448: 92 07 bf b0 add %fp, -80, %o1
201244c: 94 10 00 1a mov %i2, %o2
2012450: 40 00 26 e7 call 201bfec <rtems_rfs_dir_add_entry>
2012454: 96 10 00 1b mov %i3, %o3
if (rc > 0)
2012458: a0 92 20 00 orcc %o0, 0, %l0
201245c: 04 80 00 0b ble 2012488 <rtems_rfs_inode_create+0x288> <== ALWAYS TAKEN
2012460: 03 00 00 10 sethi %hi(0x4000), %g1
{
rtems_rfs_inode_delete (fs, &inode);
2012464: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2012468: 7f ff fe b4 call 2011f38 <rtems_rfs_inode_delete> <== NOT EXECUTED
201246c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
2012470: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2012474: 7f ff fe 8e call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
2012478: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
201247c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2012480: 10 80 00 23 b 201250c <rtems_rfs_inode_create+0x30c> <== NOT EXECUTED
2012484: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
/*
* If the node is a directory update the parent link count as the
* new directory has the '..' link that points to the parent.
*/
if (RTEMS_RFS_S_ISDIR (mode))
2012488: 80 a4 80 01 cmp %l2, %g1
201248c: 12 80 00 15 bne 20124e0 <rtems_rfs_inode_create+0x2e0>
2012490: 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);
2012494: c2 07 bf bc ld [ %fp + -68 ], %g1
if (links == 0xffff)
2012498: 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);
201249c: c6 08 60 01 ldub [ %g1 + 1 ], %g3
20124a0: c4 08 40 00 ldub [ %g1 ], %g2
20124a4: 85 28 a0 08 sll %g2, 8, %g2
20124a8: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
20124ac: 87 28 a0 10 sll %g2, 0x10, %g3
20124b0: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
20124b4: 86 39 00 03 xnor %g4, %g3, %g3
20124b8: 80 a0 00 03 cmp %g0, %g3
20124bc: 86 60 20 00 subx %g0, 0, %g3
20124c0: 84 08 80 03 and %g2, %g3, %g2
rtems_rfs_inode_set_links (&parent_inode,
20124c4: 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);
20124c8: 87 30 a0 08 srl %g2, 8, %g3
20124cc: c6 28 40 00 stb %g3, [ %g1 ]
20124d0: c2 07 bf bc ld [ %fp + -68 ], %g1
20124d4: c4 28 60 01 stb %g2, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
20124d8: 82 10 20 01 mov 1, %g1
20124dc: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
20124e0: 7f ff fe 73 call 2011eac <rtems_rfs_inode_close>
20124e4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
20124e8: 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);
20124ec: a0 10 00 08 mov %o0, %l0
if (rc > 0)
20124f0: 80 a4 20 00 cmp %l0, 0
20124f4: 04 80 00 09 ble 2012518 <rtems_rfs_inode_create+0x318> <== ALWAYS TAKEN
20124f8: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
20124fc: 7f ff fe 8f call 2011f38 <rtems_rfs_inode_delete> <== NOT EXECUTED
2012500: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
2012504: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2012508: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
201250c: 7f ff fe 68 call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
2012510: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
2012514: 30 80 00 0c b,a 2012544 <rtems_rfs_inode_create+0x344> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
2012518: 7f ff fe 65 call 2011eac <rtems_rfs_inode_close>
201251c: 01 00 00 00 nop
if (rc > 0)
2012520: a0 92 20 00 orcc %o0, 0, %l0
2012524: 24 80 00 07 ble,a 2012540 <rtems_rfs_inode_create+0x340> <== ALWAYS TAKEN
2012528: a0 10 20 00 clr %l0
{
rtems_rfs_inode_free (fs, *ino);
201252c: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED
2012530: 7f ff fd bb call 2011c1c <rtems_rfs_inode_free> <== NOT EXECUTED
2012534: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
}
return 0;
}
2012538: 81 c7 e0 08 ret <== NOT EXECUTED
201253c: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
2012540: b0 10 00 10 mov %l0, %i0
2012544: 81 c7 e0 08 ret
2012548: 81 e8 00 00 restore
02011f38 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
2011f38: 9d e3 bf 50 save %sp, -176, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
2011f3c: 90 10 20 00 clr %o0
2011f40: 40 00 05 f2 call 2013708 <rtems_rfs_trace>
2011f44: 13 00 20 00 sethi %hi(0x800000), %o1
2011f48: 80 8a 20 ff btst 0xff, %o0
2011f4c: 22 80 00 0f be,a 2011f88 <rtems_rfs_inode_delete+0x50> <== ALWAYS TAKEN
2011f50: c4 06 60 0c ld [ %i1 + 0xc ], %g2
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
2011f54: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
2011f58: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2011f5c: 02 80 00 05 be 2011f70 <rtems_rfs_inode_delete+0x38> <== NOT EXECUTED
2011f60: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2011f64: 15 00 80 ca sethi %hi(0x2032800), %o2 <== NOT EXECUTED
2011f68: 10 80 00 04 b 2011f78 <rtems_rfs_inode_delete+0x40> <== NOT EXECUTED
2011f6c: 94 12 a3 28 or %o2, 0x328, %o2 ! 2032b28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
2011f70: 15 00 80 c3 sethi %hi(0x2030c00), %o2 <== NOT EXECUTED
2011f74: 94 12 a0 10 or %o2, 0x10, %o2 ! 2030c10 <__FUNCTION__.7127+0x538><== NOT EXECUTED
2011f78: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2011f7c: 40 00 40 02 call 2021f84 <printf> <== NOT EXECUTED
2011f80: 90 12 20 20 or %o0, 0x20, %o0 ! 2032c20 <_CPU_Trap_slot_template+0xbe8><== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
2011f84: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED
2011f88: 80 a0 a0 00 cmp %g2, 0
2011f8c: 02 80 00 1e be 2012004 <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
2011f90: 90 10 20 00 clr %o0
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
2011f94: d2 06 60 08 ld [ %i1 + 8 ], %o1
2011f98: 7f ff ff 21 call 2011c1c <rtems_rfs_inode_free>
2011f9c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
2011fa0: 80 a2 20 00 cmp %o0, 0
2011fa4: 14 80 00 18 bg 2012004 <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
2011fa8: 92 10 00 19 mov %i1, %o1
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
2011fac: 90 10 00 18 mov %i0, %o0
2011fb0: 40 00 21 25 call 201a444 <rtems_rfs_block_map_open>
2011fb4: 94 07 bf b0 add %fp, -80, %o2
if (rc == 0)
2011fb8: 80 a2 20 00 cmp %o0, 0
2011fbc: 12 80 00 12 bne 2012004 <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
2011fc0: 92 07 bf b0 add %fp, -80, %o1
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
2011fc4: 40 00 24 35 call 201b098 <rtems_rfs_block_map_free_all>
2011fc8: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_block_map_close (fs, &map);
2011fcc: 92 07 bf b0 add %fp, -80, %o1
2011fd0: 40 00 21 7e call 201a5c8 <rtems_rfs_block_map_close>
2011fd4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
2011fd8: d0 06 60 0c ld [ %i1 + 0xc ], %o0
2011fdc: 92 10 20 ff mov 0xff, %o1
2011fe0: 40 00 3f 6b call 2021d8c <memset>
2011fe4: 94 10 20 38 mov 0x38, %o2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2011fe8: 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);
2011fec: 90 10 00 18 mov %i0, %o0
rrc = rtems_rfs_block_map_free_all (fs, &map);
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2011ff0: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
/*
* Do the release here to avoid the ctime field being set on a
* close. Also if there loads is greater then one then other loads
* active. Forcing the loads count to 0.
*/
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
2011ff4: 40 00 24 8d call 201b228 <rtems_rfs_buffer_handle_release>
2011ff8: 92 06 60 10 add %i1, 0x10, %o1
handle->loads = 0;
2011ffc: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->node = NULL;
2012000: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
2012004: 81 c7 e0 08 ret
2012008: 91 e8 00 08 restore %g0, %o0, %o0
020125cc <rtems_rfs_inode_get_block>:
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
20125cc: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
20125d0: 92 02 60 06 add %o1, 6, %o1 <== NOT EXECUTED
20125d4: 85 2a 60 02 sll %o1, 2, %g2 <== NOT EXECUTED
20125d8: 84 00 40 02 add %g1, %g2, %g2 <== NOT EXECUTED
20125dc: 82 00 a0 04 add %g2, 4, %g1 <== NOT EXECUTED
20125e0: d0 08 a0 04 ldub [ %g2 + 4 ], %o0 <== NOT EXECUTED
20125e4: c4 08 a0 05 ldub [ %g2 + 5 ], %g2 <== NOT EXECUTED
20125e8: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED
20125ec: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
20125f0: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
20125f4: c4 08 60 03 ldub [ %g1 + 3 ], %g2 <== NOT EXECUTED
20125f8: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
20125fc: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
2012600: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
}
2012604: 81 c3 e0 08 retl <== NOT EXECUTED
2012608: 90 12 00 01 or %o0, %g1, %o0 <== NOT EXECUTED
02011c30 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
2011c30: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
2011c34: 90 10 20 00 clr %o0
2011c38: 40 00 06 b4 call 2013708 <rtems_rfs_trace>
2011c3c: 13 00 04 00 sethi %hi(0x100000), %o1
2011c40: 80 8a 20 ff btst 0xff, %o0
2011c44: 02 80 00 0f be 2011c80 <rtems_rfs_inode_load+0x50> <== ALWAYS TAKEN
2011c48: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
2011c4c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2011c50: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2011c54: 02 80 00 05 be 2011c68 <rtems_rfs_inode_load+0x38> <== NOT EXECUTED
2011c58: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
2011c5c: 17 00 80 ca sethi %hi(0x2032800), %o3 <== NOT EXECUTED
2011c60: 10 80 00 04 b 2011c70 <rtems_rfs_inode_load+0x40> <== NOT EXECUTED
2011c64: 96 12 e3 28 or %o3, 0x328, %o3 ! 2032b28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
2011c68: 17 00 80 c3 sethi %hi(0x2030c00), %o3 <== NOT EXECUTED
2011c6c: 96 12 e0 10 or %o3, 0x10, %o3 ! 2030c10 <__FUNCTION__.7127+0x538><== NOT EXECUTED
2011c70: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011c74: 40 00 40 c4 call 2021f84 <printf> <== NOT EXECUTED
2011c78: 90 12 23 30 or %o0, 0x330, %o0 ! 2032b30 <_CPU_Trap_slot_template+0xaf8><== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
2011c7c: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
2011c80: 80 a0 60 00 cmp %g1, 0
2011c84: 32 80 00 13 bne,a 2011cd0 <rtems_rfs_inode_load+0xa0>
2011c88: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
2011c8c: d4 06 60 1c ld [ %i1 + 0x1c ], %o2
2011c90: 90 10 00 18 mov %i0, %o0
2011c94: 92 06 60 10 add %i1, 0x10, %o1
2011c98: 40 00 25 d8 call 201b3f8 <rtems_rfs_buffer_handle_request>
2011c9c: 96 10 20 01 mov 1, %o3
handle->block, true);
if (rc > 0)
2011ca0: b0 92 20 00 orcc %o0, 0, %i0
2011ca4: 14 80 00 0e bg 2011cdc <rtems_rfs_inode_load+0xac> <== NEVER TAKEN
2011ca8: 01 00 00 00 nop
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
2011cac: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
handle->node += handle->offset;
2011cb0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2011cb4: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
2011cb8: 87 28 60 03 sll %g1, 3, %g3
2011cbc: 83 28 60 06 sll %g1, 6, %g1
2011cc0: 82 20 40 03 sub %g1, %g3, %g1
2011cc4: 82 00 80 01 add %g2, %g1, %g1
2011cc8: c2 26 60 0c st %g1, [ %i1 + 0xc ]
}
handle->loads++;
2011ccc: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
return 0;
2011cd0: b0 10 20 00 clr %i0
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
2011cd4: 82 00 60 01 inc %g1
2011cd8: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
return 0;
}
2011cdc: 81 c7 e0 08 ret
2011ce0: 81 e8 00 00 restore
02011ce4 <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)
{
2011ce4: 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))
2011ce8: 90 10 20 00 clr %o0
2011cec: 40 00 06 87 call 2013708 <rtems_rfs_trace>
2011cf0: 13 00 01 00 sethi %hi(0x40000), %o1
2011cf4: 80 8a 20 ff btst 0xff, %o0
2011cf8: 02 80 00 07 be 2011d14 <rtems_rfs_inode_open+0x30> <== ALWAYS TAKEN
2011cfc: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
2011d00: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011d04: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2011d08: 40 00 40 9f call 2021f84 <printf> <== NOT EXECUTED
2011d0c: 90 12 23 68 or %o0, 0x368, %o0 <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
2011d10: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2011d14: 02 80 00 28 be 2011db4 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
2011d18: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
2011d1c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
2011d20: ba 06 7f ff add %i1, -1, %i5
2011d24: 80 a7 40 02 cmp %i5, %g2
2011d28: 18 80 00 23 bgu 2011db4 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
2011d2c: 90 10 00 1d mov %i5, %o0
return EINVAL;
handle->ino = ino;
2011d30: 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;
2011d34: f2 06 20 2c ld [ %i0 + 0x2c ], %i1
gino = gino % fs->group_inodes;
2011d38: 92 10 00 19 mov %i1, %o1
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
2011d3c: 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;
2011d40: 40 00 71 12 call 202e188 <.urem>
2011d44: c0 26 a0 24 clr [ %i2 + 0x24 ]
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
2011d48: 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;
2011d4c: a0 10 00 08 mov %o0, %l0
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
2011d50: 40 00 71 0e call 202e188 <.urem>
2011d54: 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;
2011d58: 92 10 00 19 mov %i1, %o1
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
2011d5c: 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;
2011d60: 7f ff c2 47 call 200267c <.udiv>
2011d64: 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);
2011d68: c4 06 20 20 ld [ %i0 + 0x20 ], %g2
2011d6c: 87 2a 20 04 sll %o0, 4, %g3
2011d70: 83 2a 20 06 sll %o0, 6, %g1
2011d74: 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;
2011d78: fa 00 80 01 ld [ %g2 + %g1 ], %i5
2011d7c: 90 10 00 10 mov %l0, %o0
2011d80: ba 07 60 02 add %i5, 2, %i5
2011d84: 7f ff c2 3e call 200267c <.udiv>
2011d88: 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;
2011d8c: c0 2e a0 10 clrb [ %i2 + 0x10 ]
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
2011d90: 90 07 40 08 add %i5, %o0, %o0
handle->bnum = 0;
2011d94: c0 26 a0 14 clr [ %i2 + 0x14 ]
2011d98: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
handle->buffer = NULL;
2011d9c: c0 26 a0 18 clr [ %i2 + 0x18 ]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
2011da0: 80 a6 e0 00 cmp %i3, 0
2011da4: 02 80 00 04 be 2011db4 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
2011da8: 82 10 20 00 clr %g1
rc = rtems_rfs_inode_load (fs, handle);
2011dac: 7f ff ff a1 call 2011c30 <rtems_rfs_inode_load>
2011db0: 93 e8 00 1a restore %g0, %i2, %o1
return rc;
}
2011db4: 81 c7 e0 08 ret <== NOT EXECUTED
2011db8: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
0201260c <rtems_rfs_inode_set_block>:
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
201260c: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
2012610: 92 02 60 06 add %o1, 6, %o1 <== NOT EXECUTED
2012614: 93 2a 60 02 sll %o1, 2, %o1 <== NOT EXECUTED
2012618: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
201261c: 85 32 a0 18 srl %o2, 0x18, %g2 <== NOT EXECUTED
2012620: c4 28 60 04 stb %g2, [ %g1 + 4 ] <== NOT EXECUTED
2012624: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
2012628: 85 32 a0 10 srl %o2, 0x10, %g2 <== NOT EXECUTED
201262c: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
2012630: c4 28 60 05 stb %g2, [ %g1 + 5 ] <== NOT EXECUTED
2012634: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
2012638: 85 32 a0 08 srl %o2, 8, %g2 <== NOT EXECUTED
201263c: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
2012640: c4 28 60 06 stb %g2, [ %g1 + 6 ] <== NOT EXECUTED
2012644: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
2012648: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
201264c: d4 2a 60 07 stb %o2, [ %o1 + 7 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2012650: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2012654: 81 c3 e0 08 retl <== NOT EXECUTED
2012658: c2 2a 20 10 stb %g1, [ %o0 + 0x10 ] <== NOT EXECUTED
0201200c <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
201200c: 9d e3 bf a0 save %sp, -96, %sp
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
2012010: c2 06 20 0c ld [ %i0 + 0xc ], %g1
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
2012014: ba 10 00 18 mov %i0, %i5
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
2012018: 80 a0 60 00 cmp %g1, 0
201201c: 02 80 00 23 be 20120a8 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
2012020: b0 10 20 06 mov 6, %i0
return ENXIO;
now = time (NULL);
2012024: 40 00 4f f4 call 2025ff4 <time>
2012028: 90 10 20 00 clr %o0
if (atime)
201202c: 80 a6 60 00 cmp %i1, 0
2012030: 02 80 00 0f be 201206c <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
2012034: 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);
2012038: c2 07 60 0c ld [ %i5 + 0xc ], %g1
201203c: 85 32 20 18 srl %o0, 0x18, %g2
2012040: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
2012044: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2012048: 85 32 20 10 srl %o0, 0x10, %g2
201204c: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
2012050: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2012054: 85 32 20 08 srl %o0, 8, %g2
2012058: c4 28 60 12 stb %g2, [ %g1 + 0x12 ]
201205c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2012060: d0 28 60 13 stb %o0, [ %g1 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2012064: 82 10 20 01 mov 1, %g1
2012068: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
201206c: 02 80 00 0f be 20120a8 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
2012070: 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);
2012074: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2012078: 85 32 20 18 srl %o0, 0x18, %g2
201207c: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
2012080: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2012084: 85 32 20 10 srl %o0, 0x10, %g2
2012088: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
201208c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2012090: 85 32 20 08 srl %o0, 8, %g2
2012094: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
2012098: c2 07 60 0c ld [ %i5 + 0xc ], %g1
201209c: d0 28 60 17 stb %o0, [ %g1 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
20120a0: 82 10 20 01 mov 1, %g1
20120a4: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
20120a8: 81 c7 e0 08 ret
20120ac: 81 e8 00 00 restore
02011dbc <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
2011dbc: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
2011dc0: 90 10 20 00 clr %o0
2011dc4: 40 00 06 51 call 2013708 <rtems_rfs_trace>
2011dc8: 13 00 08 00 sethi %hi(0x200000), %o1
2011dcc: 80 8a 20 ff btst 0xff, %o0
2011dd0: 02 80 00 0f be 2011e0c <rtems_rfs_inode_unload+0x50> <== ALWAYS TAKEN
2011dd4: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
2011dd8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2011ddc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2011de0: 02 80 00 05 be 2011df4 <rtems_rfs_inode_unload+0x38> <== NOT EXECUTED
2011de4: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
2011de8: 17 00 80 ca sethi %hi(0x2032800), %o3 <== NOT EXECUTED
2011dec: 10 80 00 04 b 2011dfc <rtems_rfs_inode_unload+0x40> <== NOT EXECUTED
2011df0: 96 12 e3 28 or %o3, 0x328, %o3 ! 2032b28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
2011df4: 17 00 80 c3 sethi %hi(0x2030c00), %o3 <== NOT EXECUTED
2011df8: 96 12 e0 10 or %o3, 0x10, %o3 ! 2030c10 <__FUNCTION__.7127+0x538><== NOT EXECUTED
2011dfc: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011e00: 40 00 40 61 call 2021f84 <printf> <== NOT EXECUTED
2011e04: 90 12 23 90 or %o0, 0x390, %o0 ! 2032b90 <_CPU_Trap_slot_template+0xb58><== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
2011e08: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
2011e0c: 80 a0 60 00 cmp %g1, 0
2011e10: 32 80 00 04 bne,a 2011e20 <rtems_rfs_inode_unload+0x64>
2011e14: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
int rc = 0;
2011e18: 10 80 00 23 b 2011ea4 <rtems_rfs_inode_unload+0xe8>
2011e1c: 90 10 20 00 clr %o0
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
2011e20: 80 a0 a0 00 cmp %g2, 0
2011e24: 02 80 00 20 be 2011ea4 <rtems_rfs_inode_unload+0xe8> <== NEVER TAKEN
2011e28: 90 10 20 05 mov 5, %o0
return EIO;
handle->loads--;
2011e2c: 82 00 bf ff add %g2, -1, %g1
if (handle->loads == 0)
2011e30: 80 a0 60 00 cmp %g1, 0
2011e34: 12 bf ff f9 bne 2011e18 <rtems_rfs_inode_unload+0x5c>
2011e38: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
2011e3c: c2 0e 60 10 ldub [ %i1 + 0x10 ], %g1
2011e40: 80 a0 60 00 cmp %g1, 0
2011e44: 02 80 00 15 be 2011e98 <rtems_rfs_inode_unload+0xdc>
2011e48: 90 10 00 18 mov %i0, %o0
2011e4c: 80 a6 a0 00 cmp %i2, 0
2011e50: 02 80 00 12 be 2011e98 <rtems_rfs_inode_unload+0xdc> <== NEVER TAKEN
2011e54: 01 00 00 00 nop
rtems_rfs_inode_set_ctime (handle, time (NULL));
2011e58: 40 00 50 67 call 2025ff4 <time>
2011e5c: 90 10 20 00 clr %o0 ! 0 <PROM_START>
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
2011e60: c4 06 60 0c ld [ %i1 + 0xc ], %g2
2011e64: 87 32 20 18 srl %o0, 0x18, %g3
2011e68: c6 28 a0 18 stb %g3, [ %g2 + 0x18 ]
2011e6c: c4 06 60 0c ld [ %i1 + 0xc ], %g2
2011e70: 87 32 20 10 srl %o0, 0x10, %g3
2011e74: c6 28 a0 19 stb %g3, [ %g2 + 0x19 ]
2011e78: c4 06 60 0c ld [ %i1 + 0xc ], %g2
2011e7c: 87 32 20 08 srl %o0, 8, %g3
2011e80: c6 28 a0 1a stb %g3, [ %g2 + 0x1a ]
2011e84: c4 06 60 0c ld [ %i1 + 0xc ], %g2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2011e88: 82 10 20 01 mov 1, %g1
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
2011e8c: d0 28 a0 1b stb %o0, [ %g2 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2011e90: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
2011e94: 90 10 00 18 mov %i0, %o0
2011e98: 40 00 24 e4 call 201b228 <rtems_rfs_buffer_handle_release>
2011e9c: 92 06 60 10 add %i1, 0x10, %o1
handle->node = NULL;
2011ea0: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
2011ea4: 81 c7 e0 08 ret
2011ea8: 91 e8 00 08 restore %g0, %o0, %o0
0201e528 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
201e528: 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))
201e52c: 90 10 20 00 clr %o0
201e530: 7f ff d4 76 call 2013708 <rtems_rfs_trace>
201e534: 13 00 40 00 sethi %hi(0x1000000), %o1
201e538: 80 8a 20 ff btst 0xff, %o0
201e53c: 02 80 00 13 be 201e588 <rtems_rfs_link+0x60> <== ALWAYS TAKEN
201e540: 90 10 00 18 mov %i0, %o0
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
201e544: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e548: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201e54c: 90 12 20 e0 or %o0, 0xe0, %o0 <== NOT EXECUTED
201e550: 40 00 0e 8d call 2021f84 <printf> <== NOT EXECUTED
201e554: a0 10 20 00 clr %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
201e558: 10 80 00 05 b 201e56c <rtems_rfs_link+0x44> <== NOT EXECUTED
201e55c: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
201e560: 40 00 0e f3 call 202212c <putchar> <== NOT EXECUTED
201e564: 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++)
201e568: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
201e56c: 26 bf ff fd bl,a 201e560 <rtems_rfs_link+0x38> <== NOT EXECUTED
201e570: d0 4e 40 10 ldsb [ %i1 + %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
201e574: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e578: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201e57c: 40 00 0e 82 call 2021f84 <printf> <== NOT EXECUTED
201e580: 90 12 21 08 or %o0, 0x108, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
201e584: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e588: 92 10 00 1c mov %i4, %o1
201e58c: 94 07 bf d8 add %fp, -40, %o2
201e590: 7f ff cd d5 call 2011ce4 <rtems_rfs_inode_open>
201e594: 96 10 20 01 mov 1, %o3
if (rc)
201e598: a0 92 20 00 orcc %o0, 0, %l0
201e59c: 12 80 00 49 bne 201e6c0 <rtems_rfs_link+0x198> <== NEVER TAKEN
201e5a0: 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)))
201e5a4: 12 80 00 10 bne 201e5e4 <rtems_rfs_link+0xbc> <== NEVER TAKEN
201e5a8: 90 10 00 18 mov %i0, %o0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
201e5ac: c2 07 bf e4 ld [ %fp + -28 ], %g1
201e5b0: c4 08 60 02 ldub [ %g1 + 2 ], %g2
201e5b4: 03 00 00 3c sethi %hi(0xf000), %g1
201e5b8: 85 28 a0 08 sll %g2, 8, %g2
201e5bc: 84 08 80 01 and %g2, %g1, %g2
201e5c0: 03 00 00 10 sethi %hi(0x4000), %g1
201e5c4: 80 a0 80 01 cmp %g2, %g1
201e5c8: 12 80 00 08 bne 201e5e8 <rtems_rfs_link+0xc0> <== ALWAYS TAKEN
201e5cc: 92 10 00 1b mov %i3, %o1
{
rtems_rfs_inode_close (fs, &target_inode);
201e5d0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
201e5d4: 7f ff ce 36 call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201e5d8: a0 10 20 86 mov 0x86, %l0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
201e5dc: 81 c7 e0 08 ret <== NOT EXECUTED
201e5e0: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
201e5e4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201e5e8: 94 07 bf b0 add %fp, -80, %o2
201e5ec: 7f ff cd be call 2011ce4 <rtems_rfs_inode_open>
201e5f0: 96 10 20 01 mov 1, %o3
201e5f4: a0 10 00 08 mov %o0, %l0
if (rc)
201e5f8: 80 a4 20 00 cmp %l0, 0
201e5fc: 02 80 00 04 be 201e60c <rtems_rfs_link+0xe4> <== ALWAYS TAKEN
201e600: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
201e604: 10 80 00 0f b 201e640 <rtems_rfs_link+0x118> <== NOT EXECUTED
201e608: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
201e60c: 92 07 bf b0 add %fp, -80, %o1
201e610: 94 10 00 19 mov %i1, %o2
201e614: 96 10 00 1a mov %i2, %o3
201e618: 7f ff f6 75 call 201bfec <rtems_rfs_dir_add_entry>
201e61c: 98 10 00 1c mov %i4, %o4
if (rc > 0)
201e620: a0 92 20 00 orcc %o0, 0, %l0
201e624: 04 80 00 0a ble 201e64c <rtems_rfs_link+0x124> <== ALWAYS TAKEN
201e628: 92 07 bf b0 add %fp, -80, %o1
{
rtems_rfs_inode_close (fs, &parent_inode);
201e62c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e630: 7f ff ce 1f call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201e634: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
201e638: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e63c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
201e640: 7f ff ce 1b call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201e644: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
201e648: 30 80 00 1f b,a 201e6c4 <rtems_rfs_link+0x19c> <== NOT EXECUTED
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
201e64c: 7f ff ff a8 call 201e4ec <rtems_rfs_inode_get_links>
201e650: 90 07 bf d8 add %fp, -40, %o0
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
201e654: c2 07 bf e4 ld [ %fp + -28 ], %g1
201e658: 90 02 20 01 inc %o0
201e65c: 85 32 20 08 srl %o0, 8, %g2
201e660: c4 28 40 00 stb %g2, [ %g1 ]
201e664: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
201e668: 92 10 20 01 mov 1, %o1
201e66c: d0 28 60 01 stb %o0, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201e670: 82 10 20 01 mov 1, %g1
201e674: 90 07 bf b0 add %fp, -80, %o0
201e678: c2 2f bf e8 stb %g1, [ %fp + -24 ]
201e67c: 7f ff ce 64 call 201200c <rtems_rfs_inode_time_stamp_now>
201e680: 94 10 20 01 mov 1, %o2
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
201e684: 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);
201e688: a0 10 00 08 mov %o0, %l0
if (rc > 0)
201e68c: 80 a4 20 00 cmp %l0, 0
201e690: 14 bf ff e8 bg 201e630 <rtems_rfs_link+0x108> <== NEVER TAKEN
201e694: 90 10 00 18 mov %i0, %o0
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
201e698: 7f ff ce 05 call 2011eac <rtems_rfs_inode_close>
201e69c: 01 00 00 00 nop
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
201e6a0: 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);
201e6a4: a0 10 00 08 mov %o0, %l0
if (rc > 0)
201e6a8: 80 a4 20 00 cmp %l0, 0
201e6ac: 14 bf ff e5 bg 201e640 <rtems_rfs_link+0x118> <== NEVER TAKEN
201e6b0: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
201e6b4: 7f ff cd fe call 2011eac <rtems_rfs_inode_close>
201e6b8: 01 00 00 00 nop
201e6bc: a0 10 00 08 mov %o0, %l0
return rc;
}
201e6c0: b0 10 00 10 mov %l0, %i0
201e6c4: 81 c7 e0 08 ret
201e6c8: 81 e8 00 00 restore
0201eea4 <rtems_rfs_mutex_create>:
RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
201eea4: 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'),
201eea8: 11 14 91 94 sethi %hi(0x52465000), %o0
201eeac: 98 10 00 18 mov %i0, %o4
201eeb0: 90 12 23 6d or %o0, 0x36d, %o0
201eeb4: 92 10 20 01 mov 1, %o1
201eeb8: 94 10 20 54 mov 0x54, %o2
201eebc: 96 10 20 00 clr %o3
201eec0: 7f ff b6 3e call 200c7b8 <rtems_semaphore_create>
201eec4: b0 10 20 00 clr %i0
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
201eec8: 80 a2 20 00 cmp %o0, 0
201eecc: 02 80 00 0f be 201ef08 <rtems_rfs_mutex_create+0x64> <== ALWAYS TAKEN
201eed0: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
201eed4: 90 10 20 00 clr %o0 <== NOT EXECUTED
201eed8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201eedc: 7f ff d2 0b call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201eee0: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
201eee4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201eee8: 02 80 00 08 be 201ef08 <rtems_rfs_mutex_create+0x64> <== NOT EXECUTED
201eeec: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
201eef0: 7f ff a3 a1 call 2007d74 <rtems_status_text> <== NOT EXECUTED
201eef4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201eef8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
201eefc: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201ef00: 40 00 0c 21 call 2021f84 <printf> <== NOT EXECUTED
201ef04: 90 12 23 38 or %o0, 0x338, %o0 ! 2034b38 <CSWTCH.2+0x1658><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
201ef08: 81 c7 e0 08 ret
201ef0c: 81 e8 00 00 restore
0201ef10 <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
201ef10: 9d e3 bf a0 save %sp, -96, %sp
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
201ef14: d0 06 00 00 ld [ %i0 ], %o0
201ef18: 7f ff b6 96 call 200c970 <rtems_semaphore_delete>
201ef1c: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
201ef20: 80 a2 20 00 cmp %o0, 0
201ef24: 02 80 00 0f be 201ef60 <rtems_rfs_mutex_destroy+0x50> <== ALWAYS TAKEN
201ef28: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
201ef2c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201ef30: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201ef34: 7f ff d1 f5 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201ef38: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
201ef3c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ef40: 02 80 00 08 be 201ef60 <rtems_rfs_mutex_destroy+0x50> <== NOT EXECUTED
201ef44: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
201ef48: 7f ff a3 8b call 2007d74 <rtems_status_text> <== NOT EXECUTED
201ef4c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ef50: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
201ef54: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201ef58: 40 00 0c 0b call 2021f84 <printf> <== NOT EXECUTED
201ef5c: 90 12 23 60 or %o0, 0x360, %o0 ! 2034b60 <CSWTCH.2+0x1680><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
201ef60: 81 c7 e0 08 ret
201ef64: 81 e8 00 00 restore
0201f180 <rtems_rfs_mutex_lock.isra.0>:
* @param mutex The mutex to lock.
* @retval true The mutex is locked.
* @retval false The mutex could not be locked.
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
201f180: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
201f184: 92 10 20 00 clr %o1
201f188: 90 10 00 18 mov %i0, %o0
201f18c: 94 10 20 00 clr %o2
201f190: 7f ff b6 27 call 200ca2c <rtems_semaphore_obtain>
201f194: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
201f198: 80 a2 20 00 cmp %o0, 0
201f19c: 02 80 00 0f be 201f1d8 <rtems_rfs_mutex_lock.isra.0+0x58> <== ALWAYS TAKEN
201f1a0: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
201f1a4: 90 10 20 00 clr %o0 <== NOT EXECUTED
201f1a8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201f1ac: 7f ff d1 57 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201f1b0: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
201f1b4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201f1b8: 02 80 00 08 be 201f1d8 <rtems_rfs_mutex_lock.isra.0+0x58> <== NOT EXECUTED
201f1bc: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
201f1c0: 7f ff a2 ed call 2007d74 <rtems_status_text> <== NOT EXECUTED
201f1c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201f1c8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
201f1cc: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
201f1d0: 40 00 0b 6d call 2021f84 <printf> <== NOT EXECUTED
201f1d4: 90 12 20 f0 or %o0, 0xf0, %o0 ! 2032cf0 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
201f1d8: 81 c7 e0 08 ret
201f1dc: 81 e8 00 00 restore
02012ccc <rtems_rfs_mutex_lock.isra.2>:
* @param mutex The mutex to lock.
* @retval true The mutex is locked.
* @retval false The mutex could not be locked.
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
2012ccc: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
2012cd0: 92 10 20 00 clr %o1
2012cd4: 90 10 00 18 mov %i0, %o0
2012cd8: 94 10 20 00 clr %o2
2012cdc: 7f ff e7 54 call 200ca2c <rtems_semaphore_obtain>
2012ce0: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
2012ce4: 80 a2 20 00 cmp %o0, 0
2012ce8: 02 80 00 0f be 2012d24 <rtems_rfs_mutex_lock.isra.2+0x58> <== ALWAYS TAKEN
2012cec: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2012cf0: 90 10 20 00 clr %o0 <== NOT EXECUTED
2012cf4: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2012cf8: 40 00 02 84 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
2012cfc: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2012d00: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2012d04: 02 80 00 08 be 2012d24 <rtems_rfs_mutex_lock.isra.2+0x58> <== NOT EXECUTED
2012d08: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2012d0c: 7f ff d4 1a call 2007d74 <rtems_status_text> <== NOT EXECUTED
2012d10: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2012d14: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2012d18: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2012d1c: 40 00 3c 9a call 2021f84 <printf> <== NOT EXECUTED
2012d20: 90 12 20 f0 or %o0, 0xf0, %o0 ! 2032cf0 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
2012d24: 81 c7 e0 08 ret
2012d28: 81 e8 00 00 restore
02012c74 <rtems_rfs_mutex_unlock.isra.1>:
* @param mutex The mutex to unlock.
* @retval true The mutex is unlocked.
* @retval false The mutex could not be unlocked.
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
2012c74: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2012c78: 90 10 00 18 mov %i0, %o0
2012c7c: 7f ff e7 b5 call 200cb50 <rtems_semaphore_release>
2012c80: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
2012c84: 80 a2 20 00 cmp %o0, 0
2012c88: 02 80 00 0f be 2012cc4 <rtems_rfs_mutex_unlock.isra.1+0x50><== ALWAYS TAKEN
2012c8c: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2012c90: 90 10 20 00 clr %o0 <== NOT EXECUTED
2012c94: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2012c98: 40 00 02 9c call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
2012c9c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2012ca0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2012ca4: 02 80 00 08 be 2012cc4 <rtems_rfs_mutex_unlock.isra.1+0x50><== NOT EXECUTED
2012ca8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2012cac: 7f ff d4 32 call 2007d74 <rtems_status_text> <== NOT EXECUTED
2012cb0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2012cb4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2012cb8: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2012cbc: 40 00 3c b2 call 2021f84 <printf> <== NOT EXECUTED
2012cc0: 90 12 20 c8 or %o0, 0xc8, %o0 ! 2032cc8 <_CPU_Trap_slot_template+0xc90><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
2012cc4: 81 c7 e0 08 ret
2012cc8: 81 e8 00 00 restore
0201b0a8 <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
201b0a8: 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))
201b0ac: 90 10 20 00 clr %o0
201b0b0: 92 10 20 80 mov 0x80, %o1
201b0b4: 7f ff e1 95 call 2013708 <rtems_rfs_trace>
201b0b8: ba 10 00 18 mov %i0, %i5
201b0bc: 80 8a 20 ff btst 0xff, %o0
201b0c0: 22 80 00 07 be,a 201b0dc <rtems_rfs_release_chain+0x34> <== ALWAYS TAKEN
201b0c4: b0 10 20 00 clr %i0
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
201b0c8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
201b0cc: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201b0d0: 40 00 1b ad call 2021f84 <printf> <== NOT EXECUTED
201b0d4: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 20335e8 <CSWTCH.2+0x108> <== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
201b0d8: b0 10 20 00 clr %i0 <== NOT EXECUTED
201b0dc: 10 80 00 10 b 201b11c <rtems_rfs_release_chain+0x74>
201b0e0: b8 07 60 04 add %i5, 4, %i4
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
201b0e4: 7f ff c9 28 call 200d584 <_Chain_Get>
201b0e8: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
201b0ec: c2 06 40 00 ld [ %i1 ], %g1
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
201b0f0: 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)--;
201b0f4: 82 00 7f ff add %g1, -1, %g1
201b0f8: c2 26 40 00 st %g1, [ %i1 ]
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
201b0fc: 40 00 15 31 call 20205c0 <rtems_rfs_buffer_bdbuf_release>
201b100: c0 22 20 34 clr [ %o0 + 0x34 ]
if ((rc > 0) && (rrc == 0))
201b104: 80 a2 20 00 cmp %o0, 0
201b108: 24 80 00 06 ble,a 201b120 <rtems_rfs_release_chain+0x78> <== ALWAYS TAKEN
201b10c: c2 07 40 00 ld [ %i5 ], %g1
201b110: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
201b114: 22 80 00 02 be,a 201b11c <rtems_rfs_release_chain+0x74> <== NOT EXECUTED
201b118: 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))
201b11c: c2 07 40 00 ld [ %i5 ], %g1
201b120: 80 a0 40 1c cmp %g1, %i4
201b124: 12 bf ff f0 bne 201b0e4 <rtems_rfs_release_chain+0x3c>
201b128: 01 00 00 00 nop
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
201b12c: 81 c7 e0 08 ret
201b130: 81 e8 00 00 restore
02012978 <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
2012978: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
201297c: 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);
2012980: 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);
2012984: fa 00 60 08 ld [ %g1 + 8 ], %i5
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2012988: 94 07 bf d8 add %fp, -40, %o2
201298c: 90 10 00 1d mov %i5, %o0
2012990: 7f ff fc d5 call 2011ce4 <rtems_rfs_inode_open>
2012994: 96 10 20 01 mov 1, %o3
if (rc > 0)
2012998: b8 92 20 00 orcc %o0, 0, %i4
201299c: 04 80 00 07 ble 20129b8 <rtems_rfs_rtems_chown+0x40> <== ALWAYS TAKEN
20129a0: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("chown: opening inode", rc);
20129a4: 40 00 38 1f call 2020a20 <__errno> <== NOT EXECUTED
20129a8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
20129ac: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
20129b0: 81 c7 e0 08 ret <== NOT EXECUTED
20129b4: 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();
20129b8: 40 00 10 fa call 2016da0 <geteuid>
20129bc: 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;
20129c0: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
20129c4: 91 2a 20 10 sll %o0, 0x10, %o0
20129c8: c6 08 60 07 ldub [ %g1 + 7 ], %g3
20129cc: c4 08 60 06 ldub [ %g1 + 6 ], %g2
20129d0: 85 28 a0 08 sll %g2, 8, %g2
20129d4: 84 10 80 03 or %g2, %g3, %g2
20129d8: 85 28 a0 10 sll %g2, 0x10, %g2
20129dc: 80 a0 80 08 cmp %g2, %o0
20129e0: 02 80 00 0e be 2012a18 <rtems_rfs_rtems_chown+0xa0> <== ALWAYS TAKEN
20129e4: 87 32 20 10 srl %o0, 0x10, %g3
20129e8: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
20129ec: 22 80 00 0c be,a 2012a1c <rtems_rfs_rtems_chown+0xa4> <== NOT EXECUTED
20129f0: b5 2e a0 10 sll %i2, 0x10, %i2 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
20129f4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
20129f8: 7f ff fd 2d call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
20129fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: not able", EPERM);
2012a00: 40 00 38 08 call 2020a20 <__errno> <== NOT EXECUTED
2012a04: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012a08: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2012a0c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2012a10: 81 c7 e0 08 ret <== NOT EXECUTED
2012a14: 81 e8 00 00 restore <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,
uint16_t uid, uint16_t gid)
{
rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
2012a18: b5 2e a0 10 sll %i2, 0x10, %i2
2012a1c: b4 16 80 19 or %i2, %i1, %i2
2012a20: 85 36 a0 18 srl %i2, 0x18, %g2
2012a24: c4 28 60 04 stb %g2, [ %g1 + 4 ]
2012a28: c2 07 bf e4 ld [ %fp + -28 ], %g1
2012a2c: 85 36 a0 10 srl %i2, 0x10, %g2
2012a30: c4 28 60 05 stb %g2, [ %g1 + 5 ]
2012a34: c2 07 bf e4 ld [ %fp + -28 ], %g1
2012a38: b5 36 a0 08 srl %i2, 8, %i2
2012a3c: f4 28 60 06 stb %i2, [ %g1 + 6 ]
2012a40: 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);
2012a44: 90 10 00 1d mov %i5, %o0
2012a48: f2 28 60 07 stb %i1, [ %g1 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2012a4c: 82 10 20 01 mov 1, %g1
2012a50: 92 07 bf d8 add %fp, -40, %o1
2012a54: c2 2f bf e8 stb %g1, [ %fp + -24 ]
2012a58: 7f ff fd 15 call 2011eac <rtems_rfs_inode_close>
2012a5c: b0 10 20 00 clr %i0
if (rc)
2012a60: 80 a2 20 00 cmp %o0, 0
2012a64: 02 80 00 05 be 2012a78 <rtems_rfs_rtems_chown+0x100> <== ALWAYS TAKEN
2012a68: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
2012a6c: 40 00 37 ed call 2020a20 <__errno> <== NOT EXECUTED
2012a70: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012a74: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2012a78: 81 c7 e0 08 ret
2012a7c: 81 e8 00 00 restore
0201efec <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);
201efec: d2 02 20 2c ld [ %o0 + 0x2c ], %o1 <== NOT EXECUTED
201eff0: d4 02 20 30 ld [ %o0 + 0x30 ], %o2 <== NOT EXECUTED
201eff4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
201eff8: 40 00 03 37 call 201fcd4 <rtems_deviceio_close> <== NOT EXECUTED
201effc: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0201efa8 <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, off_t length)
{
return 0;
}
201efa8: 81 c3 e0 08 retl <== NOT EXECUTED
201efac: 90 10 20 00 clr %o0 <== NOT EXECUTED
0201efb0 <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);
201efb0: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
201efb4: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
201efb8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
201efbc: 40 00 03 86 call 201fdd4 <rtems_deviceio_control> <== NOT EXECUTED
201efc0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0201f054 <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
201f054: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
201f058: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
201f05c: 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);
201f060: 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);
201f064: 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
};
201f068: c2 07 60 80 ld [ %i5 + 0x80 ], %g1 <== NOT EXECUTED
201f06c: 94 10 20 00 clr %o2 <== NOT EXECUTED
201f070: 7f ff b6 6f call 200ca2c <rtems_semaphore_obtain> <== NOT EXECUTED
201f074: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
201f078: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
201f07c: 02 80 00 0f be 201f0b8 <rtems_rfs_rtems_device_open+0x64> <== NOT EXECUTED
201f080: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
201f084: 90 10 20 00 clr %o0 <== NOT EXECUTED
201f088: 7f ff d1 a0 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201f08c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201f090: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201f094: 22 80 00 09 be,a 201f0b8 <rtems_rfs_rtems_device_open+0x64><== NOT EXECUTED
201f098: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
201f09c: 7f ff a3 36 call 2007d74 <rtems_status_text> <== NOT EXECUTED
201f0a0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201f0a4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
201f0a8: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
201f0ac: 40 00 0b b6 call 2021f84 <printf> <== NOT EXECUTED
201f0b0: 90 12 20 f0 or %o0, 0xf0, %o0 ! 2032cf0 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
rtems_device_minor_number minor;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
201f0b4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201f0b8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201f0bc: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
201f0c0: 7f ff cb 09 call 2011ce4 <rtems_rfs_inode_open> <== NOT EXECUTED
201f0c4: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
201f0c8: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
201f0cc: 04 80 00 09 ble 201f0f0 <rtems_rfs_rtems_device_open+0x9c><== NOT EXECUTED
201f0d0: 92 10 20 00 clr %o1 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
201f0d4: 7f ff ff cb call 201f000 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f0d8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
201f0dc: 40 00 06 51 call 2020a20 <__errno> <== NOT EXECUTED
201f0e0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201f0e4: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
201f0e8: 81 c7 e0 08 ret <== NOT EXECUTED
201f0ec: 81 e8 00 00 restore <== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
201f0f0: 7f ff ff 9e call 201ef68 <rtems_rfs_inode_get_block> <== NOT EXECUTED
201f0f4: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
201f0f8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
}
major = rtems_rfs_inode_get_block (&inode, 0);
201f0fc: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
201f100: 7f ff ff 9a call 201ef68 <rtems_rfs_inode_get_block> <== NOT EXECUTED
201f104: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
201f108: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
}
major = rtems_rfs_inode_get_block (&inode, 0);
minor = rtems_rfs_inode_get_block (&inode, 1);
201f10c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
201f110: 7f ff cb 67 call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201f114: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201f118: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
if (rc > 0)
201f11c: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
201f120: 04 80 00 09 ble 201f144 <rtems_rfs_rtems_device_open+0xf0><== NOT EXECUTED
201f124: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
201f128: 7f ff ff b6 call 201f000 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f12c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
201f130: 40 00 06 3c call 2020a20 <__errno> <== NOT EXECUTED
201f134: 01 00 00 00 nop <== NOT EXECUTED
201f138: e2 22 00 00 st %l1, [ %o0 ] <== NOT EXECUTED
201f13c: 81 c7 e0 08 ret <== NOT EXECUTED
201f140: 81 e8 00 00 restore <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
201f144: 7f ff ff af call 201f000 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f148: 01 00 00 00 nop <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void *) minor;
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
201f14c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
201f150: f8 26 20 2c st %i4, [ %i0 + 0x2c ] <== NOT EXECUTED
iop->data1 = (void *) minor;
201f154: e0 26 20 30 st %l0, [ %i0 + 0x30 ] <== NOT EXECUTED
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
201f158: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201f15c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201f160: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
201f164: 98 10 00 10 mov %l0, %o4 <== NOT EXECUTED
201f168: 40 00 02 ce call 201fca0 <rtems_deviceio_open> <== NOT EXECUTED
201f16c: 9a 10 00 1c mov %i4, %o5 <== NOT EXECUTED
}
201f170: 81 c7 e0 08 ret <== NOT EXECUTED
201f174: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
0201efd8 <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);
201efd8: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
201efdc: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
201efe0: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
201efe4: 40 00 03 48 call 201fd04 <rtems_deviceio_read> <== NOT EXECUTED
201efe8: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0201efc4 <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);
201efc4: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
201efc8: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
201efcc: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
201efd0: 40 00 03 67 call 201fd6c <rtems_deviceio_write> <== NOT EXECUTED
201efd4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0201f324 <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
201f324: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
201f328: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
201f32c: f8 06 20 1c ld [ %i0 + 0x1c ], %i4
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
201f330: fa 00 60 08 ld [ %g1 + 8 ], %i5
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_filesystem_default_ftruncate_directory,
.fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
201f334: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
201f338: 7f ff ff 92 call 201f180 <rtems_rfs_mutex_lock.isra.0>
201f33c: d0 00 40 00 ld [ %g1 ], %o0
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
201f340: 92 10 00 1c mov %i4, %o1
201f344: 90 10 00 1d mov %i5, %o0
201f348: 94 07 bf d8 add %fp, -40, %o2
201f34c: 7f ff ca 66 call 2011ce4 <rtems_rfs_inode_open>
201f350: 96 10 20 01 mov 1, %o3
if (rc)
201f354: b8 92 20 00 orcc %o0, 0, %i4
201f358: 02 80 00 09 be 201f37c <rtems_rfs_rtems_dir_open+0x58> <== ALWAYS TAKEN
201f35c: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
rtems_rfs_rtems_unlock (fs);
201f360: 7f ff ff a0 call 201f1e0 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f364: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
201f368: 40 00 05 ae call 2020a20 <__errno> <== NOT EXECUTED
201f36c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201f370: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
201f374: 81 c7 e0 08 ret <== NOT EXECUTED
201f378: 81 e8 00 00 restore <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
201f37c: c4 08 60 02 ldub [ %g1 + 2 ], %g2
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
201f380: 03 00 00 3c sethi %hi(0xf000), %g1
201f384: 85 28 a0 08 sll %g2, 8, %g2
201f388: 84 08 80 01 and %g2, %g1, %g2
201f38c: 03 00 00 10 sethi %hi(0x4000), %g1
201f390: 80 a0 80 01 cmp %g2, %g1
201f394: 02 80 00 0c be 201f3c4 <rtems_rfs_rtems_dir_open+0xa0> <== ALWAYS TAKEN
201f398: 92 07 bf d8 add %fp, -40, %o1
{
rtems_rfs_inode_close (fs, &inode);
201f39c: 7f ff ca c4 call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201f3a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
201f3a4: 7f ff ff 8f call 201f1e0 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f3a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
201f3ac: 40 00 05 9d call 2020a20 <__errno> <== NOT EXECUTED
201f3b0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201f3b4: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
201f3b8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201f3bc: 81 c7 e0 08 ret <== NOT EXECUTED
201f3c0: 81 e8 00 00 restore <== NOT EXECUTED
}
iop->offset = 0;
201f3c4: c0 26 20 08 clr [ %i0 + 8 ]
201f3c8: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_rfs_inode_close (fs, &inode);
201f3cc: 7f ff ca b8 call 2011eac <rtems_rfs_inode_close>
201f3d0: 90 10 00 1d mov %i5, %o0
rtems_rfs_rtems_unlock (fs);
201f3d4: 90 10 00 1d mov %i5, %o0
201f3d8: 7f ff ff 82 call 201f1e0 <rtems_rfs_rtems_unlock>
201f3dc: b0 10 20 00 clr %i0
return 0;
}
201f3e0: 81 c7 e0 08 ret
201f3e4: 81 e8 00 00 restore
0201f234 <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
201f234: 9d e3 bf 70 save %sp, -144, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
201f238: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
201f23c: 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);
201f240: fa 00 60 08 ld [ %g1 + 8 ], %i5
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
201f244: a0 07 bf d8 add %fp, -40, %l0
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_filesystem_default_ftruncate_directory,
.fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
201f248: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_mutex_lock (&rtems->access);
201f24c: 7f ff ff cd call 201f180 <rtems_rfs_mutex_lock.isra.0>
201f250: d0 00 40 00 ld [ %g1 ], %o0
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
201f254: 92 10 00 1c mov %i4, %o1
201f258: 90 10 00 1d mov %i5, %o0
201f25c: 94 10 00 10 mov %l0, %o2
201f260: 7f ff ca a1 call 2011ce4 <rtems_rfs_inode_open>
201f264: 96 10 20 01 mov 1, %o3
if (rc)
201f268: b8 92 20 00 orcc %o0, 0, %i4
201f26c: 02 80 00 1f be 201f2e8 <rtems_rfs_rtems_dir_read+0xb4> <== ALWAYS TAKEN
201f270: 90 10 00 1a mov %i2, %o0
{
rtems_rfs_rtems_unlock (fs);
201f274: 7f ff ff db call 201f1e0 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f278: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
201f27c: 40 00 05 e9 call 2020a20 <__errno> <== NOT EXECUTED
201f280: 01 00 00 00 nop <== NOT EXECUTED
201f284: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
201f288: 10 80 00 25 b 201f31c <rtems_rfs_rtems_dir_read+0xe8> <== NOT EXECUTED
201f28c: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
201f290: d4 1e 20 08 ldd [ %i0 + 8 ], %o2
201f294: 90 10 00 1d mov %i5, %o0
201f298: 92 10 00 10 mov %l0, %o1
201f29c: 7f ff f5 35 call 201c770 <rtems_rfs_dir_read>
201f2a0: 9a 07 bf d4 add %fp, -44, %o5
if (rc == ENOENT)
201f2a4: 80 a2 20 02 cmp %o0, 2
201f2a8: 02 80 00 18 be 201f308 <rtems_rfs_rtems_dir_read+0xd4>
201f2ac: b4 10 00 08 mov %o0, %i2
{
rc = 0;
break;
}
if (rc > 0)
201f2b0: 80 a2 20 00 cmp %o0, 0
201f2b4: 24 80 00 06 ble,a 201f2cc <rtems_rfs_rtems_dir_read+0x98><== ALWAYS TAKEN
201f2b8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
201f2bc: 40 00 05 d9 call 2020a20 <__errno> <== NOT EXECUTED
201f2c0: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
201f2c4: 10 80 00 11 b 201f308 <rtems_rfs_rtems_dir_read+0xd4> <== NOT EXECUTED
201f2c8: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
break;
}
iop->offset += size;
201f2cc: c2 07 bf d4 ld [ %fp + -44 ], %g1
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
201f2d0: b8 07 21 18 add %i4, 0x118, %i4
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
201f2d4: 86 80 c0 01 addcc %g3, %g1, %g3
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
201f2d8: b6 06 e0 01 inc %i3
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
201f2dc: 84 40 a0 00 addx %g2, 0, %g2
201f2e0: 10 80 00 07 b 201f2fc <rtems_rfs_rtems_dir_read+0xc8>
201f2e4: c4 3e 20 08 std %g2, [ %i0 + 8 ]
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
201f2e8: 92 10 21 18 mov 0x118, %o1
201f2ec: 7f ff 8c e4 call 200267c <.udiv>
201f2f0: b6 10 20 00 clr %i3
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
201f2f4: b8 10 20 00 clr %i4
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
201f2f8: a2 10 00 08 mov %o0, %l1
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
201f2fc: 80 a6 c0 11 cmp %i3, %l1
201f300: 12 bf ff e4 bne 201f290 <rtems_rfs_rtems_dir_read+0x5c>
201f304: 98 06 40 1c add %i1, %i4, %o4
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
201f308: 90 10 00 1d mov %i5, %o0
201f30c: 7f ff ca e8 call 2011eac <rtems_rfs_inode_close>
201f310: 92 07 bf d8 add %fp, -40, %o1
rtems_rfs_rtems_unlock (fs);
201f314: 7f ff ff b3 call 201f1e0 <rtems_rfs_rtems_unlock>
201f318: 90 10 00 1d mov %i5, %o0
return bytes_transferred;
}
201f31c: 81 c7 e0 08 ret
201f320: 91 e8 00 1c restore %g0, %i4, %o0
02012bd0 <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)
{
2012bd0: 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);
2012bd4: 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);
2012bd8: 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);
2012bdc: 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);
2012be0: 94 07 bf d8 add %fp, -40, %o2
2012be4: 90 10 00 1d mov %i5, %o0
2012be8: 7f ff fc 3f call 2011ce4 <rtems_rfs_inode_open>
2012bec: 96 10 20 01 mov 1, %o3
if (rc == 0) {
2012bf0: b8 92 20 00 orcc %o0, 0, %i4
2012bf4: 12 80 00 10 bne 2012c34 <rtems_rfs_rtems_eval_path+0x64> <== NEVER TAKEN
2012bf8: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_generic (
2012bfc: 92 07 bf d8 add %fp, -40, %o1
2012c00: 15 00 80 cb sethi %hi(0x2032c00), %o2
2012c04: 40 00 11 68 call 20171a4 <rtems_filesystem_eval_path_generic>
2012c08: 94 12 a1 d8 or %o2, 0x1d8, %o2 ! 2032dd8 <rtems_rfs_rtems_eval_config>
ctx,
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
2012c0c: 90 10 00 1d mov %i5, %o0
2012c10: 7f ff fc a7 call 2011eac <rtems_rfs_inode_close>
2012c14: 92 07 bf d8 add %fp, -40, %o1
if (rc != 0) {
2012c18: ba 92 20 00 orcc %o0, 0, %i5
2012c1c: 02 80 00 0c be 2012c4c <rtems_rfs_rtems_eval_path+0x7c> <== ALWAYS TAKEN
2012c20: 01 00 00 00 nop
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
2012c24: 40 00 37 7f call 2020a20 <__errno> <== NOT EXECUTED
2012c28: 01 00 00 00 nop <== NOT EXECUTED
2012c2c: 10 80 00 05 b 2012c40 <rtems_rfs_rtems_eval_path+0x70> <== NOT EXECUTED
2012c30: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
);
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
2012c34: 40 00 37 7b call 2020a20 <__errno> <== NOT EXECUTED
2012c38: 01 00 00 00 nop <== NOT EXECUTED
2012c3c: 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 (
2012c40: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2012c44: 7f ff da 95 call 2009698 <rtems_filesystem_eval_path_error><== NOT EXECUTED
2012c48: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
2012c4c: 81 c7 e0 08 ret
2012c50: 81 e8 00 00 restore
02013028 <rtems_rfs_rtems_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
2013028: 9d e3 bf 90 save %sp, -112, %sp
201302c: f8 06 60 0c ld [ %i1 + 0xc ], %i4
2013030: ba 10 00 18 mov %i0, %i5
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
2013034: c2 0f 20 07 ldub [ %i4 + 7 ], %g1
2013038: f0 0f 20 06 ldub [ %i4 + 6 ], %i0
static bool
rtems_rfs_rtems_eval_perms (rtems_filesystem_eval_path_context_t *ctx,
int eval_flags,
rtems_rfs_inode_handle* inode)
{
return rtems_filesystem_eval_path_check_access(
201303c: 90 10 00 19 mov %i1, %o0
2013040: b1 2e 20 08 sll %i0, 8, %i0
2013044: 7f ff fd 5a call 20125ac <rtems_rfs_inode_get_gid>
2013048: b0 16 00 01 or %i0, %g1, %i0
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
201304c: c2 0f 20 02 ldub [ %i4 + 2 ], %g1
2013050: d4 0f 20 03 ldub [ %i4 + 3 ], %o2
2013054: 83 28 60 08 sll %g1, 8, %g1
2013058: 97 2e 20 10 sll %i0, 0x10, %o3
201305c: 99 2a 20 10 sll %o0, 0x10, %o4
2013060: 92 10 20 01 mov 1, %o1
2013064: 90 10 00 1d mov %i5, %o0
2013068: 94 12 80 01 or %o2, %g1, %o2
201306c: 97 32 e0 10 srl %o3, 0x10, %o3
2013070: 99 33 20 10 srl %o4, 0x10, %o4
2013074: 40 00 10 3e call 201716c <rtems_filesystem_eval_path_check_access>
2013078: 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) {
201307c: 80 8a 20 ff btst 0xff, %o0
2013080: 02 80 00 71 be 2013244 <rtems_rfs_rtems_eval_token+0x21c>
2013084: 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] == '.';
2013088: 12 80 00 06 bne 20130a0 <rtems_rfs_rtems_eval_token+0x78>
201308c: 82 10 20 00 clr %g1
2013090: c2 4e 80 00 ldsb [ %i2 ], %g1
2013094: 82 18 60 2e xor %g1, 0x2e, %g1
2013098: 80 a0 00 01 cmp %g0, %g1
201309c: 82 60 3f ff subx %g0, -1, %g1
if (rtems_filesystem_is_current_directory (token, tokenlen)) {
20130a0: 80 a0 60 00 cmp %g1, 0
20130a4: 22 80 00 04 be,a 20130b4 <rtems_rfs_rtems_eval_token+0x8c>
20130a8: 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;
20130ac: 10 80 00 44 b 20131bc <rtems_rfs_rtems_eval_token+0x194>
20130b0: c0 27 60 0c clr [ %i5 + 0xc ]
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc( ctx );
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
20130b4: 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);
20130b8: f8 00 60 08 ld [ %g1 + 8 ], %i4
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
20130bc: 94 10 00 1a mov %i2, %o2
20130c0: 90 10 00 1c mov %i4, %o0
20130c4: 96 10 00 1b mov %i3, %o3
20130c8: 98 07 bf f4 add %fp, -12, %o4
20130cc: 9a 07 bf f8 add %fp, -8, %o5
20130d0: 40 00 22 89 call 201baf4 <rtems_rfs_dir_lookup_ino>
20130d4: b0 10 20 02 mov 2, %i0
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
20130d8: 80 a2 20 00 cmp %o0, 0
20130dc: 12 80 00 5a bne 2013244 <rtems_rfs_rtems_eval_token+0x21c>
20130e0: 90 10 00 1c mov %i4, %o0
rc = rtems_rfs_inode_close (fs, inode);
20130e4: 7f ff fb 72 call 2011eac <rtems_rfs_inode_close>
20130e8: 92 10 00 19 mov %i1, %o1
if (rc == 0) {
20130ec: 80 a2 20 00 cmp %o0, 0
20130f0: 02 80 00 07 be 201310c <rtems_rfs_rtems_eval_token+0xe4> <== ALWAYS TAKEN
20130f4: 90 10 00 19 mov %i1, %o0
if (rc != 0) {
/*
* This prevents the rtems_rfs_inode_close() from doing something in
* rtems_rfs_rtems_eval_path().
*/
memset (inode, 0, sizeof(*inode));
20130f8: 92 10 20 00 clr %o1 <== NOT EXECUTED
20130fc: 40 00 3b 24 call 2021d8c <memset> <== NOT EXECUTED
2013100: 94 10 20 28 mov 0x28, %o2 <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
2013104: 81 c7 e0 08 ret <== NOT EXECUTED
2013108: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
);
if (rc == 0) {
rc = rtems_rfs_inode_close (fs, inode);
if (rc == 0) {
rc = rtems_rfs_inode_open (fs, entry_ino, inode, true);
201310c: d2 07 bf f4 ld [ %fp + -12 ], %o1
2013110: 90 10 00 1c mov %i4, %o0
2013114: 94 10 00 19 mov %i1, %o2
2013118: 7f ff fa f3 call 2011ce4 <rtems_rfs_inode_open>
201311c: 96 10 20 01 mov 1, %o3
}
if (rc != 0) {
2013120: 80 a2 20 00 cmp %o0, 0
2013124: 02 80 00 2f be 20131e0 <rtems_rfs_rtems_eval_token+0x1b8> <== ALWAYS TAKEN
2013128: 90 10 00 19 mov %i1, %o0
/*
* This prevents the rtems_rfs_inode_close() from doing something in
* rtems_rfs_rtems_eval_path().
*/
memset (inode, 0, sizeof(*inode));
201312c: 10 bf ff f4 b 20130fc <rtems_rfs_rtems_eval_token+0xd4> <== NOT EXECUTED
2013130: 92 10 20 00 clr %o1 <== NOT EXECUTED
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
2013134: 02 80 00 04 be 2013144 <rtems_rfs_rtems_eval_token+0x11c>
2013138: 80 88 a0 ff btst 0xff, %g2
201313c: 02 80 00 23 be 20131c8 <rtems_rfs_rtems_eval_token+0x1a0>
2013140: 90 07 60 18 add %i5, 0x18, %o0
rtems_filesystem_eval_path_context_t* ctx,
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
2013144: 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);
2013148: f4 07 bf f4 ld [ %fp + -12 ], %i2
rtems_filesystem_eval_path_context_t* ctx,
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
201314c: c2 27 bf fc st %g1, [ %fp + -4 ]
char *link = malloc(len + 1);
2013150: 7f ff d5 36 call 2008628 <malloc>
2013154: 90 10 24 01 mov 0x401, %o0
if (link != NULL) {
2013158: b6 92 20 00 orcc %o0, 0, %i3
201315c: 02 80 00 14 be 20131ac <rtems_rfs_rtems_eval_token+0x184> <== NEVER TAKEN
2013160: 90 10 00 1c mov %i4, %o0
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
2013164: 92 10 00 1a mov %i2, %o1
2013168: 94 10 00 1b mov %i3, %o2
201316c: 96 10 24 00 mov 0x400, %o3
2013170: 40 00 2e dc call 201ece0 <rtems_rfs_symlink_read>
2013174: 98 07 bf fc add %fp, -4, %o4
if (rc == 0) {
2013178: 80 a2 20 00 cmp %o0, 0
201317c: 12 80 00 06 bne 2013194 <rtems_rfs_rtems_eval_token+0x16c><== NEVER TAKEN
2013180: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_recursive (ctx, link, len);
2013184: d4 07 bf fc ld [ %fp + -4 ], %o2
2013188: 7f ff da 42 call 2009a90 <rtems_filesystem_eval_path_recursive>
201318c: 92 10 00 1b mov %i3, %o1
2013190: 30 80 00 03 b,a 201319c <rtems_rfs_rtems_eval_token+0x174>
} else {
rtems_filesystem_eval_path_error (ctx, 0);
2013194: 7f ff d9 41 call 2009698 <rtems_filesystem_eval_path_error><== NOT EXECUTED
2013198: 92 10 20 00 clr %o1 <== NOT EXECUTED
}
free(link);
201319c: 7f ff d3 92 call 2007fe4 <free>
20131a0: 90 10 00 1b mov %i3, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
20131a4: 81 c7 e0 08 ret
20131a8: 91 e8 20 01 restore %g0, 1, %o0
rtems_filesystem_eval_path_error (ctx, 0);
}
free(link);
} else {
rtems_filesystem_eval_path_error (ctx, ENOMEM);
20131ac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20131b0: 92 10 20 0c mov 0xc, %o1 <== NOT EXECUTED
20131b4: 7f ff d9 39 call 2009698 <rtems_filesystem_eval_path_error><== NOT EXECUTED
20131b8: 01 00 00 00 nop <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
20131bc: 81 c7 e0 08 ret
20131c0: 91 e8 20 01 restore %g0, 1, %o0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);
} else {
rc = rtems_rfs_rtems_set_handlers (currentloc, inode) ? 0 : EIO;
20131c4: 90 07 60 18 add %i5, 0x18, %o0
20131c8: 40 00 01 1d call 201363c <rtems_rfs_rtems_set_handlers>
20131cc: 92 10 00 19 mov %i1, %o1
20131d0: 80 8a 20 ff btst 0xff, %o0
20131d4: 12 80 00 18 bne 2013234 <rtems_rfs_rtems_eval_token+0x20c><== ALWAYS TAKEN
20131d8: c2 07 bf f4 ld [ %fp + -12 ], %g1
20131dc: 30 80 00 0f b,a 2013218 <rtems_rfs_rtems_eval_token+0x1f0><== NOT EXECUTED
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
rc = -1;
}
if (rc == 0) {
bool is_sym_link = rtems_rfs_rtems_node_type_by_inode (inode)
20131e0: 7f ff ff 53 call 2012f2c <rtems_rfs_rtems_node_type_by_inode>
20131e4: 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);
20131e8: 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;
20131ec: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
20131f0: 80 a0 00 01 cmp %g0, %g1
20131f4: c0 27 60 0c clr [ %i5 + 0xc ]
20131f8: 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;
20131fc: 85 30 a0 04 srl %g2, 4, %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
2013200: b0 10 00 01 mov %g1, %i0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
2013204: 80 a2 20 03 cmp %o0, 3
2013208: 12 bf ff ef bne 20131c4 <rtems_rfs_rtems_eval_token+0x19c>
201320c: 84 08 a0 01 and %g2, 1, %g2
2013210: 10 bf ff c9 b 2013134 <rtems_rfs_rtems_eval_token+0x10c>
2013214: 80 a0 60 00 cmp %g1, 0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
2013218: 40 00 36 02 call 2020a20 <__errno> <== NOT EXECUTED
201321c: 01 00 00 00 nop <== NOT EXECUTED
2013220: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
2013224: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
2013228: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
201322c: 10 bf ff e2 b 20131b4 <rtems_rfs_rtems_eval_token+0x18c> <== NOT EXECUTED
2013230: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
2013234: 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);
2013238: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
201323c: c2 07 bf f8 ld [ %fp + -8 ], %g1
2013240: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
}
}
}
return status;
}
2013244: 81 c7 e0 08 ret
2013248: 81 e8 00 00 restore
020134ec <rtems_rfs_rtems_fchmod>:
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
20134ec: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
20134f0: 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);
20134f4: 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);
20134f8: fa 00 60 08 ld [ %g1 + 8 ], %i5
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
20134fc: 94 07 bf d8 add %fp, -40, %o2
2013500: 90 10 00 1d mov %i5, %o0
2013504: 7f ff f9 f8 call 2011ce4 <rtems_rfs_inode_open>
2013508: 96 10 20 01 mov 1, %o3
if (rc)
201350c: b8 92 20 00 orcc %o0, 0, %i4
2013510: 02 80 00 07 be 201352c <rtems_rfs_rtems_fchmod+0x40> <== ALWAYS TAKEN
2013514: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
2013518: 40 00 35 42 call 2020a20 <__errno> <== NOT EXECUTED
201351c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013520: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2013524: 81 c7 e0 08 ret <== NOT EXECUTED
2013528: 81 e8 00 00 restore <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
201352c: f8 08 60 02 ldub [ %g1 + 2 ], %i4
2013530: c2 08 60 03 ldub [ %g1 + 3 ], %g1
2013534: b9 2f 20 08 sll %i4, 8, %i4
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
2013538: 40 00 0e 1a call 2016da0 <geteuid>
201353c: b8 17 00 01 or %i4, %g1, %i4
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
2013540: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
2013544: 91 2a 20 10 sll %o0, 0x10, %o0
2013548: c6 08 60 07 ldub [ %g1 + 7 ], %g3
201354c: c4 08 60 06 ldub [ %g1 + 6 ], %g2
2013550: 85 28 a0 08 sll %g2, 8, %g2
2013554: 84 10 80 03 or %g2, %g3, %g2
2013558: 85 28 a0 10 sll %g2, 0x10, %g2
201355c: 80 a0 80 08 cmp %g2, %o0
2013560: 02 80 00 0e be 2013598 <rtems_rfs_rtems_fchmod+0xac> <== ALWAYS TAKEN
2013564: 87 32 20 10 srl %o0, 0x10, %g3
2013568: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
201356c: 22 80 00 0c be,a 201359c <rtems_rfs_rtems_fchmod+0xb0> <== NOT EXECUTED
2013570: b8 0f 30 00 and %i4, -4096, %i4 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
2013574: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2013578: 7f ff fa 4d call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201357c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
2013580: 40 00 35 28 call 2020a20 <__errno> <== NOT EXECUTED
2013584: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013588: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
201358c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2013590: 81 c7 e0 08 ret <== NOT EXECUTED
2013594: 81 e8 00 00 restore <== NOT EXECUTED
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
2013598: b8 0f 30 00 and %i4, -4096, %i4
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
201359c: b2 0e 6f ff and %i1, 0xfff, %i1
20135a0: b2 17 00 19 or %i4, %i1, %i1
* @prarm mode The mode.
*/
static inline void
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{
rtems_rfs_write_u16 (&handle->node->mode, mode);
20135a4: 85 36 60 08 srl %i1, 8, %g2
20135a8: c4 28 60 02 stb %g2, [ %g1 + 2 ]
20135ac: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
20135b0: 90 10 00 1d mov %i5, %o0
20135b4: f2 28 60 03 stb %i1, [ %g1 + 3 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
20135b8: 82 10 20 01 mov 1, %g1
20135bc: 92 07 bf d8 add %fp, -40, %o1
20135c0: c2 2f bf e8 stb %g1, [ %fp + -24 ]
20135c4: 7f ff fa 3a call 2011eac <rtems_rfs_inode_close>
20135c8: b0 10 20 00 clr %i0
if (rc > 0)
20135cc: 80 a2 20 00 cmp %o0, 0
20135d0: 04 80 00 05 ble 20135e4 <rtems_rfs_rtems_fchmod+0xf8> <== ALWAYS TAKEN
20135d4: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
20135d8: 40 00 35 12 call 2020a20 <__errno> <== NOT EXECUTED
20135dc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20135e0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
20135e4: 81 c7 e0 08 ret
20135e8: 81 e8 00 00 restore
02013608 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
2013608: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
201360c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
if (rc)
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
return 0;
2013610: 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));
2013614: 40 00 20 7d call 201b808 <rtems_rfs_buffer_sync> <== NOT EXECUTED
2013618: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
if (rc)
201361c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2013620: 02 80 00 05 be 2013634 <rtems_rfs_rtems_fdatasync+0x2c> <== NOT EXECUTED
2013624: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
2013628: 40 00 34 fe call 2020a20 <__errno> <== NOT EXECUTED
201362c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013630: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return 0;
}
2013634: 81 c7 e0 08 ret <== NOT EXECUTED
2013638: 81 e8 00 00 restore <== NOT EXECUTED
0201f758 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
201f758: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
201f75c: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
201f760: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
201f764: fa 00 60 98 ld [ %g1 + 0x98 ], %i5
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
201f768: 7f ff ff 20 call 201f3e8 <rtems_rfs_rtems_lock>
201f76c: 90 10 00 1d mov %i5, %o0
rc = rtems_rfs_file_close (fs, file);
201f770: 90 10 00 1d mov %i5, %o0
201f774: 7f ff f5 7a call 201cd5c <rtems_rfs_file_close>
201f778: 92 10 00 1c mov %i4, %o1
if (rc > 0)
201f77c: b0 92 20 00 orcc %o0, 0, %i0
201f780: 04 80 00 06 ble 201f798 <rtems_rfs_rtems_file_close+0x40> <== ALWAYS TAKEN
201f784: 01 00 00 00 nop
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
201f788: 40 00 04 a6 call 2020a20 <__errno> <== NOT EXECUTED
201f78c: 01 00 00 00 nop <== NOT EXECUTED
201f790: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
201f794: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
201f798: 7f ff ff 29 call 201f43c <rtems_rfs_rtems_unlock>
201f79c: 90 10 00 1d mov %i5, %o0
return rc;
}
201f7a0: 81 c7 e0 08 ret
201f7a4: 81 e8 00 00 restore
0201f490 <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
201f490: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
201f494: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
201f498: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
201f49c: 7f ff ff d3 call 201f3e8 <rtems_rfs_rtems_lock>
201f4a0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
rc = rtems_rfs_file_set_size (file, length);
201f4a4: 90 10 00 1b mov %i3, %o0
201f4a8: 92 10 00 19 mov %i1, %o1
201f4ac: 7f ff f8 4c call 201d5dc <rtems_rfs_file_set_size>
201f4b0: 94 10 00 1a mov %i2, %o2
if (rc)
201f4b4: b0 92 20 00 orcc %o0, 0, %i0
201f4b8: 22 80 00 07 be,a 201f4d4 <rtems_rfs_rtems_file_ftruncate+0x44><== ALWAYS TAKEN
201f4bc: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
201f4c0: 40 00 05 58 call 2020a20 <__errno> <== NOT EXECUTED
201f4c4: 01 00 00 00 nop <== NOT EXECUTED
201f4c8: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
201f4cc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201f4d0: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
201f4d4: 7f ff ff da call 201f43c <rtems_rfs_rtems_unlock>
201f4d8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return rc;
}
201f4dc: 81 c7 e0 08 ret
201f4e0: 81 e8 00 00 restore
0201f4e4 <rtems_rfs_rtems_file_lseek>:
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
201f4e4: 9d e3 bf 98 save %sp, -104, %sp
201f4e8: b8 10 00 19 mov %i1, %i4
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
201f4ec: f2 06 20 20 ld [ %i0 + 0x20 ], %i1
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
201f4f0: ba 10 00 1a mov %i2, %i5
off_t new_offset;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
201f4f4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
201f4f8: a0 10 00 1b mov %i3, %l0
off_t new_offset;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
201f4fc: 7f ff ff bb call 201f3e8 <rtems_rfs_rtems_lock>
201f500: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
201f504: 92 10 00 1c mov %i4, %o1
201f508: 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;
201f50c: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
201f510: 90 10 00 18 mov %i0, %o0
201f514: 40 00 01 26 call 201f9ac <rtems_filesystem_default_lseek_file>
201f518: 96 10 00 10 mov %l0, %o3
201f51c: b8 10 00 08 mov %o0, %i4
if (new_offset != -1)
201f520: 80 a7 3f ff cmp %i4, -1
201f524: 12 80 00 05 bne 201f538 <rtems_rfs_rtems_file_lseek+0x54>
201f528: ba 10 00 09 mov %o1, %i5
201f52c: 80 a2 7f ff cmp %o1, -1
201f530: 22 80 00 13 be,a 201f57c <rtems_rfs_rtems_file_lseek+0x98><== ALWAYS TAKEN
201f534: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
rtems_rfs_pos pos = iop->offset;
201f538: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
int rc = rtems_rfs_file_seek (file, pos, &pos);
201f53c: 90 10 00 19 mov %i1, %o0
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
if (new_offset != -1)
{
rtems_rfs_pos pos = iop->offset;
201f540: c4 3f bf f8 std %g2, [ %fp + -8 ]
int rc = rtems_rfs_file_seek (file, pos, &pos);
201f544: 92 10 00 02 mov %g2, %o1
201f548: 94 10 00 03 mov %g3, %o2
201f54c: 7f ff f7 e6 call 201d4e4 <rtems_rfs_file_seek>
201f550: 96 07 bf f8 add %fp, -8, %o3
if (rc)
201f554: a0 92 20 00 orcc %o0, 0, %l0
201f558: 22 80 00 09 be,a 201f57c <rtems_rfs_rtems_file_lseek+0x98><== ALWAYS TAKEN
201f55c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
201f560: 40 00 05 30 call 2020a20 <__errno> <== NOT EXECUTED
201f564: 39 3f ff ff sethi %hi(0xfffffc00), %i4 <== NOT EXECUTED
201f568: e0 22 00 00 st %l0, [ %o0 ] <== NOT EXECUTED
iop->offset = old_offset;
201f56c: f4 3e 20 08 std %i2, [ %i0 + 8 ] <== NOT EXECUTED
new_offset = -1;
201f570: b8 17 23 ff or %i4, 0x3ff, %i4 <== NOT EXECUTED
201f574: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201f578: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
return new_offset;
}
201f57c: b0 10 00 1c mov %i4, %i0
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201f580: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201f584: 7f ff ff ae call 201f43c <rtems_rfs_rtems_unlock>
201f588: b2 10 00 1d mov %i5, %i1
return new_offset;
}
201f58c: 81 c7 e0 08 ret
201f590: 81 e8 00 00 restore
0201f7a8 <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
201f7a8: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
201f7ac: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
201f7b0: fa 00 60 08 ld [ %g1 + 8 ], %i5
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: path:%s ino:%" PRId32 " flags:%04i mode:%04" PRIu32 "\n",
pathname, ino, flags, mode);
rtems_rfs_rtems_lock (fs);
201f7b4: 7f ff ff 0d call 201f3e8 <rtems_rfs_rtems_lock>
201f7b8: 90 10 00 1d mov %i5, %o0
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
201f7bc: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
201f7c0: 90 10 00 1d mov %i5, %o0
201f7c4: 94 10 20 00 clr %o2
201f7c8: 7f ff f8 5d call 201d93c <rtems_rfs_file_open>
201f7cc: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
201f7d0: b8 92 20 00 orcc %o0, 0, %i4
201f7d4: 04 80 00 09 ble 201f7f8 <rtems_rfs_rtems_file_open+0x50> <== ALWAYS TAKEN
201f7d8: c2 07 bf fc ld [ %fp + -4 ], %g1
{
rtems_rfs_rtems_unlock (fs);
201f7dc: 7f ff ff 18 call 201f43c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f7e0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-open: open", rc);
201f7e4: 40 00 04 8f call 2020a20 <__errno> <== NOT EXECUTED
201f7e8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201f7ec: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
201f7f0: 81 c7 e0 08 ret <== NOT EXECUTED
201f7f4: 81 e8 00 00 restore <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
rtems_rfs_rtems_set_iop_file_handle (iop, file);
rtems_rfs_rtems_unlock (fs);
201f7f8: 90 10 00 1d mov %i5, %o0
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
rtems_rfs_rtems_set_iop_file_handle (iop, file);
201f7fc: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
rtems_rfs_rtems_unlock (fs);
201f800: 7f ff ff 0f call 201f43c <rtems_rfs_rtems_unlock>
201f804: b0 10 20 00 clr %i0
return 0;
}
201f808: 81 c7 e0 08 ret
201f80c: 81 e8 00 00 restore
0201f810 <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
201f810: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
201f814: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
201f818: a2 10 00 18 mov %i0, %l1
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));
201f81c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
201f820: 7f ff fe f2 call 201f3e8 <rtems_rfs_rtems_lock>
201f824: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
201f828: 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;
201f82c: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
201f830: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201f834: 7f ff ea ec call 201a3e4 <rtems_rfs_block_get_size>
201f838: 92 02 60 84 add %o1, 0x84, %o1
if (pos < rtems_rfs_file_size (file))
201f83c: 80 a2 00 1c cmp %o0, %i4
201f840: 38 80 00 2b bgu,a 201f8ec <rtems_rfs_rtems_file_read+0xdc><== NEVER TAKEN
201f844: b0 10 20 00 clr %i0 <== NOT EXECUTED
201f848: 80 a2 00 1c cmp %o0, %i4
201f84c: 12 80 00 2e bne 201f904 <rtems_rfs_rtems_file_read+0xf4> <== NEVER TAKEN
201f850: b0 10 20 00 clr %i0
201f854: 80 a2 40 1d cmp %o1, %i5
201f858: 18 80 00 25 bgu 201f8ec <rtems_rfs_rtems_file_read+0xdc>
201f85c: 01 00 00 00 nop
}
}
}
if (read >= 0)
iop->offset = pos + read;
201f860: 10 80 00 2a b 201f908 <rtems_rfs_rtems_file_read+0xf8>
201f864: b6 86 00 1d addcc %i0, %i5, %i3
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
201f868: 92 07 bf fc add %fp, -4, %o1
201f86c: 7f ff f5 e8 call 201d00c <rtems_rfs_file_io_start>
201f870: 94 10 20 01 mov 1, %o2
if (rc > 0)
201f874: b6 92 20 00 orcc %o0, 0, %i3
201f878: 14 80 00 19 bg 201f8dc <rtems_rfs_rtems_file_read+0xcc> <== NEVER TAKEN
201f87c: c2 07 bf fc ld [ %fp + -4 ], %g1
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
201f880: 80 a0 60 00 cmp %g1, 0
201f884: 02 80 00 1d be 201f8f8 <rtems_rfs_rtems_file_read+0xe8>
201f888: 80 a0 40 1a cmp %g1, %i2
break;
if (size > count)
201f88c: 38 80 00 02 bgu,a 201f894 <rtems_rfs_rtems_file_read+0x84>
201f890: f4 27 bf fc st %i2, [ %fp + -4 ]
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
201f894: c2 04 20 0c ld [ %l0 + 0xc ], %g1
201f898: f6 07 bf fc ld [ %fp + -4 ], %i3
201f89c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
201f8a0: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
201f8a4: 94 10 00 1b mov %i3, %o2
201f8a8: 92 02 40 01 add %o1, %g1, %o1
201f8ac: 40 00 08 a9 call 2021b50 <memcpy>
201f8b0: 90 10 00 19 mov %i1, %o0
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
201f8b4: 92 10 00 1b mov %i3, %o1
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
201f8b8: b2 06 40 1b add %i1, %i3, %i1
count -= size;
201f8bc: b4 26 80 1b sub %i2, %i3, %i2
read += size;
201f8c0: b0 06 00 1b add %i0, %i3, %i0
rc = rtems_rfs_file_io_end (file, size, true);
201f8c4: 90 10 00 10 mov %l0, %o0
201f8c8: 7f ff f6 5a call 201d230 <rtems_rfs_file_io_end>
201f8cc: 94 10 20 01 mov 1, %o2
if (rc > 0)
201f8d0: b6 92 20 00 orcc %o0, 0, %i3
201f8d4: 04 80 00 07 ble 201f8f0 <rtems_rfs_rtems_file_read+0xe0> <== ALWAYS TAKEN
201f8d8: 80 a6 a0 00 cmp %i2, 0
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
201f8dc: 40 00 04 51 call 2020a20 <__errno> <== NOT EXECUTED
201f8e0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201f8e4: 10 80 00 0c b 201f914 <rtems_rfs_rtems_file_read+0x104> <== NOT EXECUTED
201f8e8: f6 22 00 00 st %i3, [ %o0 ] <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
201f8ec: 80 a6 a0 00 cmp %i2, 0
201f8f0: 12 bf ff de bne 201f868 <rtems_rfs_rtems_file_read+0x58>
201f8f4: 90 10 00 10 mov %l0, %o0
break;
}
}
}
if (read >= 0)
201f8f8: 80 a6 20 00 cmp %i0, 0
201f8fc: 26 80 00 07 bl,a 201f918 <rtems_rfs_rtems_file_read+0x108><== NEVER TAKEN
201f900: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
iop->offset = pos + read;
201f904: b6 86 00 1d addcc %i0, %i5, %i3
201f908: 85 3e 20 1f sra %i0, 0x1f, %g2
201f90c: b4 40 80 1c addx %g2, %i4, %i2
201f910: f4 3c 60 08 std %i2, [ %l1 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201f914: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
201f918: 7f ff fe c9 call 201f43c <rtems_rfs_rtems_unlock>
201f91c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return read;
}
201f920: 81 c7 e0 08 ret
201f924: 81 e8 00 00 restore
0201f594 <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
201f594: 9d e3 bf 90 save %sp, -112, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
201f598: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
201f59c: a2 10 00 18 mov %i0, %l1
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));
201f5a0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
201f5a4: 7f ff ff 91 call 201f3e8 <rtems_rfs_rtems_lock>
201f5a8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
201f5ac: 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;
201f5b0: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
201f5b4: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201f5b8: c4 3f bf f8 std %g2, [ %fp + -8 ]
201f5bc: 7f ff eb 8a call 201a3e4 <rtems_rfs_block_get_size>
201f5c0: 92 02 60 84 add %o1, 0x84, %o1
201f5c4: 86 10 00 09 mov %o1, %g3
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
201f5c8: d2 07 bf f8 ld [ %fp + -8 ], %o1
201f5cc: 82 10 00 08 mov %o0, %g1
201f5d0: 80 a2 40 01 cmp %o1, %g1
201f5d4: 18 80 00 08 bgu 201f5f4 <rtems_rfs_rtems_file_write+0x60> <== NEVER TAKEN
201f5d8: d4 07 bf fc ld [ %fp + -4 ], %o2
201f5dc: 80 a2 40 01 cmp %o1, %g1
201f5e0: 12 80 00 11 bne 201f624 <rtems_rfs_rtems_file_write+0x90> <== NEVER TAKEN
201f5e4: 80 a0 40 09 cmp %g1, %o1
201f5e8: 80 a2 80 03 cmp %o2, %g3
201f5ec: 08 80 00 0e bleu 201f624 <rtems_rfs_rtems_file_write+0x90>
201f5f0: 80 a0 40 09 cmp %g1, %o1
/*
* If the iop position is past the physical end of the file we need to set
* the file size to the new length before writing. The
* rtems_rfs_file_io_end() will grow the file subsequently.
*/
rc = rtems_rfs_file_set_size (file, pos);
201f5f4: 7f ff f7 fa call 201d5dc <rtems_rfs_file_set_size>
201f5f8: 90 10 00 10 mov %l0, %o0
201f5fc: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
if (rc)
201f600: ba 92 20 00 orcc %o0, 0, %i5
201f604: 12 80 00 20 bne 201f684 <rtems_rfs_rtems_file_write+0xf0> <== NEVER TAKEN
201f608: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
201f60c: d2 07 bf f8 ld [ %fp + -8 ], %o1
201f610: d4 07 bf fc ld [ %fp + -4 ], %o2
201f614: 7f ff eb 44 call 201a324 <rtems_rfs_block_get_bpos>
201f618: 96 04 20 10 add %l0, 0x10, %o3
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
201f61c: 10 80 00 40 b 201f71c <rtems_rfs_rtems_file_write+0x188>
201f620: b0 10 20 00 clr %i0
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
}
else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
201f624: 38 80 00 09 bgu,a 201f648 <rtems_rfs_rtems_file_write+0xb4><== NEVER TAKEN
201f628: c4 04 60 10 ld [ %l1 + 0x10 ], %g2 <== NOT EXECUTED
201f62c: 80 a0 40 09 cmp %g1, %o1
201f630: 12 80 00 3b bne 201f71c <rtems_rfs_rtems_file_write+0x188><== NEVER TAKEN
201f634: b0 10 20 00 clr %i0
201f638: 80 a0 c0 0a cmp %g3, %o2
201f63c: 08 80 00 39 bleu 201f720 <rtems_rfs_rtems_file_write+0x18c>
201f640: 80 a6 a0 00 cmp %i2, 0
201f644: c4 04 60 10 ld [ %l1 + 0x10 ], %g2
201f648: 80 88 a2 00 btst 0x200, %g2
201f64c: 22 80 00 34 be,a 201f71c <rtems_rfs_rtems_file_write+0x188>
201f650: b0 10 20 00 clr %i0
{
pos = file_size;
201f654: c2 27 bf f8 st %g1, [ %fp + -8 ]
201f658: c6 27 bf fc st %g3, [ %fp + -4 ]
rc = rtems_rfs_file_seek (file, pos, &pos);
201f65c: 90 10 00 10 mov %l0, %o0
201f660: 92 10 00 01 mov %g1, %o1
201f664: 94 10 00 03 mov %g3, %o2
201f668: 7f ff f7 9f call 201d4e4 <rtems_rfs_file_seek>
201f66c: 96 07 bf f8 add %fp, -8, %o3
if (rc)
201f670: ba 92 20 00 orcc %o0, 0, %i5
201f674: 22 80 00 2a be,a 201f71c <rtems_rfs_rtems_file_write+0x188><== ALWAYS TAKEN
201f678: b0 10 20 00 clr %i0
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201f67c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
201f680: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
201f684: 7f ff ff 6e call 201f43c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f688: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
201f68c: 40 00 04 e5 call 2020a20 <__errno> <== NOT EXECUTED
201f690: 01 00 00 00 nop <== NOT EXECUTED
201f694: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
201f698: 81 c7 e0 08 ret <== NOT EXECUTED
201f69c: 81 e8 00 00 restore <== NOT EXECUTED
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
201f6a0: 90 10 00 10 mov %l0, %o0
201f6a4: 92 07 bf f4 add %fp, -12, %o1
201f6a8: 7f ff f6 59 call 201d00c <rtems_rfs_file_io_start>
201f6ac: 94 10 20 00 clr %o2
if (rc)
201f6b0: ba 92 20 00 orcc %o0, 0, %i5
201f6b4: 12 80 00 16 bne 201f70c <rtems_rfs_rtems_file_write+0x178>
201f6b8: c2 07 bf f4 ld [ %fp + -12 ], %g1
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
201f6bc: 80 a0 40 1a cmp %g1, %i2
201f6c0: 38 80 00 02 bgu,a 201f6c8 <rtems_rfs_rtems_file_write+0x134>
201f6c4: f4 27 bf f4 st %i2, [ %fp + -12 ]
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
201f6c8: c2 04 20 0c ld [ %l0 + 0xc ], %g1
201f6cc: d4 07 bf f4 ld [ %fp + -12 ], %o2
201f6d0: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
201f6d4: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
201f6d8: 92 10 00 19 mov %i1, %o1
201f6dc: 40 00 09 1d call 2021b50 <memcpy>
201f6e0: 90 02 00 01 add %o0, %g1, %o0
data += size;
201f6e4: d2 07 bf f4 ld [ %fp + -12 ], %o1
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
201f6e8: 90 10 00 10 mov %l0, %o0
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
201f6ec: b2 06 40 09 add %i1, %o1, %i1
count -= size;
201f6f0: b4 26 80 09 sub %i2, %o1, %i2
write += size;
201f6f4: b0 06 00 09 add %i0, %o1, %i0
rc = rtems_rfs_file_io_end (file, size, false);
201f6f8: 7f ff f6 ce call 201d230 <rtems_rfs_file_io_end>
201f6fc: 94 10 20 00 clr %o2
if (rc)
201f700: ba 92 20 00 orcc %o0, 0, %i5
201f704: 02 80 00 07 be 201f720 <rtems_rfs_rtems_file_write+0x18c> <== ALWAYS TAKEN
201f708: 80 a6 a0 00 cmp %i2, 0
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
201f70c: 40 00 04 c5 call 2020a20 <__errno>
201f710: b0 10 3f ff mov -1, %i0
201f714: 10 80 00 0c b 201f744 <rtems_rfs_rtems_file_write+0x1b0>
201f718: fa 22 00 00 st %i5, [ %o0 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
201f71c: 80 a6 a0 00 cmp %i2, 0
201f720: 32 bf ff e0 bne,a 201f6a0 <rtems_rfs_rtems_file_write+0x10c>
201f724: f4 27 bf f4 st %i2, [ %fp + -12 ]
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
if (write >= 0)
201f728: 80 a6 20 00 cmp %i0, 0
201f72c: 06 80 00 06 bl 201f744 <rtems_rfs_rtems_file_write+0x1b0> <== NEVER TAKEN
201f730: f8 1f bf f8 ldd [ %fp + -8 ], %i4
iop->offset = pos + write;
201f734: 85 3e 20 1f sra %i0, 0x1f, %g2
201f738: b6 86 00 1d addcc %i0, %i5, %i3
201f73c: b4 40 80 1c addx %g2, %i4, %i2
201f740: f4 3c 60 08 std %i2, [ %l1 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201f744: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
201f748: 7f ff ff 3d call 201f43c <rtems_rfs_rtems_unlock>
201f74c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return write;
}
201f750: 81 c7 e0 08 ret
201f754: 81 e8 00 00 restore
0201324c <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
201324c: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2013250: 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);
2013254: 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);
2013258: 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);
201325c: 94 07 bf d8 add %fp, -40, %o2
2013260: 90 10 00 1d mov %i5, %o0
2013264: 7f ff fa a0 call 2011ce4 <rtems_rfs_inode_open>
2013268: 96 10 20 01 mov 1, %o3
if (rc)
201326c: b8 92 20 00 orcc %o0, 0, %i4
2013270: 02 80 00 07 be 201328c <rtems_rfs_rtems_fstat+0x40> <== ALWAYS TAKEN
2013274: c4 07 bf e4 ld [ %fp + -28 ], %g2
{
return rtems_rfs_rtems_error ("stat: opening inode", rc);
2013278: 40 00 35 ea call 2020a20 <__errno> <== NOT EXECUTED
201327c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013280: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2013284: 81 c7 e0 08 ret <== NOT EXECUTED
2013288: 81 e8 00 00 restore <== NOT EXECUTED
201328c: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
2013290: f8 08 a0 03 ldub [ %g2 + 3 ], %i4
}
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
2013294: 05 3f ff ec sethi %hi(0xffffb000), %g2
2013298: 83 28 60 08 sll %g1, 8, %g1
201329c: b8 10 40 1c or %g1, %i4, %i4
20132a0: 82 08 40 02 and %g1, %g2, %g1
20132a4: 05 00 00 08 sethi %hi(0x2000), %g2
20132a8: 80 a0 40 02 cmp %g1, %g2
20132ac: 32 80 00 0c bne,a 20132dc <rtems_rfs_rtems_fstat+0x90> <== ALWAYS TAKEN
20132b0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
{
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
20132b4: 92 10 20 00 clr %o1 <== NOT EXECUTED
20132b8: 7f ff fc c5 call 20125cc <rtems_rfs_inode_get_block> <== NOT EXECUTED
20132bc: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
20132c0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
20132c4: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
20132c8: 7f ff fc c1 call 20125cc <rtems_rfs_inode_get_block> <== NOT EXECUTED
20132cc: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
{
buf->st_rdev =
20132d0: f6 26 60 18 st %i3, [ %i1 + 0x18 ] <== NOT EXECUTED
20132d4: d0 26 60 1c st %o0, [ %i1 + 0x1c ] <== NOT EXECUTED
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
20132d8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
20132dc: 91 2f 20 10 sll %i4, 0x10, %o0
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
20132e0: c2 26 60 04 st %g1, [ %i1 + 4 ]
20132e4: 83 38 60 1f sra %g1, 0x1f, %g1
20132e8: c2 26 40 00 st %g1, [ %i1 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
20132ec: c2 07 bf e0 ld [ %fp + -32 ], %g1
buf->st_mode = rtems_rfs_rtems_mode (mode);
20132f0: 91 32 20 10 srl %o0, 0x10, %o0
20132f4: 40 00 01 03 call 2013700 <rtems_rfs_rtems_mode>
20132f8: c2 26 60 08 st %g1, [ %i1 + 8 ]
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
20132fc: c2 07 bf e4 ld [ %fp + -28 ], %g1
2013300: d0 26 60 0c st %o0, [ %i1 + 0xc ]
2013304: c6 08 60 01 ldub [ %g1 + 1 ], %g3
2013308: c4 08 40 00 ldub [ %g1 ], %g2
if (links == 0xffff)
201330c: 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);
2013310: 85 28 a0 08 sll %g2, 8, %g2
2013314: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
2013318: 87 28 a0 10 sll %g2, 0x10, %g3
201331c: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
2013320: 86 39 00 03 xnor %g4, %g3, %g3
2013324: 80 a0 00 03 cmp %g0, %g3
2013328: 86 60 20 00 subx %g0, 0, %g3
201332c: 84 08 80 03 and %g2, %g3, %g2
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
2013330: 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;
2013334: c6 08 60 06 ldub [ %g1 + 6 ], %g3
2013338: c4 08 60 07 ldub [ %g1 + 7 ], %g2
201333c: 87 28 e0 08 sll %g3, 8, %g3
2013340: 82 10 c0 02 or %g3, %g2, %g1
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
buf->st_gid = rtems_rfs_inode_get_gid (&inode);
2013344: 90 07 bf d8 add %fp, -40, %o0
2013348: 7f ff fc 99 call 20125ac <rtems_rfs_inode_get_gid>
201334c: c2 36 60 12 sth %g1, [ %i1 + 0x12 ]
/*
* Need to check is the ino is an open file. If so we take the values from
* the open file rather than the inode.
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
2013350: d2 07 bf e0 ld [ %fp + -32 ], %o1
buf->st_dev = rtems_rfs_fs_device (fs);
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
buf->st_gid = rtems_rfs_inode_get_gid (&inode);
2013354: d0 36 60 14 sth %o0, [ %i1 + 0x14 ]
/*
* Need to check is the ino is an open file. If so we take the values from
* the open file rather than the inode.
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
2013358: 40 00 29 6b call 201d904 <rtems_rfs_file_get_shared>
201335c: 90 10 00 1d mov %i5, %o0
if (shared)
2013360: 92 92 20 00 orcc %o0, 0, %o1
2013364: 02 80 00 17 be 20133c0 <rtems_rfs_rtems_fstat+0x174>
2013368: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
201336c: c2 02 60 8c ld [ %o1 + 0x8c ], %g1
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
2013370: c4 06 60 0c ld [ %i1 + 0xc ], %g2
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
2013374: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
2013378: c2 02 60 90 ld [ %o1 + 0x90 ], %g1
201337c: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
2013380: c2 02 60 94 ld [ %o1 + 0x94 ], %g1
2013384: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
2013388: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
201338c: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
2013390: 03 00 00 3c sethi %hi(0xf000), %g1
2013394: 84 08 80 01 and %g2, %g1, %g2
2013398: 03 00 00 28 sethi %hi(0xa000), %g1
201339c: 80 a0 80 01 cmp %g2, %g1
20133a0: 12 80 00 04 bne 20133b0 <rtems_rfs_rtems_fstat+0x164> <== ALWAYS TAKEN
20133a4: 90 10 00 1d mov %i5, %o0
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
20133a8: 10 80 00 3d b 201349c <rtems_rfs_rtems_fstat+0x250> <== NOT EXECUTED
20133ac: c2 12 60 8a lduh [ %o1 + 0x8a ], %g1 <== NOT EXECUTED
*/
static inline rtems_rfs_pos
rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,
rtems_rfs_file_shared* shared)
{
return rtems_rfs_block_get_size (fs, &shared->size);
20133b0: 40 00 1c 0d call 201a3e4 <rtems_rfs_block_get_size>
20133b4: 92 02 60 84 add %o1, 0x84, %o1
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
20133b8: 10 80 00 3f b 20134b4 <rtems_rfs_rtems_fstat+0x268>
20133bc: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
20133c0: c6 08 60 10 ldub [ %g1 + 0x10 ], %g3
20133c4: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
20133c8: 87 28 e0 18 sll %g3, 0x18, %g3
20133cc: 85 28 a0 10 sll %g2, 0x10, %g2
20133d0: 84 10 c0 02 or %g3, %g2, %g2
20133d4: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
20133d8: 84 10 80 03 or %g2, %g3, %g2
20133dc: c6 08 60 12 ldub [ %g1 + 0x12 ], %g3
20133e0: 87 28 e0 08 sll %g3, 8, %g3
20133e4: 84 10 80 03 or %g2, %g3, %g2
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
}
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
20133e8: 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);
20133ec: c6 08 60 14 ldub [ %g1 + 0x14 ], %g3
20133f0: c4 08 60 15 ldub [ %g1 + 0x15 ], %g2
20133f4: 87 28 e0 18 sll %g3, 0x18, %g3
20133f8: 85 28 a0 10 sll %g2, 0x10, %g2
20133fc: 84 10 c0 02 or %g3, %g2, %g2
2013400: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
2013404: 84 10 80 03 or %g2, %g3, %g2
2013408: c6 08 60 16 ldub [ %g1 + 0x16 ], %g3
201340c: 87 28 e0 08 sll %g3, 8, %g3
2013410: 84 10 80 03 or %g2, %g3, %g2
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
2013414: 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);
2013418: c6 08 60 18 ldub [ %g1 + 0x18 ], %g3
201341c: c4 08 60 19 ldub [ %g1 + 0x19 ], %g2
2013420: 87 28 e0 18 sll %g3, 0x18, %g3
2013424: 85 28 a0 10 sll %g2, 0x10, %g2
2013428: 84 10 c0 02 or %g3, %g2, %g2
201342c: c6 08 60 1b ldub [ %g1 + 0x1b ], %g3
2013430: 84 10 80 03 or %g2, %g3, %g2
2013434: c6 08 60 1a ldub [ %g1 + 0x1a ], %g3
2013438: 87 28 e0 08 sll %g3, 8, %g3
201343c: 84 10 80 03 or %g2, %g3, %g2
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
2013440: 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);
2013444: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
2013448: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
201344c: 87 28 e0 18 sll %g3, 0x18, %g3
2013450: 85 28 a0 10 sll %g2, 0x10, %g2
2013454: 84 10 c0 02 or %g3, %g2, %g2
2013458: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
201345c: 84 10 80 03 or %g2, %g3, %g2
2013460: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
2013464: 87 28 e0 08 sll %g3, 8, %g3
2013468: 84 10 80 03 or %g2, %g3, %g2
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
201346c: c6 06 60 0c ld [ %i1 + 0xc ], %g3
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
2013470: c4 26 60 44 st %g2, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
2013474: 05 00 00 3c sethi %hi(0xf000), %g2
2013478: 86 08 c0 02 and %g3, %g2, %g3
201347c: 05 00 00 28 sethi %hi(0xa000), %g2
2013480: 80 a0 c0 02 cmp %g3, %g2
2013484: 12 80 00 09 bne 20134a8 <rtems_rfs_rtems_fstat+0x25c>
2013488: 90 10 00 1d mov %i5, %o0
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
201348c: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
2013490: c2 08 60 0b ldub [ %g1 + 0xb ], %g1
2013494: 85 28 a0 08 sll %g2, 8, %g2
2013498: 82 10 40 02 or %g1, %g2, %g1
201349c: c0 26 60 20 clr [ %i1 + 0x20 ]
20134a0: 10 80 00 05 b 20134b4 <rtems_rfs_rtems_fstat+0x268>
20134a4: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
20134a8: 7f ff fc 29 call 201254c <rtems_rfs_inode_get_size>
20134ac: 92 07 bf d8 add %fp, -40, %o1
20134b0: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
20134b4: c2 07 60 08 ld [ %i5 + 8 ], %g1
rc = rtems_rfs_inode_close (fs, &inode);
20134b8: 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);
20134bc: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
rc = rtems_rfs_inode_close (fs, &inode);
20134c0: 92 07 bf d8 add %fp, -40, %o1
20134c4: 7f ff fa 7a call 2011eac <rtems_rfs_inode_close>
20134c8: b0 10 20 00 clr %i0
if (rc > 0)
20134cc: 80 a2 20 00 cmp %o0, 0
20134d0: 04 80 00 05 ble 20134e4 <rtems_rfs_rtems_fstat+0x298> <== ALWAYS TAKEN
20134d4: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
20134d8: 40 00 35 52 call 2020a20 <__errno> <== NOT EXECUTED
20134dc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20134e0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
20134e4: 81 c7 e0 08 ret
20134e8: 81 e8 00 00 restore
02012d44 <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
2012d44: 9d e3 bf 98 save %sp, -104, %sp
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
2012d48: 3b 00 80 cb sethi %hi(0x2032c00), %i5
if (strncmp (options, "hold-bitmaps",
2012d4c: 35 00 80 cb sethi %hi(0x2032c00), %i2
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
2012d50: 21 00 80 cb sethi %hi(0x2032c00), %l0
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
2012d54: 23 00 80 cb sethi %hi(0x2032c00), %l1
const void* data)
{
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
uint32_t flags = 0;
uint32_t max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
2012d58: b6 10 20 05 mov 5, %i3
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
uint32_t flags = 0;
2012d5c: b8 10 20 00 clr %i4
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
2012d60: ba 17 61 18 or %i5, 0x118, %i5
if (strncmp (options, "hold-bitmaps",
2012d64: b4 16 a1 28 or %i2, 0x128, %i2
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
2012d68: a0 14 21 38 or %l0, 0x138, %l0
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
2012d6c: 10 80 00 2f b 2012e28 <rtems_rfs_rtems_initialise+0xe4>
2012d70: a2 14 61 48 or %l1, 0x148, %l1
{
printf ("options=%s\n", options);
2012d74: 40 00 3c 84 call 2021f84 <printf> <== NOT EXECUTED
2012d78: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
2012d7c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2012d80: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2012d84: 40 00 41 45 call 2023298 <strncmp> <== NOT EXECUTED
2012d88: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
2012d8c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2012d90: 12 80 00 04 bne 2012da0 <rtems_rfs_rtems_initialise+0x5c> <== NOT EXECUTED
2012d94: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
2012d98: 10 80 00 1a b 2012e00 <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
2012d9c: b8 17 20 01 or %i4, 1, %i4 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
2012da0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2012da4: 40 00 41 3d call 2023298 <strncmp> <== NOT EXECUTED
2012da8: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
2012dac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2012db0: 12 80 00 04 bne 2012dc0 <rtems_rfs_rtems_initialise+0x7c> <== NOT EXECUTED
2012db4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
2012db8: 10 80 00 12 b 2012e00 <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
2012dbc: b8 17 20 02 or %i4, 2, %i4 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
2012dc0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2012dc4: 40 00 41 35 call 2023298 <strncmp> <== NOT EXECUTED
2012dc8: 94 10 20 0d mov 0xd, %o2 <== NOT EXECUTED
2012dcc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2012dd0: 12 80 00 07 bne 2012dec <rtems_rfs_rtems_initialise+0xa8> <== NOT EXECUTED
2012dd4: 92 10 20 00 clr %o1 <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
2012dd8: 90 06 60 0e add %i1, 0xe, %o0 <== NOT EXECUTED
2012ddc: 40 00 42 0e call 2023614 <strtoul> <== NOT EXECUTED
2012de0: 94 10 20 00 clr %o2 <== NOT EXECUTED
2012de4: 10 80 00 06 b 2012dfc <rtems_rfs_rtems_initialise+0xb8> <== NOT EXECUTED
2012de8: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
2012dec: 40 00 37 0d call 2020a20 <__errno> <== NOT EXECUTED
2012df0: 01 00 00 00 nop <== NOT EXECUTED
2012df4: 10 80 00 18 b 2012e54 <rtems_rfs_rtems_initialise+0x110> <== NOT EXECUTED
2012df8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
options = strchr (options, ',');
2012dfc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2012e00: 40 00 3e 8a call 2022828 <strchr> <== NOT EXECUTED
2012e04: 92 10 20 2c mov 0x2c, %o1 <== NOT EXECUTED
if (options)
2012e08: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
2012e0c: 02 80 00 0a be 2012e34 <rtems_rfs_rtems_initialise+0xf0> <== NOT EXECUTED
2012e10: 01 00 00 00 nop <== NOT EXECUTED
{
++options;
if (*options == '\0')
2012e14: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1 <== NOT EXECUTED
2012e18: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2012e1c: 02 80 00 06 be 2012e34 <rtems_rfs_rtems_initialise+0xf0> <== NOT EXECUTED
2012e20: 01 00 00 00 nop <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
options = strchr (options, ',');
if (options)
{
++options;
2012e24: b2 06 60 01 inc %i1 <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
2012e28: 80 a6 60 00 cmp %i1, 0
2012e2c: 12 bf ff d2 bne 2012d74 <rtems_rfs_rtems_initialise+0x30> <== NEVER TAKEN
2012e30: 92 10 00 19 mov %i1, %o1
if (*options == '\0')
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
2012e34: 7f ff d5 fd call 2008628 <malloc>
2012e38: 90 10 20 04 mov 4, %o0
if (!rtems)
2012e3c: ba 92 20 00 orcc %o0, 0, %i5
2012e40: 12 80 00 08 bne 2012e60 <rtems_rfs_rtems_initialise+0x11c><== ALWAYS TAKEN
2012e44: 01 00 00 00 nop
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
2012e48: 40 00 36 f6 call 2020a20 <__errno> <== NOT EXECUTED
2012e4c: 01 00 00 00 nop <== NOT EXECUTED
2012e50: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
2012e54: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2012e58: 81 c7 e0 08 ret <== NOT EXECUTED
2012e5c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
rc = rtems_rfs_mutex_create (&rtems->access);
2012e60: 40 00 30 11 call 201eea4 <rtems_rfs_mutex_create>
2012e64: c0 27 40 00 clr [ %i5 ]
if (rc > 0)
2012e68: b4 92 20 00 orcc %o0, 0, %i2
2012e6c: 14 80 00 09 bg 2012e90 <rtems_rfs_rtems_initialise+0x14c> <== NEVER TAKEN
2012e70: 01 00 00 00 nop
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
}
rc = rtems_rfs_mutex_lock (&rtems->access);
2012e74: 7f ff ff 96 call 2012ccc <rtems_rfs_mutex_lock.isra.2>
2012e78: d0 07 40 00 ld [ %i5 ], %o0
if (rc > 0)
2012e7c: b4 92 20 00 orcc %o0, 0, %i2
2012e80: 24 80 00 0b ble,a 2012eac <rtems_rfs_rtems_initialise+0x168><== ALWAYS TAKEN
2012e84: d0 06 20 38 ld [ %i0 + 0x38 ], %o0
{
rtems_rfs_mutex_destroy (&rtems->access);
2012e88: 40 00 30 22 call 201ef10 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
2012e8c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free (rtems);
2012e90: 7f ff d4 55 call 2007fe4 <free> <== NOT EXECUTED
2012e94: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
2012e98: 40 00 36 e2 call 2020a20 <__errno> <== NOT EXECUTED
2012e9c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012ea0: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
2012ea4: 81 c7 e0 08 ret <== NOT EXECUTED
2012ea8: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
2012eac: 94 10 00 1c mov %i4, %o2
2012eb0: 92 10 00 1d mov %i5, %o1
2012eb4: 96 10 00 1b mov %i3, %o3
2012eb8: 40 00 2b 75 call 201dc8c <rtems_rfs_fs_open>
2012ebc: 98 07 bf fc add %fp, -4, %o4
if (rc)
2012ec0: b8 92 20 00 orcc %o0, 0, %i4
2012ec4: 02 80 00 09 be 2012ee8 <rtems_rfs_rtems_initialise+0x1a4> <== ALWAYS TAKEN
2012ec8: d0 07 bf fc ld [ %fp + -4 ], %o0
{
free (rtems);
2012ecc: 7f ff d4 46 call 2007fe4 <free> <== NOT EXECUTED
2012ed0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
2012ed4: 40 00 36 d3 call 2020a20 <__errno> <== NOT EXECUTED
2012ed8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012edc: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2012ee0: 81 c7 e0 08 ret <== NOT EXECUTED
2012ee4: 81 e8 00 00 restore <== NOT EXECUTED
}
mt_entry->fs_info = fs;
mt_entry->ops = &rtems_rfs_ops;
2012ee8: 03 00 80 cb sethi %hi(0x2032c00), %g1
2012eec: 82 10 61 58 or %g1, 0x158, %g1 ! 2032d58 <rtems_rfs_ops>
2012ef0: c2 26 20 0c st %g1, [ %i0 + 0xc ]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
2012ef4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
2012ef8: d0 26 20 08 st %o0, [ %i0 + 8 ]
mt_entry->ops = &rtems_rfs_ops;
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
2012efc: 84 10 20 01 mov 1, %g2
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
2012f00: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
2012f04: c4 20 60 08 st %g2, [ %g1 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
2012f08: 05 00 80 d2 sethi %hi(0x2034800), %g2
2012f0c: 84 10 a3 b0 or %g2, 0x3b0, %g2 ! 2034bb0 <rtems_rfs_rtems_dir_handlers>
rtems_rfs_buffers_release (fs);
2012f10: 40 00 22 60 call 201b890 <rtems_rfs_buffers_release>
2012f14: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
rtems_rfs_mutex_unlock (&rtems->access);
2012f18: d0 07 40 00 ld [ %i5 ], %o0
2012f1c: 7f ff ff 56 call 2012c74 <rtems_rfs_mutex_unlock.isra.1>
2012f20: b0 10 20 00 clr %i0
rtems_rfs_rtems_unlock (fs);
return 0;
}
2012f24: 81 c7 e0 08 ret
2012f28: 81 e8 00 00 restore
020126f0 <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)
{
20126f0: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
20126f4: 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);
20126f8: d6 06 20 08 ld [ %i0 + 8 ], %o3
20126fc: d0 00 60 08 ld [ %g1 + 8 ], %o0
2012700: d8 06 60 08 ld [ %i1 + 8 ], %o4
2012704: 92 10 00 1a mov %i2, %o1
2012708: 94 10 00 1b mov %i3, %o2
201270c: 9a 10 20 00 clr %o5
2012710: 40 00 2f 86 call 201e528 <rtems_rfs_link>
2012714: b0 10 20 00 clr %i0
if (rc)
2012718: 80 a2 20 00 cmp %o0, 0
201271c: 02 80 00 05 be 2012730 <rtems_rfs_rtems_link+0x40> <== ALWAYS TAKEN
2012720: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("link: linking", rc);
2012724: 40 00 38 bf call 2020a20 <__errno> <== NOT EXECUTED
2012728: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201272c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2012730: 81 c7 e0 08 ret
2012734: 81 e8 00 00 restore
0201f3e8 <rtems_rfs_rtems_lock>:
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
201f3e8: 9d e3 bf a0 save %sp, -96, %sp
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
201f3ec: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
201f3f0: 92 10 20 00 clr %o1
201f3f4: d0 00 40 00 ld [ %g1 ], %o0
201f3f8: 7f ff b5 8d call 200ca2c <rtems_semaphore_obtain>
201f3fc: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
201f400: ba 92 20 00 orcc %o0, 0, %i5
201f404: 02 80 00 0c be 201f434 <rtems_rfs_rtems_lock+0x4c> <== ALWAYS TAKEN
201f408: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
201f40c: 7f ff d0 bf call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201f410: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201f414: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201f418: 02 80 00 07 be 201f434 <rtems_rfs_rtems_lock+0x4c> <== NOT EXECUTED
201f41c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
201f420: 7f ff a2 55 call 2007d74 <rtems_status_text> <== NOT EXECUTED
201f424: 31 00 80 cb sethi %hi(0x2032c00), %i0 <== NOT EXECUTED
201f428: b0 16 20 f0 or %i0, 0xf0, %i0 ! 2032cf0 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
201f42c: 40 00 0a d6 call 2021f84 <printf> <== NOT EXECUTED
201f430: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
201f434: 81 c7 e0 08 ret
201f438: 81 e8 00 00 restore
02012a80 <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)
{
2012a80: 9d e3 bf 60 save %sp, -160, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
2012a84: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
2012a88: f0 06 20 08 ld [ %i0 + 8 ], %i0
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
2012a8c: 40 00 10 c5 call 2016da0 <geteuid>
2012a90: e0 00 60 08 ld [ %g1 + 8 ], %l0
gid = getegid ();
2012a94: 40 00 10 bf call 2016d90 <getegid>
2012a98: a4 10 00 08 mov %o0, %l2
2012a9c: a2 10 00 08 mov %o0, %l1
#else
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
2012aa0: 40 00 03 15 call 20136f4 <rtems_rfs_rtems_imode>
2012aa4: 90 10 00 1b mov %i3, %o0
2012aa8: 82 07 bf d4 add %fp, -44, %g1
2012aac: 99 2a 20 10 sll %o0, 0x10, %o4
2012ab0: 96 10 00 1a mov %i2, %o3
2012ab4: a5 2c a0 10 sll %l2, 0x10, %l2
2012ab8: a3 2c 60 10 sll %l1, 0x10, %l1
2012abc: a5 34 a0 10 srl %l2, 0x10, %l2
2012ac0: a3 34 60 10 srl %l1, 0x10, %l1
2012ac4: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
2012ac8: e2 23 a0 60 st %l1, [ %sp + 0x60 ]
2012acc: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
2012ad0: 90 10 00 10 mov %l0, %o0
2012ad4: 92 10 00 18 mov %i0, %o1
2012ad8: 94 10 00 19 mov %i1, %o2
2012adc: 99 33 20 10 srl %o4, 0x10, %o4
2012ae0: 7f ff fd c8 call 2012200 <rtems_rfs_inode_create>
2012ae4: 9a 10 20 01 mov 1, %o5
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
2012ae8: b4 92 20 00 orcc %o0, 0, %i2
2012aec: 14 80 00 09 bg 2012b10 <rtems_rfs_rtems_mknod+0x90>
2012af0: d2 07 bf d4 ld [ %fp + -44 ], %o1
{
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2012af4: 90 10 00 10 mov %l0, %o0
2012af8: 94 07 bf d8 add %fp, -40, %o2
2012afc: 7f ff fc 7a call 2011ce4 <rtems_rfs_inode_open>
2012b00: 96 10 20 01 mov 1, %o3
if (rc > 0)
2012b04: b4 92 20 00 orcc %o0, 0, %i2
2012b08: 04 80 00 07 ble 2012b24 <rtems_rfs_rtems_mknod+0xa4> <== ALWAYS TAKEN
2012b0c: 03 00 00 3c sethi %hi(0xf000), %g1
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
2012b10: 40 00 37 c4 call 2020a20 <__errno>
2012b14: b0 10 3f ff mov -1, %i0
2012b18: f4 22 00 00 st %i2, [ %o0 ]
2012b1c: 81 c7 e0 08 ret
2012b20: 81 e8 00 00 restore
}
if (S_ISDIR(mode) || S_ISREG(mode))
2012b24: 05 00 00 20 sethi %hi(0x8000), %g2
2012b28: 82 0e c0 01 and %i3, %g1, %g1
2012b2c: 80 a0 40 02 cmp %g1, %g2
2012b30: 02 80 00 1c be 2012ba0 <rtems_rfs_rtems_mknod+0x120>
2012b34: 05 00 00 10 sethi %hi(0x4000), %g2
2012b38: 80 a0 40 02 cmp %g1, %g2
2012b3c: 02 80 00 19 be 2012ba0 <rtems_rfs_rtems_mknod+0x120> <== ALWAYS TAKEN
2012b40: 03 00 00 2c sethi %hi(0xb000), %g1
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
2012b44: b6 0e c0 01 and %i3, %g1, %i3 <== NOT EXECUTED
2012b48: 03 00 00 08 sethi %hi(0x2000), %g1 <== NOT EXECUTED
2012b4c: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
2012b50: 12 80 00 0b bne 2012b7c <rtems_rfs_rtems_mknod+0xfc> <== NOT EXECUTED
2012b54: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
{
int major;
int minor;
rtems_filesystem_split_dev_t (dev, major, minor);
rtems_rfs_inode_set_block (&inode, 0, major);
2012b58: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2012b5c: 7f ff fe ac call 201260c <rtems_rfs_inode_set_block> <== NOT EXECUTED
2012b60: 92 10 20 00 clr %o1 <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 1, minor);
2012b64: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
2012b68: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2012b6c: 7f ff fe a8 call 201260c <rtems_rfs_inode_set_block> <== NOT EXECUTED
2012b70: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
}
rc = rtems_rfs_inode_close (fs, &inode);
2012b74: 10 80 00 0c b 2012ba4 <rtems_rfs_rtems_mknod+0x124> <== NOT EXECUTED
2012b78: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 0, major);
rtems_rfs_inode_set_block (&inode, 1, minor);
}
else
{
rtems_rfs_inode_close (fs, &inode);
2012b7c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2012b80: 7f ff fc cb call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
2012b84: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
2012b88: 40 00 37 a6 call 2020a20 <__errno> <== NOT EXECUTED
2012b8c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012b90: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2012b94: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2012b98: 81 c7 e0 08 ret <== NOT EXECUTED
2012b9c: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
2012ba0: 90 10 00 10 mov %l0, %o0
2012ba4: 92 07 bf d8 add %fp, -40, %o1
2012ba8: 7f ff fc c1 call 2011eac <rtems_rfs_inode_close>
2012bac: b0 10 20 00 clr %i0
if (rc > 0)
2012bb0: 80 a2 20 00 cmp %o0, 0
2012bb4: 04 80 00 05 ble 2012bc8 <rtems_rfs_rtems_mknod+0x148> <== ALWAYS TAKEN
2012bb8: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
2012bbc: 40 00 37 99 call 2020a20 <__errno> <== NOT EXECUTED
2012bc0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012bc4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2012bc8: 81 c7 e0 08 ret
2012bcc: 81 e8 00 00 restore
02012fb0 <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)
{
2012fb0: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2012fb4: 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);
2012fb8: 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);
2012fbc: fa 00 60 08 ld [ %g1 + 8 ], %i5
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_filesystem_node_types_t type;
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2012fc0: 94 07 bf d8 add %fp, -40, %o2
2012fc4: 90 10 00 1d mov %i5, %o0
2012fc8: 7f ff fb 47 call 2011ce4 <rtems_rfs_inode_open>
2012fcc: 96 10 20 01 mov 1, %o3
if (rc > 0)
2012fd0: b8 92 20 00 orcc %o0, 0, %i4
2012fd4: 04 80 00 07 ble 2012ff0 <rtems_rfs_rtems_node_type+0x40> <== ALWAYS TAKEN
2012fd8: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
2012fdc: 40 00 36 91 call 2020a20 <__errno> <== NOT EXECUTED
2012fe0: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2012fe4: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2012fe8: 81 c7 e0 08 ret <== NOT EXECUTED
2012fec: 81 e8 00 00 restore <== NOT EXECUTED
}
type = rtems_rfs_rtems_node_type_by_inode (&inode);
2012ff0: 7f ff ff cf call 2012f2c <rtems_rfs_rtems_node_type_by_inode>
2012ff4: 90 07 bf d8 add %fp, -40, %o0
rc = rtems_rfs_inode_close (fs, &inode);
2012ff8: 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);
2012ffc: b0 10 00 08 mov %o0, %i0
rc = rtems_rfs_inode_close (fs, &inode);
2013000: 7f ff fb ab call 2011eac <rtems_rfs_inode_close>
2013004: 90 10 00 1d mov %i5, %o0
if (rc > 0)
2013008: ba 92 20 00 orcc %o0, 0, %i5
201300c: 04 80 00 05 ble 2013020 <rtems_rfs_rtems_node_type+0x70> <== ALWAYS TAKEN
2013010: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
2013014: 40 00 36 83 call 2020a20 <__errno> <== NOT EXECUTED
2013018: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
201301c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return type;
}
2013020: 81 c7 e0 08 ret
2013024: 81 e8 00 00 restore
02012808 <rtems_rfs_rtems_readlink>:
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
2012808: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
201280c: 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);
2012810: d2 06 20 08 ld [ %i0 + 8 ], %o1
2012814: d0 00 60 08 ld [ %g1 + 8 ], %o0
2012818: 94 10 00 19 mov %i1, %o2
201281c: 96 10 00 1a mov %i2, %o3
2012820: 40 00 31 30 call 201ece0 <rtems_rfs_symlink_read>
2012824: 98 07 bf fc add %fp, -4, %o4
if (rc)
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
return (ssize_t) length;
2012828: 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)
201282c: 80 a2 20 00 cmp %o0, 0
2012830: 02 80 00 05 be 2012844 <rtems_rfs_rtems_readlink+0x3c> <== ALWAYS TAKEN
2012834: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
2012838: 40 00 38 7a call 2020a20 <__errno> <== NOT EXECUTED
201283c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012840: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return (ssize_t) length;
}
2012844: 81 c7 e0 08 ret
2012848: 81 e8 00 00 restore
02012738 <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)
{
2012738: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
201273c: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 <== NOT EXECUTED
rtems_rfs_ino new_parent;
rtems_rfs_ino ino;
uint32_t doff;
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
2012740: e0 06 20 08 ld [ %i0 + 8 ], %l0 <== NOT EXECUTED
const rtems_filesystem_location_info_t* old_loc,
const rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name,
size_t new_name_len)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
2012744: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
2012748: f0 06 60 08 ld [ %i1 + 8 ], %i0 <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, new_name_len, new_parent, ino, true);
201274c: d6 06 a0 08 ld [ %i2 + 8 ], %o3 <== NOT EXECUTED
2012750: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
doff = rtems_rfs_rtems_get_pathloc_doff (old_loc);
2012754: f2 06 60 0c ld [ %i1 + 0xc ], %i1 <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, new_name_len, new_parent, ino, true);
2012758: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201275c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2012760: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
2012764: 40 00 2f 71 call 201e528 <rtems_rfs_link> <== NOT EXECUTED
2012768: 9a 10 20 01 mov 1, %o5 <== NOT EXECUTED
if (rc)
201276c: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2012770: 02 80 00 07 be 201278c <rtems_rfs_rtems_rename+0x54> <== NOT EXECUTED
2012774: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: linking", rc);
2012778: 40 00 38 aa call 2020a20 <__errno> <== NOT EXECUTED
201277c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012780: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2012784: 81 c7 e0 08 ret <== NOT EXECUTED
2012788: 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,
201278c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2012790: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2012794: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
2012798: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
201279c: 40 00 2f cc call 201e6cc <rtems_rfs_unlink> <== NOT EXECUTED
20127a0: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
20127a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20127a8: 02 80 00 05 be 20127bc <rtems_rfs_rtems_rename+0x84> <== NOT EXECUTED
20127ac: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
20127b0: 40 00 38 9c call 2020a20 <__errno> <== NOT EXECUTED
20127b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20127b8: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
20127bc: 81 c7 e0 08 ret <== NOT EXECUTED
20127c0: 81 e8 00 00 restore <== NOT EXECUTED
0201363c <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
201363c: 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);
2013640: c2 06 60 0c ld [ %i1 + 0xc ], %g1
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
2013644: 05 00 00 10 sethi %hi(0x4000), %g2
2013648: d2 08 60 02 ldub [ %g1 + 2 ], %o1
201364c: c2 08 60 03 ldub [ %g1 + 3 ], %g1
2013650: 93 2a 60 08 sll %o1, 8, %o1
2013654: 92 12 40 01 or %o1, %g1, %o1
2013658: 03 00 00 3c sethi %hi(0xf000), %g1
201365c: 82 0a 40 01 and %o1, %g1, %g1
2013660: 80 a0 40 02 cmp %g1, %g2
2013664: 12 80 00 05 bne 2013678 <rtems_rfs_rtems_set_handlers+0x3c>
2013668: c0 26 20 10 clr [ %i0 + 0x10 ]
loc->handlers = rtems_rfs_rtems_handlers (dir);
201366c: 03 00 80 d2 sethi %hi(0x2034800), %g1
2013670: 10 80 00 0a b 2013698 <rtems_rfs_rtems_set_handlers+0x5c>
2013674: 82 10 63 b0 or %g1, 0x3b0, %g1 ! 2034bb0 <rtems_rfs_rtems_dir_handlers>
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
2013678: 07 00 00 2c sethi %hi(0xb000), %g3
201367c: 05 00 00 08 sethi %hi(0x2000), %g2
2013680: 86 0a 40 03 and %o1, %g3, %g3
2013684: 80 a0 c0 02 cmp %g3, %g2
2013688: 12 80 00 07 bne 20136a4 <rtems_rfs_rtems_set_handlers+0x68><== ALWAYS TAKEN
201368c: 05 00 00 28 sethi %hi(0xa000), %g2
loc->handlers = rtems_rfs_rtems_handlers (device);
2013690: 03 00 80 d2 sethi %hi(0x2034800), %g1 <== NOT EXECUTED
2013694: 82 10 63 84 or %g1, 0x384, %g1 ! 2034b84 <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
2013698: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
201369c: 10 80 00 13 b 20136e8 <rtems_rfs_rtems_set_handlers+0xac>
20136a0: b0 10 20 01 mov 1, %i0
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
20136a4: 80 a0 40 02 cmp %g1, %g2
20136a8: 12 80 00 05 bne 20136bc <rtems_rfs_rtems_set_handlers+0x80>
20136ac: 05 00 00 20 sethi %hi(0x8000), %g2
loc->handlers = rtems_rfs_rtems_handlers (link);
20136b0: 03 00 80 cb sethi %hi(0x2032c00), %g1
20136b4: 10 bf ff f9 b 2013698 <rtems_rfs_rtems_set_handlers+0x5c>
20136b8: 82 10 61 ac or %g1, 0x1ac, %g1 ! 2032dac <rtems_rfs_rtems_link_handlers>
else if (RTEMS_RFS_S_ISREG (mode))
20136bc: 80 a0 40 02 cmp %g1, %g2
20136c0: 32 80 00 05 bne,a 20136d4 <rtems_rfs_rtems_set_handlers+0x98><== NEVER TAKEN
20136c4: 93 2a 60 10 sll %o1, 0x10, %o1 <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (file);
20136c8: 03 00 80 d2 sethi %hi(0x2034800), %g1
20136cc: 10 bf ff f3 b 2013698 <rtems_rfs_rtems_set_handlers+0x5c>
20136d0: 82 10 63 dc or %g1, 0x3dc, %g1 ! 2034bdc <rtems_rfs_rtems_file_handlers>
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
20136d4: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
20136d8: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
20136dc: 90 12 21 e0 or %o0, 0x1e0, %o0 <== NOT EXECUTED
20136e0: 40 00 3a 29 call 2021f84 <printf> <== NOT EXECUTED
20136e4: b0 10 20 00 clr %i0 <== NOT EXECUTED
return false;
}
return true;
}
20136e8: b0 0e 20 01 and %i0, 1, %i0
20136ec: 81 c7 e0 08 ret
20136f0: 81 e8 00 00 restore
0201265c <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
201265c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2012660: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
2012664: 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);
2012668: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
201266c: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
2012670: 7f ff fd 3b call 2011b5c <rtems_rfs_group_usage> <== NOT EXECUTED
2012674: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
2012678: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
201267c: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
2012680: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
2012684: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
2012688: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
201268c: c4 26 60 04 st %g2, [ %i1 + 4 ] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
2012690: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
2012694: c4 07 60 04 ld [ %i5 + 4 ], %g2 <== NOT EXECUTED
2012698: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
201269c: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
20126a0: 82 20 80 01 sub %g2, %g1, %g1 <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
20126a4: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
20126a8: c2 26 60 14 st %g1, [ %i1 + 0x14 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
20126ac: c2 26 60 1c st %g1, [ %i1 + 0x1c ] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
20126b0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
20126b4: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
20126b8: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
20126bc: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
20126c0: c2 26 60 24 st %g1, [ %i1 + 0x24 ] <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
20126c4: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
20126c8: 03 0a 02 48 sethi %hi(0x28092000), %g1 <== NOT EXECUTED
20126cc: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_END+0x25c92001><== NOT EXECUTED
20126d0: c2 26 60 2c st %g1, [ %i1 + 0x2c ] <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
20126d4: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
20126d8: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
20126dc: c2 26 60 30 st %g1, [ %i1 + 0x30 ] <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
20126e0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
20126e4: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED
return 0;
}
20126e8: 81 c7 e0 08 ret <== NOT EXECUTED
20126ec: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
0201284c <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)
{
201284c: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
2012850: 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),
2012854: 90 10 00 1b mov %i3, %o0
2012858: 40 00 42 5e call 20231d0 <strlen>
201285c: 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);
2012860: f0 06 20 08 ld [ %i0 + 8 ], %i0
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
2012864: 40 00 11 4f call 2016da0 <geteuid>
2012868: ba 10 00 08 mov %o0, %i5
201286c: 40 00 11 49 call 2016d90 <getegid>
2012870: a0 10 00 08 mov %o0, %l0
2012874: 91 2a 20 10 sll %o0, 0x10, %o0
2012878: 91 32 20 10 srl %o0, 0x10, %o0
201287c: f0 23 a0 60 st %i0, [ %sp + 0x60 ]
2012880: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
2012884: 98 10 00 1d mov %i5, %o4
2012888: 9b 2c 20 10 sll %l0, 0x10, %o5
201288c: 90 10 00 1c mov %i4, %o0
2012890: 92 10 00 19 mov %i1, %o1
2012894: 94 10 00 1a mov %i2, %o2
2012898: 96 10 00 1b mov %i3, %o3
201289c: 9b 33 60 10 srl %o5, 0x10, %o5
20128a0: 40 00 30 77 call 201ea7c <rtems_rfs_symlink>
20128a4: b0 10 20 00 clr %i0
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
20128a8: 80 a2 20 00 cmp %o0, 0
20128ac: 02 80 00 05 be 20128c0 <rtems_rfs_rtems_symlink+0x74> <== ALWAYS TAKEN
20128b0: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
20128b4: 40 00 38 5b call 2020a20 <__errno> <== NOT EXECUTED
20128b8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20128bc: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
20128c0: 81 c7 e0 08 ret
20128c4: 81 e8 00 00 restore
0201f000 <rtems_rfs_rtems_unlock>:
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
201f000: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
201f004: fa 06 20 80 ld [ %i0 + 0x80 ], %i5
rtems_rfs_buffers_release (fs);
201f008: 7f ff f2 22 call 201b890 <rtems_rfs_buffers_release>
201f00c: 90 10 00 18 mov %i0, %o0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
201f010: 7f ff b6 d0 call 200cb50 <rtems_semaphore_release>
201f014: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
201f018: ba 92 20 00 orcc %o0, 0, %i5
201f01c: 02 80 00 0c be 201f04c <rtems_rfs_rtems_unlock+0x4c> <== ALWAYS TAKEN
201f020: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
201f024: 7f ff d1 b9 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201f028: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201f02c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201f030: 02 80 00 07 be 201f04c <rtems_rfs_rtems_unlock+0x4c> <== NOT EXECUTED
201f034: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
201f038: 7f ff a3 4f call 2007d74 <rtems_status_text> <== NOT EXECUTED
201f03c: 31 00 80 cb sethi %hi(0x2032c00), %i0 <== NOT EXECUTED
201f040: b0 16 20 c8 or %i0, 0xc8, %i0 ! 2032cc8 <_CPU_Trap_slot_template+0xc90><== NOT EXECUTED
201f044: 40 00 0b d0 call 2021f84 <printf> <== NOT EXECUTED
201f048: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
201f04c: 81 c7 e0 08 ret
201f050: 81 e8 00 00 restore
020128c8 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
20128c8: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
20128cc: 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);
20128d0: 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);
20128d4: 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);
20128d8: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
20128dc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20128e0: 7f ff fd 01 call 2011ce4 <rtems_rfs_inode_open> <== NOT EXECUTED
20128e4: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
20128e8: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
20128ec: 02 80 00 07 be 2012908 <rtems_rfs_rtems_utime+0x40> <== NOT EXECUTED
20128f0: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: read inode", rc);
20128f4: 40 00 38 4b call 2020a20 <__errno> <== NOT EXECUTED
20128f8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20128fc: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2012900: 81 c7 e0 08 ret <== NOT EXECUTED
2012904: 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);
2012908: 85 36 60 18 srl %i1, 0x18, %g2 <== NOT EXECUTED
201290c: c4 28 60 10 stb %g2, [ %g1 + 0x10 ] <== NOT EXECUTED
2012910: 85 36 60 10 srl %i1, 0x10, %g2 <== NOT EXECUTED
2012914: c4 28 60 11 stb %g2, [ %g1 + 0x11 ] <== NOT EXECUTED
2012918: 85 36 60 08 srl %i1, 8, %g2 <== NOT EXECUTED
201291c: c4 28 60 12 stb %g2, [ %g1 + 0x12 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2012920: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
2012924: c4 2f bf e8 stb %g2, [ %fp + -24 ] <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
2012928: 85 36 a0 18 srl %i2, 0x18, %g2 <== NOT EXECUTED
201292c: c4 28 60 14 stb %g2, [ %g1 + 0x14 ] <== NOT EXECUTED
2012930: 85 36 a0 10 srl %i2, 0x10, %g2 <== NOT EXECUTED
2012934: c4 28 60 15 stb %g2, [ %g1 + 0x15 ] <== NOT EXECUTED
2012938: 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);
201293c: 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);
2012940: 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);
2012944: c4 28 60 16 stb %g2, [ %g1 + 0x16 ] <== NOT EXECUTED
2012948: f4 28 60 17 stb %i2, [ %g1 + 0x17 ] <== NOT EXECUTED
201294c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2012950: 7f ff fd 57 call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
2012954: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (rc)
2012958: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201295c: 02 80 00 05 be 2012970 <rtems_rfs_rtems_utime+0xa8> <== NOT EXECUTED
2012960: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
2012964: 40 00 38 2f call 2020a20 <__errno> <== NOT EXECUTED
2012968: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201296c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2012970: 81 c7 e0 08 ret <== NOT EXECUTED
2012974: 81 e8 00 00 restore <== NOT EXECUTED
0201b134 <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
201b134: 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))
201b138: 90 10 20 00 clr %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
201b13c: fa 06 20 08 ld [ %i0 + 8 ], %i5
201b140: 7f ff e1 72 call 2013708 <rtems_rfs_trace>
201b144: 92 10 20 80 mov 0x80, %o1
201b148: 80 8a 20 ff btst 0xff, %o0
201b14c: 22 80 00 29 be,a 201b1f0 <rtems_rfs_scan_chain+0xbc> <== ALWAYS TAKEN
201b150: 39 00 80 cd sethi %hi(0x2033400), %i4
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
201b154: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
201b158: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201b15c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201b160: 40 00 1b 89 call 2021f84 <printf> <== NOT EXECUTED
201b164: 90 12 22 10 or %o0, 0x210, %o0 <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
201b168: 10 80 00 22 b 201b1f0 <rtems_rfs_scan_chain+0xbc> <== NOT EXECUTED
201b16c: 39 00 80 cd sethi %hi(0x2033400), %i4 <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
201b170: 7f ff e1 66 call 2013708 <rtems_rfs_trace>
201b174: 01 00 00 00 nop
201b178: 80 8a 20 ff btst 0xff, %o0
201b17c: 22 80 00 06 be,a 201b194 <rtems_rfs_scan_chain+0x60> <== ALWAYS TAKEN
201b180: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
201b184: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
201b188: 40 00 1b 7f call 2021f84 <printf> <== NOT EXECUTED
201b18c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
201b190: c2 07 60 34 ld [ %i5 + 0x34 ], %g1 <== NOT EXECUTED
201b194: 80 a0 40 1a cmp %g1, %i2
201b198: 32 80 00 17 bne,a 201b1f4 <rtems_rfs_scan_chain+0xc0>
201b19c: fa 07 60 04 ld [ %i5 + 4 ], %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
201b1a0: 90 10 20 00 clr %o0
201b1a4: 7f ff e1 59 call 2013708 <rtems_rfs_trace>
201b1a8: 92 10 20 80 mov 0x80, %o1
201b1ac: 80 8a 20 ff btst 0xff, %o0
201b1b0: 22 80 00 07 be,a 201b1cc <rtems_rfs_scan_chain+0x98> <== ALWAYS TAKEN
201b1b4: c2 06 40 00 ld [ %i1 ], %g1
printf (": found block=%" PRIuPTR "\n",
201b1b8: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
201b1bc: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201b1c0: 40 00 1b 71 call 2021f84 <printf> <== NOT EXECUTED
201b1c4: 90 12 22 48 or %o0, 0x248, %o0 ! 2033648 <CSWTCH.2+0x168> <== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
201b1c8: 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 );
201b1cc: 90 10 00 1d mov %i5, %o0
201b1d0: 82 00 7f ff add %g1, -1, %g1
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
201b1d4: b0 10 00 1d mov %i5, %i0
201b1d8: 7f ff f4 10 call 2018218 <_Chain_Extract>
201b1dc: c2 26 40 00 st %g1, [ %i1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
201b1e0: c0 27 60 04 clr [ %i5 + 4 ]
201b1e4: c0 27 40 00 clr [ %i5 ]
201b1e8: 81 c7 e0 08 ret
201b1ec: 81 e8 00 00 restore
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
201b1f0: b8 17 22 40 or %i4, 0x240, %i4
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
201b1f4: 90 10 20 00 clr %o0
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
201b1f8: 80 a7 40 18 cmp %i5, %i0
201b1fc: 12 bf ff dd bne 201b170 <rtems_rfs_scan_chain+0x3c>
201b200: 92 10 20 80 mov 0x80, %o1
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
201b204: 7f ff e1 41 call 2013708 <rtems_rfs_trace>
201b208: b0 10 20 00 clr %i0
201b20c: 80 8a 20 ff btst 0xff, %o0
201b210: 02 bf ff f6 be 201b1e8 <rtems_rfs_scan_chain+0xb4> <== ALWAYS TAKEN
201b214: 11 00 80 cd sethi %hi(0x2033400), %o0
printf (": not found\n");
201b218: 40 00 1b f3 call 20221e4 <puts> <== NOT EXECUTED
201b21c: 90 12 22 60 or %o0, 0x260, %o0 ! 2033660 <CSWTCH.2+0x180> <== NOT EXECUTED
return NULL;
}
201b220: 81 c7 e0 08 ret <== NOT EXECUTED
201b224: 81 e8 00 00 restore <== NOT EXECUTED
02019884 <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,
2019884: 9d e3 bf 88 save %sp, -120, %sp
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
2019888: c0 2e 80 00 clrb [ %i2 ]
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
201988c: 90 10 00 18 mov %i0, %o0
2019890: 7f ff ff e8 call 2019830 <rtems_rfs_bitmap_load_map>
2019894: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
2019898: 80 a2 20 00 cmp %o0, 0
201989c: 14 80 00 98 bg 2019afc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x278><== NEVER TAKEN
20198a0: a1 2e e0 0b sll %i3, 0xb, %l0
return rc;
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
20198a4: fa 06 40 00 ld [ %i1 ], %i5
end_bit = test_bit + (window * direction);
if (end_bit < 0)
20198a8: a0 84 00 1d addcc %l0, %i5, %l0
20198ac: 2c 80 00 08 bneg,a 20198cc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48>
20198b0: a0 10 20 00 clr %l0
end_bit = 0;
else if (end_bit >= control->size)
20198b4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
20198b8: 80 a4 00 01 cmp %l0, %g1
20198bc: 3a 80 00 04 bcc,a 20198cc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48>
20198c0: 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];
20198c4: 10 80 00 03 b 20198d0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
20198c8: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
20198cc: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
map_bits = &map[map_index];
20198d0: e2 07 bf fc ld [ %fp + -4 ], %l1
if (end_bit < 0)
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
20198d4: b9 3f 60 05 sra %i5, 5, %i4
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
20198d8: a7 3f 60 0a sra %i5, 0xa, %l3
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
20198dc: a4 0f 60 1f and %i5, 0x1f, %l2
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
20198e0: a7 2c e0 02 sll %l3, 2, %l3
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
20198e4: 82 0f 20 1f and %i4, 0x1f, %g1
search_bits = &control->search_bits[search_index];
20198e8: a6 00 80 13 add %g2, %l3, %l3
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
20198ec: ad 2e e0 02 sll %i3, 2, %l6
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
map_bits = &map[map_index];
20198f0: 85 2f 20 02 sll %i4, 2, %g2
20198f4: a8 10 20 1f mov 0x1f, %l4
20198f8: 80 a6 e0 00 cmp %i3, 0
20198fc: 04 80 00 03 ble 2019908 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x84>
2019900: a2 04 40 02 add %l1, %g2, %l1
2019904: a8 10 20 00 clr %l4
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
|| ((direction > 0) && (test_bit >= end_bit)))
2019908: ab 3e e0 1f sra %i3, 0x1f, %l5
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
201990c: 89 2e e0 05 sll %i3, 5, %g4
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
|| ((direction > 0) && (test_bit >= end_bit)))
2019910: aa 25 40 1b sub %l5, %i3, %l5
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
2019914: ae 10 20 01 mov 1, %l7
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
2019918: 87 36 e0 1f srl %i3, 0x1f, %g3
|| ((direction > 0) && (test_bit >= end_bit)))
201991c: ab 35 60 1f srl %l5, 0x1f, %l5
*/
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
2019920: 9a 10 20 20 mov 0x20, %o5
/*
* If any bit is clear find that bit and then search the map element. If
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
2019924: d8 04 c0 00 ld [ %l3 ], %o4
2019928: 80 a3 20 00 cmp %o4, 0
201992c: 02 80 00 44 be 2019a3c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1b8>
2019930: 80 a6 e0 00 cmp %i3, 0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2019934: 96 07 00 1b add %i4, %i3, %o3
2019938: 84 10 20 00 clr %g2
201993c: 97 2a e0 05 sll %o3, 5, %o3
2019940: 82 20 40 1c sub %g1, %i4, %g1
2019944: 10 80 00 38 b 2019a24 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0>
2019948: 96 02 c0 14 add %o3, %l4, %o3
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
&& (search_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*search_bits, search_offset))
201994c: 80 8b c0 0c btst %o7, %o4
2019950: 12 80 00 1a bne 20199b8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x134>
2019954: a4 24 80 1d sub %l2, %i5, %l2
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2019958: 10 80 00 1d b 20199cc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x148>
201995c: ba 00 80 0b add %g2, %o3, %i5
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
2019960: 95 2d c0 0a sll %l7, %o2, %o2
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
2019964: 80 8a 80 09 btst %o2, %o1
2019968: 02 80 00 12 be 20199b0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x12c>
201996c: 80 a7 40 10 cmp %i5, %l0
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
2019970: 94 2a 40 0a andn %o1, %o2, %o2
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
{
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
2019974: 80 a2 a0 00 cmp %o2, 0
2019978: 12 80 00 05 bne 201998c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x108>
201997c: d4 24 40 00 st %o2, [ %l1 ]
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
2019980: c2 04 c0 00 ld [ %l3 ], %g1
2019984: 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,
2019988: de 24 c0 00 st %o7, [ %l3 ]
1 << search_offset);
control->free--;
201998c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
2019990: c4 06 00 00 ld [ %i0 ], %g2
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
1 << search_offset);
control->free--;
2019994: 82 00 7f ff add %g1, -1, %g1
2019998: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
*bit = test_bit;
201999c: fa 26 40 00 st %i5, [ %i1 ]
*found = true;
20199a0: 82 10 20 01 mov 1, %g1
20199a4: c2 2e 80 00 stb %g1, [ %i2 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
20199a8: 10 80 00 54 b 2019af8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x274>
20199ac: c2 28 80 00 stb %g1, [ %g2 ]
return 0;
}
if (test_bit == end_bit)
20199b0: 02 80 00 06 be 20199c8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x144>
20199b4: ba 07 40 1b add %i5, %i3, %i5
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
20199b8: 94 04 80 1d add %l2, %i5, %o2
{
/*
* Find the clear bit in the map. Update the search map and map if
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
20199bc: 80 a2 a0 1f cmp %o2, 0x1f
20199c0: 28 bf ff e8 bleu,a 2019960 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xdc><== ALWAYS TAKEN
20199c4: d2 04 40 00 ld [ %l1 ], %o1
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
20199c8: ba 00 80 0b add %g2, %o3, %i5
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
20199cc: a2 04 40 16 add %l1, %l6, %l1
map_index += direction;
20199d0: b8 07 00 1b add %i4, %i3, %i4
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
20199d4: 80 a7 40 10 cmp %i5, %l0
20199d8: 04 80 00 03 ble 20199e4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x160>
20199dc: 9e 10 20 01 mov 1, %o7
20199e0: 9e 10 20 00 clr %o7
20199e4: 80 8b e0 ff btst 0xff, %o7
20199e8: 02 80 00 05 be 20199fc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x178>
20199ec: 84 00 80 04 add %g2, %g4, %g2
20199f0: 80 a0 e0 00 cmp %g3, 0
20199f4: 32 80 00 29 bne,a 2019a98 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x214>
20199f8: a4 10 00 14 mov %l4, %l2
|| ((direction > 0) && (test_bit >= end_bit)))
20199fc: 80 a7 40 10 cmp %i5, %l0
2019a00: 16 80 00 03 bge 2019a0c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x188>
2019a04: 9e 10 20 01 mov 1, %o7
2019a08: 9e 10 20 00 clr %o7
2019a0c: 80 8b e0 ff btst 0xff, %o7
2019a10: 02 80 00 05 be 2019a24 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0>
2019a14: a4 10 00 14 mov %l4, %l2
2019a18: 80 a5 60 00 cmp %l5, 0
2019a1c: 32 80 00 20 bne,a 2019a9c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
2019a20: a6 04 c0 16 add %l3, %l6, %l3
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2019a24: 9e 00 40 1c add %g1, %i4, %o7
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
2019a28: 80 a3 e0 1f cmp %o7, 0x1f
2019a2c: 28 bf ff c8 bleu,a 201994c <rtems_rfs_search_map_for_clear_bit.constprop.1+0xc8>
2019a30: 9f 2d c0 0f sll %l7, %o7, %o7
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
2019a34: 10 80 00 1a b 2019a9c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
2019a38: a6 04 c0 16 add %l3, %l6, %l3
* 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)
2019a3c: 04 80 00 07 ble 2019a58 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1d4>
2019a40: ba 0f 7f e0 and %i5, -32, %i5
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
2019a44: 92 23 40 01 sub %o5, %g1, %o1
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
2019a48: a4 10 20 00 clr %l2
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
2019a4c: 83 2a 60 05 sll %o1, 5, %g1
2019a50: 10 80 00 07 b 2019a6c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e8>
2019a54: ba 00 40 1d add %g1, %i5, %i5
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
2019a58: 92 00 60 01 add %g1, 1, %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;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
2019a5c: a4 10 20 1f mov 0x1f, %l2
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;
2019a60: 83 28 60 05 sll %g1, 5, %g1
2019a64: 82 38 00 01 xnor %g0, %g1, %g1
2019a68: ba 00 40 1d add %g1, %i5, %i5
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
2019a6c: c6 27 bf f4 st %g3, [ %fp + -12 ]
2019a70: c8 27 bf f0 st %g4, [ %fp + -16 ]
2019a74: da 27 bf ec st %o5, [ %fp + -20 ]
2019a78: 7f ff a2 c7 call 2002594 <.umul>
2019a7c: 90 10 00 1b mov %i3, %o0
2019a80: c6 07 bf f4 ld [ %fp + -12 ], %g3
2019a84: 83 2a 20 02 sll %o0, 2, %g1
map_index += direction * bits_skipped;
2019a88: b8 07 00 08 add %i4, %o0, %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;
2019a8c: a2 04 40 01 add %l1, %g1, %l1
2019a90: c8 07 bf f0 ld [ %fp + -16 ], %g4
2019a94: da 07 bf ec ld [ %fp + -20 ], %o5
map_index += direction * bits_skipped;
}
search_bits += direction;
2019a98: a6 04 c0 16 add %l3, %l6, %l3
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
2019a9c: 80 a6 e0 00 cmp %i3, 0
2019aa0: 04 80 00 03 ble 2019aac <rtems_rfs_search_map_for_clear_bit.constprop.1+0x228>
2019aa4: 82 10 20 1f mov 0x1f, %g1
2019aa8: 82 10 20 00 clr %g1
}
while (((direction < 0) && (test_bit >= end_bit))
2019aac: 80 a7 40 10 cmp %i5, %l0
2019ab0: 16 80 00 03 bge 2019abc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x238>
2019ab4: 84 10 20 01 mov 1, %g2
2019ab8: 84 10 20 00 clr %g2
|| ((direction > 0) && (test_bit <= end_bit)));
2019abc: 80 88 a0 ff btst 0xff, %g2
2019ac0: 02 80 00 06 be 2019ad8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x254>
2019ac4: 80 a7 40 10 cmp %i5, %l0
2019ac8: 80 a0 e0 00 cmp %g3, 0
2019acc: 32 bf ff 97 bne,a 2019928 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa4>
2019ad0: d8 04 c0 00 ld [ %l3 ], %o4
2019ad4: 80 a7 40 10 cmp %i5, %l0
2019ad8: 04 80 00 03 ble 2019ae4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x260>
2019adc: 84 10 20 01 mov 1, %g2
2019ae0: 84 10 20 00 clr %g2
2019ae4: 80 88 a0 ff btst 0xff, %g2
2019ae8: 02 80 00 04 be 2019af8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x274>
2019aec: 80 a5 60 00 cmp %l5, 0
2019af0: 32 bf ff 8e bne,a 2019928 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa4>
2019af4: d8 04 c0 00 ld [ %l3 ], %o4
return 0;
2019af8: 90 10 20 00 clr %o0
}
2019afc: 81 c7 e0 08 ret
2019b00: 91 e8 00 08 restore %g0, %o0, %o0
0201ea7c <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
201ea7c: 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))
201ea80: 90 10 20 02 mov 2, %o0
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
201ea84: e2 07 a0 60 ld [ %fp + 0x60 ], %l1
201ea88: 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))
201ea8c: 7f ff d3 1f call 2013708 <rtems_rfs_trace>
201ea90: 92 10 20 00 clr %o1
201ea94: 80 8a 20 ff btst 0xff, %o0
201ea98: 12 80 00 07 bne 201eab4 <rtems_rfs_symlink+0x38> <== NEVER TAKEN
201ea9c: 11 00 80 d2 sethi %hi(0x2034800), %o0
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
201eaa0: c2 06 20 08 ld [ %i0 + 8 ], %g1
201eaa4: 80 a7 00 01 cmp %i4, %g1
201eaa8: 1a 80 00 8b bcc 201ecd4 <rtems_rfs_symlink+0x258> <== NEVER TAKEN
201eaac: b4 10 20 5b mov 0x5b, %i2
201eab0: 30 80 00 19 b,a 201eb14 <rtems_rfs_symlink+0x98>
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
201eab4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
201eab8: 90 12 22 e0 or %o0, 0x2e0, %o0 <== NOT EXECUTED
201eabc: 40 00 0d 32 call 2021f84 <printf> <== NOT EXECUTED
201eac0: a0 10 20 00 clr %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
201eac4: 10 80 00 05 b 201ead8 <rtems_rfs_symlink+0x5c> <== NOT EXECUTED
201eac8: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
201eacc: 40 00 0d 98 call 202212c <putchar> <== NOT EXECUTED
201ead0: 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++)
201ead4: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
201ead8: 26 bf ff fd bl,a 201eacc <rtems_rfs_symlink+0x50> <== NOT EXECUTED
201eadc: d0 4e 40 10 ldsb [ %i1 + %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
201eae0: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
201eae4: b4 10 20 00 clr %i2 <== NOT EXECUTED
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (" link:");
201eae8: 40 00 0d 27 call 2021f84 <printf> <== NOT EXECUTED
201eaec: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
201eaf0: 10 80 00 05 b 201eb04 <rtems_rfs_symlink+0x88> <== NOT EXECUTED
201eaf4: 80 a6 80 1c cmp %i2, %i4 <== NOT EXECUTED
printf ("%c", link[c]);
201eaf8: 40 00 0d 8d call 202212c <putchar> <== NOT EXECUTED
201eafc: 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++)
201eb00: 80 a6 80 1c cmp %i2, %i4 <== NOT EXECUTED
201eb04: 26 bf ff fd bl,a 201eaf8 <rtems_rfs_symlink+0x7c> <== NOT EXECUTED
201eb08: d0 4e c0 1a ldsb [ %i3 + %i2 ], %o0 <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
201eb0c: 10 bf ff e6 b 201eaa4 <rtems_rfs_symlink+0x28> <== NOT EXECUTED
201eb10: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
201eb14: 40 00 11 af call 20231d0 <strlen>
201eb18: 90 10 00 19 mov %i1, %o0
201eb1c: 82 07 bf 74 add %fp, -140, %g1
201eb20: 96 10 00 08 mov %o0, %o3
201eb24: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
201eb28: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
201eb2c: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
201eb30: 90 10 00 18 mov %i0, %o0
201eb34: 92 10 00 11 mov %l1, %o1
201eb38: 94 10 00 19 mov %i1, %o2
201eb3c: 19 00 00 28 sethi %hi(0xa000), %o4
201eb40: 9a 10 20 01 mov 1, %o5
201eb44: 7f ff cd af call 2012200 <rtems_rfs_inode_create>
201eb48: 98 13 21 ff or %o4, 0x1ff, %o4
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
201eb4c: b4 92 20 00 orcc %o0, 0, %i2
201eb50: 34 80 00 62 bg,a 201ecd8 <rtems_rfs_symlink+0x25c> <== NEVER TAKEN
201eb54: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
201eb58: d2 07 bf 74 ld [ %fp + -140 ], %o1
201eb5c: 90 10 00 18 mov %i0, %o0
201eb60: 94 07 bf 88 add %fp, -120, %o2
201eb64: 7f ff cc 60 call 2011ce4 <rtems_rfs_inode_open>
201eb68: 96 10 20 01 mov 1, %o3
if (rc > 0)
201eb6c: b4 92 20 00 orcc %o0, 0, %i2
201eb70: 34 80 00 5a bg,a 201ecd8 <rtems_rfs_symlink+0x25c> <== NEVER TAKEN
201eb74: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
/*
* If the link length is less than the length of data union in the inode
* place the link into the data area else allocate a block and write the link
* to that.
*/
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
201eb78: 80 a7 20 13 cmp %i4, 0x13
201eb7c: 38 80 00 15 bgu,a 201ebd0 <rtems_rfs_symlink+0x154> <== NEVER TAKEN
201eb80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
201eb84: d0 07 bf 94 ld [ %fp + -108 ], %o0
201eb88: 92 10 20 00 clr %o1
201eb8c: 94 10 20 14 mov 0x14, %o2
201eb90: 40 00 0c 7f call 2021d8c <memset>
201eb94: 90 02 20 1c add %o0, 0x1c, %o0
memcpy (inode.node->data.name, link, link_length);
201eb98: d0 07 bf 94 ld [ %fp + -108 ], %o0
201eb9c: 92 10 00 1b mov %i3, %o1
201eba0: 90 02 20 1c add %o0, 0x1c, %o0
201eba4: 40 00 0b eb call 2021b50 <memcpy>
201eba8: 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);
201ebac: c2 07 bf 94 ld [ %fp + -108 ], %g1
201ebb0: c0 28 60 0c clrb [ %g1 + 0xc ]
201ebb4: c2 07 bf 94 ld [ %fp + -108 ], %g1
201ebb8: c0 28 60 0d clrb [ %g1 + 0xd ]
201ebbc: c2 07 bf 94 ld [ %fp + -108 ], %g1
201ebc0: c0 28 60 0e clrb [ %g1 + 0xe ]
201ebc4: c2 07 bf 94 ld [ %fp + -108 ], %g1
201ebc8: 10 80 00 38 b 201eca8 <rtems_rfs_symlink+0x22c>
201ebcc: c0 28 60 0f clrb [ %g1 + 0xf ]
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
uint8_t* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
201ebd0: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
201ebd4: 7f ff ee 1c call 201a444 <rtems_rfs_block_map_open> <== NOT EXECUTED
201ebd8: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
201ebdc: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
if (rc > 0)
201ebe0: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
201ebe4: 14 80 00 2d bg 201ec98 <rtems_rfs_symlink+0x21c> <== NOT EXECUTED
201ebe8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
201ebec: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201ebf0: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
201ebf4: 7f ff ef 6f call 201a9b0 <rtems_rfs_block_map_grow> <== NOT EXECUTED
201ebf8: 96 07 bf 78 add %fp, -136, %o3 <== NOT EXECUTED
if (rc > 0)
201ebfc: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
201ec00: 14 80 00 0c bg 201ec30 <rtems_rfs_symlink+0x1b4> <== NOT EXECUTED
201ec04: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
201ec08: d4 07 bf 78 ld [ %fp + -136 ], %o2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201ec0c: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
201ec10: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
201ec14: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
201ec18: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
201ec1c: 7f ff f1 f7 call 201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201ec20: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
201ec24: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
201ec28: 04 80 00 06 ble 201ec40 <rtems_rfs_symlink+0x1c4> <== NOT EXECUTED
201ec2c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
201ec30: 7f ff ee 66 call 201a5c8 <rtems_rfs_block_map_close> <== NOT EXECUTED
201ec34: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
201ec38: 10 80 00 18 b 201ec98 <rtems_rfs_symlink+0x21c> <== NOT EXECUTED
201ec3c: 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);
201ec40: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
201ec44: 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);
201ec48: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
201ec4c: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
201ec50: 40 00 0c 4f call 2021d8c <memset> <== NOT EXECUTED
201ec54: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
memcpy (data, link, link_length);
201ec58: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201ec5c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201ec60: 40 00 0b bc call 2021b50 <memcpy> <== NOT EXECUTED
201ec64: 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);
201ec68: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
201ec6c: 7f ff f1 6f call 201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201ec70: 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);
201ec74: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
201ec78: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
201ec7c: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
201ec80: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
201ec84: 7f ff ee 51 call 201a5c8 <rtems_rfs_block_map_close> <== NOT EXECUTED
201ec88: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
201ec8c: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
201ec90: 04 80 00 06 ble 201eca8 <rtems_rfs_symlink+0x22c> <== NOT EXECUTED
201ec94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
201ec98: 7f ff cc 85 call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201ec9c: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
201eca0: 81 c7 e0 08 ret <== NOT EXECUTED
201eca4: 91 e8 00 1a restore %g0, %i2, %o0 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
201eca8: c2 07 bf 94 ld [ %fp + -108 ], %g1
201ecac: 85 37 20 08 srl %i4, 8, %g2
201ecb0: c4 28 60 0a stb %g2, [ %g1 + 0xa ]
201ecb4: c2 07 bf 94 ld [ %fp + -108 ], %g1
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
201ecb8: 90 10 00 18 mov %i0, %o0
201ecbc: f8 28 60 0b stb %i4, [ %g1 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201ecc0: 82 10 20 01 mov 1, %g1
201ecc4: 92 07 bf 88 add %fp, -120, %o1
201ecc8: 7f ff cc 79 call 2011eac <rtems_rfs_inode_close>
201eccc: c2 2f bf 98 stb %g1, [ %fp + -104 ]
201ecd0: b4 10 00 08 mov %o0, %i2
return rc;
}
201ecd4: b0 10 00 1a mov %i2, %i0
201ecd8: 81 c7 e0 08 ret
201ecdc: 81 e8 00 00 restore
0201ece0 <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)
{
201ece0: 9d e3 bf 18 save %sp, -232, %sp
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
201ece4: 90 10 20 04 mov 4, %o0
201ece8: 92 10 20 00 clr %o1
201ecec: 7f ff d2 87 call 2013708 <rtems_rfs_trace>
201ecf0: ba 10 00 18 mov %i0, %i5
201ecf4: 80 8a 20 ff btst 0xff, %o0
201ecf8: 22 80 00 07 be,a 201ed14 <rtems_rfs_symlink_read+0x34> <== ALWAYS TAKEN
201ecfc: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
201ed00: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201ed04: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201ed08: 40 00 0c 9f call 2021f84 <printf> <== NOT EXECUTED
201ed0c: 90 12 23 10 or %o0, 0x310, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
201ed10: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ed14: 92 10 00 19 mov %i1, %o1
201ed18: 94 07 bf 88 add %fp, -120, %o2
201ed1c: 7f ff cb f2 call 2011ce4 <rtems_rfs_inode_open>
201ed20: 96 10 20 01 mov 1, %o3
if (rc)
201ed24: b0 92 20 00 orcc %o0, 0, %i0
201ed28: 12 80 00 0d bne 201ed5c <rtems_rfs_symlink_read+0x7c> <== NEVER TAKEN
201ed2c: d2 07 bf 94 ld [ %fp + -108 ], %o1
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
201ed30: 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);
201ed34: c4 0a 60 02 ldub [ %o1 + 2 ], %g2
201ed38: 85 28 a0 08 sll %g2, 8, %g2
201ed3c: 84 08 80 01 and %g2, %g1, %g2
201ed40: 03 00 00 28 sethi %hi(0xa000), %g1
201ed44: 80 a0 80 01 cmp %g2, %g1
201ed48: 02 80 00 07 be 201ed64 <rtems_rfs_symlink_read+0x84> <== ALWAYS TAKEN
201ed4c: 90 10 00 1d mov %i5, %o0
{
rtems_rfs_inode_close (fs, &inode);
201ed50: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
201ed54: 7f ff cc 56 call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201ed58: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
201ed5c: 81 c7 e0 08 ret <== NOT EXECUTED
201ed60: 81 e8 00 00 restore <== NOT EXECUTED
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
201ed64: d4 0a 60 0a ldub [ %o1 + 0xa ], %o2
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
201ed68: c2 0a 60 0b ldub [ %o1 + 0xb ], %g1
201ed6c: 95 2a a0 08 sll %o2, 8, %o2
201ed70: 94 10 40 0a or %g1, %o2, %o2
201ed74: 80 a2 80 1b cmp %o2, %i3
201ed78: 38 80 00 02 bgu,a 201ed80 <rtems_rfs_symlink_read+0xa0>
201ed7c: 94 10 00 1b mov %i3, %o2
201ed80: 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);
201ed84: c2 0a 60 0d ldub [ %o1 + 0xd ], %g1
201ed88: c4 0a 60 0c ldub [ %o1 + 0xc ], %g2
201ed8c: 83 28 60 10 sll %g1, 0x10, %g1
201ed90: 85 28 a0 18 sll %g2, 0x18, %g2
201ed94: 84 10 80 01 or %g2, %g1, %g2
201ed98: c2 0a 60 0f ldub [ %o1 + 0xf ], %g1
201ed9c: 84 10 80 01 or %g2, %g1, %g2
201eda0: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
201eda4: 83 28 60 08 sll %g1, 8, %g1
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
201eda8: 80 90 80 01 orcc %g2, %g1, %g0
201edac: 32 80 00 07 bne,a 201edc8 <rtems_rfs_symlink_read+0xe8> <== NEVER TAKEN
201edb0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
memcpy (path, inode.node->data.name, *length);
201edb4: 90 10 00 1a mov %i2, %o0
201edb8: 40 00 0b 66 call 2021b50 <memcpy>
201edbc: 92 02 60 1c add %o1, 0x1c, %o1
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
201edc0: 10 80 00 34 b 201ee90 <rtems_rfs_symlink_read+0x1b0>
201edc4: 90 10 00 1d mov %i5, %o0
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
char* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
201edc8: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
201edcc: 7f ff ed 9e call 201a444 <rtems_rfs_block_map_open> <== NOT EXECUTED
201edd0: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
201edd4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
if (rc > 0)
201edd8: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
201eddc: 14 80 00 29 bg 201ee80 <rtems_rfs_symlink_read+0x1a0> <== NOT EXECUTED
201ede0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
201ede4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201ede8: 94 10 20 00 clr %o2 <== NOT EXECUTED
201edec: 96 10 20 00 clr %o3 <== NOT EXECUTED
201edf0: 7f ff ee c6 call 201a908 <rtems_rfs_block_map_seek> <== NOT EXECUTED
201edf4: 98 07 bf 78 add %fp, -136, %o4 <== NOT EXECUTED
if (rc > 0)
201edf8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201edfc: 14 80 00 0c bg 201ee2c <rtems_rfs_symlink_read+0x14c> <== NOT EXECUTED
201ee00: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
201ee04: d4 07 bf 78 ld [ %fp + -136 ], %o2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201ee08: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
201ee0c: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
201ee10: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
201ee14: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
201ee18: 7f ff f1 78 call 201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201ee1c: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
201ee20: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201ee24: 04 80 00 06 ble 201ee3c <rtems_rfs_symlink_read+0x15c> <== NOT EXECUTED
201ee28: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
201ee2c: 7f ff ed e7 call 201a5c8 <rtems_rfs_block_map_close> <== NOT EXECUTED
201ee30: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
201ee34: 10 80 00 13 b 201ee80 <rtems_rfs_symlink_read+0x1a0> <== NOT EXECUTED
201ee38: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
201ee3c: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
201ee40: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
201ee44: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
201ee48: 40 00 0b 42 call 2021b50 <memcpy> <== NOT EXECUTED
201ee4c: 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);
201ee50: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
201ee54: 7f ff f0 f5 call 201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201ee58: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
201ee5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
201ee60: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
201ee64: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
201ee68: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
201ee6c: 7f ff ed d7 call 201a5c8 <rtems_rfs_block_map_close> <== NOT EXECUTED
201ee70: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
201ee74: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201ee78: 04 80 00 06 ble 201ee90 <rtems_rfs_symlink_read+0x1b0> <== NOT EXECUTED
201ee7c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
201ee80: 7f ff cc 0b call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201ee84: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
201ee88: 81 c7 e0 08 ret <== NOT EXECUTED
201ee8c: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
201ee90: 7f ff cc 07 call 2011eac <rtems_rfs_inode_close>
201ee94: 92 07 bf 88 add %fp, -120, %o1
201ee98: b0 10 00 08 mov %o0, %i0
return rc;
}
201ee9c: 81 c7 e0 08 ret
201eea0: 81 e8 00 00 restore
02013748 <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;
2013748: 03 00 81 19 sethi %hi(0x2046400), %g1 <== NOT EXECUTED
201374c: c4 18 61 a0 ldd [ %g1 + 0x1a0 ], %g2 ! 20465a0 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
2013750: 90 28 80 08 andn %g2, %o0, %o0 <== NOT EXECUTED
2013754: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
2013758: d0 38 61 a0 std %o0, [ %g1 + 0x1a0 ] <== NOT EXECUTED
return state;
}
201375c: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
2013760: 81 c3 e0 08 retl <== NOT EXECUTED
2013764: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
02013728 <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;
2013728: 03 00 81 19 sethi %hi(0x2046400), %g1 <== NOT EXECUTED
201372c: c4 18 61 a0 ldd [ %g1 + 0x1a0 ], %g2 ! 20465a0 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
2013730: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
2013734: 92 12 40 03 or %o1, %g3, %o1 <== NOT EXECUTED
2013738: d0 38 61 a0 std %o0, [ %g1 + 0x1a0 ] <== NOT EXECUTED
return state;
}
201373c: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
2013740: 81 c3 e0 08 retl <== NOT EXECUTED
2013744: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
02013768 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
2013768: 9d e3 be f8 save %sp, -264, %sp <== NOT EXECUTED
const char* table[] =
201376c: 13 00 80 cc sethi %hi(0x2033000), %o1 <== NOT EXECUTED
2013770: 90 07 bf 64 add %fp, -156, %o0 <== NOT EXECUTED
2013774: 92 12 60 e4 or %o1, 0xe4, %o1 <== NOT EXECUTED
2013778: 94 10 20 9c mov 0x9c, %o2 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
201377c: 27 00 80 c3 sethi %hi(0x2030c00), %l3 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
2013780: 29 00 80 cb sethi %hi(0x2032c00), %l4 <== NOT EXECUTED
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
const char* table[] =
2013784: 40 00 38 f3 call 2021b50 <memcpy> <== NOT EXECUTED
2013788: 2b 00 80 cb sethi %hi(0x2032c00), %l5 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
201378c: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
2013790: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
2013794: b4 10 20 00 clr %i2 <== NOT EXECUTED
2013798: b6 10 20 00 clr %i3 <== NOT EXECUTED
"file-close",
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
201379c: b8 10 20 00 clr %i4 <== NOT EXECUTED
20137a0: ba 10 20 00 clr %i5 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
20137a4: a6 14 e0 18 or %l3, 0x18, %l3 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
20137a8: a8 15 22 78 or %l4, 0x278, %l4 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
20137ac: aa 15 62 80 or %l5, 0x280, %l5 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
20137b0: 10 80 00 68 b 2013950 <rtems_rfs_trace_shell_command+0x1e8><== NOT EXECUTED
20137b4: 25 00 81 19 sethi %hi(0x2046400), %l2 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
20137b8: ec 06 40 01 ld [ %i1 + %g1 ], %l6 <== NOT EXECUTED
20137bc: c2 4d 80 00 ldsb [ %l6 ], %g1 <== NOT EXECUTED
20137c0: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
20137c4: 12 80 00 25 bne 2013858 <rtems_rfs_trace_shell_command+0xf0><== NOT EXECUTED
20137c8: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
{
switch (argv[arg][1])
20137cc: c2 4d a0 01 ldsb [ %l6 + 1 ], %g1 <== NOT EXECUTED
20137d0: 80 a0 60 68 cmp %g1, 0x68 <== NOT EXECUTED
20137d4: 02 80 00 06 be 20137ec <rtems_rfs_trace_shell_command+0x84><== NOT EXECUTED
20137d8: 80 a0 60 6c cmp %g1, 0x6c <== NOT EXECUTED
20137dc: 32 80 00 1a bne,a 2013844 <rtems_rfs_trace_shell_command+0xdc><== NOT EXECUTED
20137e0: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
20137e4: 10 80 00 08 b 2013804 <rtems_rfs_trace_shell_command+0x9c><== NOT EXECUTED
20137e8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
20137ec: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
20137f0: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
20137f4: 40 00 39 e4 call 2021f84 <printf> <== NOT EXECUTED
20137f8: 90 12 22 08 or %o0, 0x208, %o0 ! 2032e08 <rtems_rfs_rtems_eval_config+0x30><== NOT EXECUTED
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
return 0;
20137fc: 81 c7 e0 08 ret <== NOT EXECUTED
2013800: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
2013804: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
2013808: 39 00 80 cb sethi %hi(0x2032c00), %i4 <== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
201380c: 90 12 22 30 or %o0, 0x230, %o0 <== NOT EXECUTED
2013810: 40 00 39 dd call 2021f84 <printf> <== NOT EXECUTED
2013814: ba 10 20 00 clr %i5 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
2013818: b8 17 22 58 or %i4, 0x258, %i4 <== NOT EXECUTED
201381c: 82 07 bf 64 add %fp, -156, %g1 <== NOT EXECUTED
2013820: d2 00 40 1d ld [ %g1 + %i5 ], %o1 <== NOT EXECUTED
2013824: 40 00 39 d8 call 2021f84 <printf> <== NOT EXECUTED
2013828: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201382c: ba 07 60 04 add %i5, 4, %i5 <== NOT EXECUTED
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
2013830: 80 a7 60 9c cmp %i5, 0x9c <== NOT EXECUTED
2013834: 12 bf ff fb bne 2013820 <rtems_rfs_trace_shell_command+0xb8><== NOT EXECUTED
2013838: 82 07 bf 64 add %fp, -156, %g1 <== NOT EXECUTED
printf (" %s\n", table[t]);
return 0;
201383c: 81 c7 e0 08 ret <== NOT EXECUTED
2013840: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
default:
printf ("error: unknown option\n");
return 1;
2013844: 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");
2013848: 40 00 3a 67 call 20221e4 <puts> <== NOT EXECUTED
201384c: 90 12 22 60 or %o0, 0x260, %o0 <== NOT EXECUTED
2013850: 81 c7 e0 08 ret <== NOT EXECUTED
2013854: 81 e8 00 00 restore <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
2013858: 40 00 3c 52 call 20229a0 <strcmp> <== NOT EXECUTED
201385c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
2013860: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2013864: 22 80 00 02 be,a 201386c <rtems_rfs_trace_shell_command+0x104><== NOT EXECUTED
2013868: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
201386c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
2013870: 40 00 3c 4c call 20229a0 <strcmp> <== NOT EXECUTED
2013874: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
2013878: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201387c: 22 80 00 2e be,a 2013934 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
2013880: a2 10 20 00 clr %l1 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
2013884: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
2013888: 40 00 3c 46 call 20229a0 <strcmp> <== NOT EXECUTED
201388c: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
2013890: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2013894: 12 80 00 09 bne 20138b8 <rtems_rfs_trace_shell_command+0x150><== NOT EXECUTED
2013898: 94 10 20 00 clr %o2 <== NOT EXECUTED
{
if (set)
201389c: 80 8c 60 ff btst 0xff, %l1 <== NOT EXECUTED
20138a0: 22 80 00 23 be,a 201392c <rtems_rfs_trace_shell_command+0x1c4><== NOT EXECUTED
20138a4: 35 3f ff ff sethi %hi(0xfffffc00), %i2 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
20138a8: 39 3f ff ff sethi %hi(0xfffffc00), %i4 <== NOT EXECUTED
20138ac: b8 17 23 ff or %i4, 0x3ff, %i4 ! ffffffff <RAM_END+0xfdbfffff><== NOT EXECUTED
20138b0: 10 80 00 21 b 2013934 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
20138b4: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
20138b8: 83 2a a0 02 sll %o2, 2, %g1 <== NOT EXECUTED
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
20138bc: 84 07 bf 64 add %fp, -156, %g2 <== NOT EXECUTED
20138c0: d2 00 80 01 ld [ %g2 + %g1 ], %o1 <== NOT EXECUTED
20138c4: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
20138c8: 40 00 3c 36 call 20229a0 <strcmp> <== NOT EXECUTED
20138cc: d4 27 bf 5c st %o2, [ %fp + -164 ] <== NOT EXECUTED
20138d0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20138d4: 12 80 00 10 bne 2013914 <rtems_rfs_trace_shell_command+0x1ac><== NOT EXECUTED
20138d8: d4 07 bf 5c ld [ %fp + -164 ], %o2 <== NOT EXECUTED
{
if (set)
set_value = 1ULL << t;
20138dc: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
20138e0: 80 8c 60 ff btst 0xff, %l1 <== NOT EXECUTED
20138e4: 02 80 00 07 be 2013900 <rtems_rfs_trace_shell_command+0x198><== NOT EXECUTED
20138e8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
set_value = 1ULL << t;
20138ec: 40 00 6b 05 call 202e500 <__ashldi3> <== NOT EXECUTED
20138f0: 01 00 00 00 nop <== NOT EXECUTED
20138f4: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
20138f8: 10 80 00 0f b 2013934 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
20138fc: ba 10 00 09 mov %o1, %i5 <== NOT EXECUTED
else
clear_value = 1ULL << t;
2013900: 40 00 6b 00 call 202e500 <__ashldi3> <== NOT EXECUTED
2013904: 01 00 00 00 nop <== NOT EXECUTED
2013908: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
201390c: 10 80 00 0a b 2013934 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
2013910: b6 10 00 09 mov %o1, %i3 <== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
2013914: 94 02 a0 01 inc %o2 <== NOT EXECUTED
2013918: 80 a2 a0 27 cmp %o2, 0x27 <== NOT EXECUTED
201391c: 12 bf ff e8 bne 20138bc <rtems_rfs_trace_shell_command+0x154><== NOT EXECUTED
2013920: 83 2a a0 02 sll %o2, 2, %g1 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
2013924: 10 80 00 05 b 2013938 <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED
2013928: c4 1c a1 a0 ldd [ %l2 + 0x1a0 ], %g2 <== NOT EXECUTED
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
201392c: b4 16 a3 ff or %i2, 0x3ff, %i2 <== NOT EXECUTED
2013930: b6 10 00 1a mov %i2, %i3 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
2013934: c4 1c a1 a0 ldd [ %l2 + 0x1a0 ], %g2 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2013938: a0 04 20 01 inc %l0 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
201393c: 84 17 00 02 or %i4, %g2, %g2 <== NOT EXECUTED
2013940: 86 17 40 03 or %i5, %g3, %g3 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~clear_value;
2013944: 84 28 80 1a andn %g2, %i2, %g2 <== NOT EXECUTED
2013948: 86 28 c0 1b andn %g3, %i3, %g3 <== NOT EXECUTED
201394c: c4 3c a1 a0 std %g2, [ %l2 + 0x1a0 ] <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2013950: 80 a4 00 18 cmp %l0, %i0 <== NOT EXECUTED
2013954: 06 bf ff 99 bl 20137b8 <rtems_rfs_trace_shell_command+0x50><== NOT EXECUTED
2013958: 83 2c 20 02 sll %l0, 2, %g1 <== NOT EXECUTED
201395c: 30 bf ff b8 b,a 201383c <rtems_rfs_trace_shell_command+0xd4><== NOT EXECUTED
0201e6cc <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)
{
201e6cc: 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))
201e6d0: 90 10 20 00 clr %o0
201e6d4: 7f ff d4 0d call 2013708 <rtems_rfs_trace>
201e6d8: 13 00 80 00 sethi %hi(0x2000000), %o1
201e6dc: 80 8a 20 ff btst 0xff, %o0
201e6e0: 02 80 00 08 be 201e700 <rtems_rfs_unlink+0x34> <== ALWAYS TAKEN
201e6e4: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
201e6e8: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e6ec: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201e6f0: 90 12 21 10 or %o0, 0x110, %o0 <== NOT EXECUTED
201e6f4: 40 00 0e 24 call 2021f84 <printf> <== NOT EXECUTED
201e6f8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
201e6fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e700: 92 10 00 1a mov %i2, %o1
201e704: 94 07 bf d8 add %fp, -40, %o2
201e708: 7f ff cd 77 call 2011ce4 <rtems_rfs_inode_open>
201e70c: 96 10 20 01 mov 1, %o3
if (rc)
201e710: ba 92 20 00 orcc %o0, 0, %i5
201e714: 12 80 00 d7 bne 201ea70 <rtems_rfs_unlink+0x3a4> <== NEVER TAKEN
201e718: 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));
201e71c: 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);
201e720: c2 08 60 02 ldub [ %g1 + 2 ], %g1
201e724: 83 28 60 08 sll %g1, 8, %g1
201e728: 82 08 40 02 and %g1, %g2, %g1
201e72c: 05 00 00 10 sethi %hi(0x4000), %g2
201e730: 82 18 40 02 xor %g1, %g2, %g1
201e734: 80 a0 00 01 cmp %g0, %g1
201e738: a0 60 3f ff subx %g0, -1, %l0
if (dir)
201e73c: 80 8c 20 ff btst 0xff, %l0
201e740: 02 80 00 26 be 201e7d8 <rtems_rfs_unlink+0x10c>
201e744: 80 a7 20 00 cmp %i4, 0
{
switch (dir_mode)
201e748: 22 80 00 06 be,a 201e760 <rtems_rfs_unlink+0x94> <== NEVER TAKEN
201e74c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e750: 80 a7 20 01 cmp %i4, 1
201e754: 12 80 00 22 bne 201e7dc <rtems_rfs_unlink+0x110> <== NEVER TAKEN
201e758: 90 10 00 18 mov %i0, %o0
201e75c: 30 80 00 0f b,a 201e798 <rtems_rfs_unlink+0xcc>
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e760: 7f ff d3 ea call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e764: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201e768: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e76c: 22 80 00 06 be,a 201e784 <rtems_rfs_unlink+0xb8> <== NOT EXECUTED
201e770: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
201e774: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e778: 40 00 0e 9b call 20221e4 <puts> <== NOT EXECUTED
201e77c: 90 12 21 40 or %o0, 0x140, %o0 ! 2034940 <CSWTCH.2+0x1460><== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
201e780: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e784: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
201e788: 7f ff cd c9 call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201e78c: 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;
}
201e790: 81 c7 e0 08 ret <== NOT EXECUTED
201e794: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
return EISDIR;
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
201e798: 7f ff f8 dc call 201cb08 <rtems_rfs_dir_empty>
201e79c: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
201e7a0: ba 92 20 00 orcc %o0, 0, %i5
201e7a4: 04 80 00 0d ble 201e7d8 <rtems_rfs_unlink+0x10c>
201e7a8: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e7ac: 7f ff d3 d7 call 2013708 <rtems_rfs_trace>
201e7b0: 13 00 80 00 sethi %hi(0x2000000), %o1
201e7b4: 80 8a 20 ff btst 0xff, %o0
201e7b8: 22 80 00 97 be,a 201ea14 <rtems_rfs_unlink+0x348> <== ALWAYS TAKEN
201e7bc: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
201e7c0: 40 00 12 5d call 2023134 <strerror> <== NOT EXECUTED
201e7c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e7c8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e7cc: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e7d0: 10 80 00 8e b 201ea08 <rtems_rfs_unlink+0x33c> <== NOT EXECUTED
201e7d4: 90 12 21 60 or %o0, 0x160, %o0 ! 2034960 <CSWTCH.2+0x1480><== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
201e7d8: 90 10 00 18 mov %i0, %o0
201e7dc: 92 10 00 19 mov %i1, %o1
201e7e0: 94 07 bf b0 add %fp, -80, %o2
201e7e4: 7f ff cd 40 call 2011ce4 <rtems_rfs_inode_open>
201e7e8: 96 10 20 01 mov 1, %o3
if (rc)
201e7ec: ba 92 20 00 orcc %o0, 0, %i5
201e7f0: 02 80 00 0e be 201e828 <rtems_rfs_unlink+0x15c> <== ALWAYS TAKEN
201e7f4: 90 10 00 18 mov %i0, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e7f8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e7fc: 7f ff d3 c3 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e800: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201e804: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e808: 22 80 00 83 be,a 201ea14 <rtems_rfs_unlink+0x348> <== NOT EXECUTED
201e80c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
201e810: 40 00 12 49 call 2023134 <strerror> <== NOT EXECUTED
201e814: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e818: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e81c: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e820: 10 80 00 7a b 201ea08 <rtems_rfs_unlink+0x33c> <== NOT EXECUTED
201e824: 90 12 21 80 or %o0, 0x180, %o0 ! 2034980 <CSWTCH.2+0x14a0><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
201e828: 92 07 bf b0 add %fp, -80, %o1
201e82c: 94 10 00 1a mov %i2, %o2
201e830: 7f ff f6 d4 call 201c380 <rtems_rfs_dir_del_entry>
201e834: 96 10 00 1b mov %i3, %o3
if (rc > 0)
201e838: ba 92 20 00 orcc %o0, 0, %i5
201e83c: 04 80 00 0e ble 201e874 <rtems_rfs_unlink+0x1a8> <== ALWAYS TAKEN
201e840: 01 00 00 00 nop
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e844: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
201e848: 7f ff d3 b0 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e84c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201e850: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e854: 22 80 00 59 be,a 201e9b8 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
201e858: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
201e85c: 40 00 12 36 call 2023134 <strerror> <== NOT EXECUTED
201e860: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e864: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e868: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e86c: 10 80 00 50 b 201e9ac <rtems_rfs_unlink+0x2e0> <== NOT EXECUTED
201e870: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 20349b0 <CSWTCH.2+0x14d0><== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
201e874: 7f ff ff 1e call 201e4ec <rtems_rfs_inode_get_links>
201e878: 90 07 bf d8 add %fp, -40, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e87c: 13 00 80 00 sethi %hi(0x2000000), %o1
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
201e880: ba 10 00 08 mov %o0, %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e884: 7f ff d3 a1 call 2013708 <rtems_rfs_trace>
201e888: 90 10 20 00 clr %o0
201e88c: 80 8a 20 ff btst 0xff, %o0
201e890: 02 80 00 09 be 201e8b4 <rtems_rfs_unlink+0x1e8> <== ALWAYS TAKEN
201e894: 83 2f 60 10 sll %i5, 0x10, %g1
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
201e898: 95 2f 60 10 sll %i5, 0x10, %o2 <== NOT EXECUTED
201e89c: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e8a0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201e8a4: 90 12 21 e0 or %o0, 0x1e0, %o0 <== NOT EXECUTED
201e8a8: 40 00 0d b7 call 2021f84 <printf> <== NOT EXECUTED
201e8ac: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
if (links > 1)
201e8b0: 83 2f 60 10 sll %i5, 0x10, %g1 <== NOT EXECUTED
201e8b4: 83 30 60 10 srl %g1, 0x10, %g1
201e8b8: 80 a0 60 01 cmp %g1, 1
201e8bc: 08 80 00 0a bleu 201e8e4 <rtems_rfs_unlink+0x218>
201e8c0: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
links--;
201e8c4: 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);
201e8c8: 85 37 60 08 srl %i5, 8, %g2
201e8cc: c4 28 40 00 stb %g2, [ %g1 ]
201e8d0: c2 07 bf e4 ld [ %fp + -28 ], %g1
201e8d4: fa 28 60 01 stb %i5, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201e8d8: 82 10 20 01 mov 1, %g1
201e8dc: 10 80 00 23 b 201e968 <rtems_rfs_unlink+0x29c>
201e8e0: c2 2f bf e8 stb %g1, [ %fp + -24 ]
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
201e8e4: 90 10 00 18 mov %i0, %o0
201e8e8: 7f ff cd 94 call 2011f38 <rtems_rfs_inode_delete>
201e8ec: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
201e8f0: ba 92 20 00 orcc %o0, 0, %i5
201e8f4: 04 80 00 0d ble 201e928 <rtems_rfs_unlink+0x25c> <== ALWAYS TAKEN
201e8f8: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e8fc: 7f ff d3 83 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e900: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201e904: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e908: 22 80 00 2c be,a 201e9b8 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
201e90c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
201e910: 40 00 12 09 call 2023134 <strerror> <== NOT EXECUTED
201e914: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e918: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e91c: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e920: 10 80 00 23 b 201e9ac <rtems_rfs_unlink+0x2e0> <== NOT EXECUTED
201e924: 90 12 22 08 or %o0, 0x208, %o0 ! 2034a08 <CSWTCH.2+0x1528><== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
201e928: 80 8c 20 ff btst 0xff, %l0
201e92c: 02 80 00 10 be 201e96c <rtems_rfs_unlink+0x2a0>
201e930: 90 07 bf b0 add %fp, -80, %o0
{
links = rtems_rfs_inode_get_links (&parent_inode);
201e934: 7f ff fe ee call 201e4ec <rtems_rfs_inode_get_links>
201e938: 90 07 bf b0 add %fp, -80, %o0
if (links > 1)
201e93c: 80 a2 20 01 cmp %o0, 1
201e940: 08 80 00 03 bleu 201e94c <rtems_rfs_unlink+0x280>
201e944: 82 10 00 08 mov %o0, %g1
links--;
201e948: 82 02 3f ff add %o0, -1, %g1
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
201e94c: c4 07 bf bc ld [ %fp + -68 ], %g2
201e950: 87 30 60 08 srl %g1, 8, %g3
201e954: c6 28 80 00 stb %g3, [ %g2 ]
201e958: c4 07 bf bc ld [ %fp + -68 ], %g2
201e95c: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201e960: 82 10 20 01 mov 1, %g1
201e964: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
201e968: 90 07 bf b0 add %fp, -80, %o0
201e96c: 92 10 20 01 mov 1, %o1
201e970: 7f ff cd a7 call 201200c <rtems_rfs_inode_time_stamp_now>
201e974: 94 10 20 01 mov 1, %o2
if (rc > 0)
201e978: ba 92 20 00 orcc %o0, 0, %i5
201e97c: 04 80 00 13 ble 201e9c8 <rtems_rfs_unlink+0x2fc> <== ALWAYS TAKEN
201e980: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e984: 7f ff d3 61 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e988: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201e98c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e990: 22 80 00 0a be,a 201e9b8 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
201e994: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
201e998: 40 00 11 e7 call 2023134 <strerror> <== NOT EXECUTED
201e99c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e9a0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e9a4: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e9a8: 90 12 22 38 or %o0, 0x238, %o0 ! 2034a38 <CSWTCH.2+0x1558><== NOT EXECUTED
201e9ac: 40 00 0d 76 call 2021f84 <printf> <== NOT EXECUTED
201e9b0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
201e9b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e9b8: 7f ff cd 3d call 2011eac <rtems_rfs_inode_close> <== NOT EXECUTED
201e9bc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
201e9c0: 10 80 00 15 b 201ea14 <rtems_rfs_unlink+0x348> <== NOT EXECUTED
201e9c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
201e9c8: 90 10 00 18 mov %i0, %o0
201e9cc: 7f ff cd 38 call 2011eac <rtems_rfs_inode_close>
201e9d0: 92 07 bf b0 add %fp, -80, %o1
if (rc > 0)
201e9d4: ba 92 20 00 orcc %o0, 0, %i5
201e9d8: 04 80 00 13 ble 201ea24 <rtems_rfs_unlink+0x358> <== ALWAYS TAKEN
201e9dc: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e9e0: 7f ff d3 4a call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201e9e4: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201e9e8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e9ec: 02 80 00 0a be 201ea14 <rtems_rfs_unlink+0x348> <== NOT EXECUTED
201e9f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
201e9f4: 40 00 11 d0 call 2023134 <strerror> <== NOT EXECUTED
201e9f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e9fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201ea00: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201ea04: 90 12 22 70 or %o0, 0x270, %o0 ! 2034a70 <CSWTCH.2+0x1590><== NOT EXECUTED
201ea08: 40 00 0d 5f call 2021f84 <printf> <== NOT EXECUTED
201ea0c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
201ea10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201ea14: 7f ff cd 26 call 2011eac <rtems_rfs_inode_close>
201ea18: 92 07 bf d8 add %fp, -40, %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
201ea1c: 81 c7 e0 08 ret
201ea20: 91 e8 00 1d restore %g0, %i5, %o0
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
201ea24: 90 10 00 18 mov %i0, %o0
201ea28: 7f ff cd 21 call 2011eac <rtems_rfs_inode_close>
201ea2c: 92 07 bf d8 add %fp, -40, %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201ea30: ba 92 20 00 orcc %o0, 0, %i5
201ea34: 04 80 00 10 ble 201ea74 <rtems_rfs_unlink+0x3a8> <== ALWAYS TAKEN
201ea38: b0 10 00 1d mov %i5, %i0
201ea3c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201ea40: 7f ff d3 32 call 2013708 <rtems_rfs_trace> <== NOT EXECUTED
201ea44: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201ea48: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ea4c: 22 80 00 0a be,a 201ea74 <rtems_rfs_unlink+0x3a8> <== NOT EXECUTED
201ea50: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
201ea54: 40 00 11 b8 call 2023134 <strerror> <== NOT EXECUTED
201ea58: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ea5c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201ea60: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201ea64: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201ea68: 40 00 0d 47 call 2021f84 <printf> <== NOT EXECUTED
201ea6c: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 2034aa8 <CSWTCH.2+0x15c8><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
201ea70: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
201ea74: 81 c7 e0 08 ret
201ea78: 81 e8 00 00 restore
02020d88 <rtems_shell_rfs_format>:
int
rtems_shell_rfs_format (int argc, char* argv[])
{
2020d88: 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));
2020d8c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020d90: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED
2020d94: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED
2020d98: 40 00 65 0d call 203a1cc <memset> <== NOT EXECUTED
2020d9c: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
int
rtems_shell_rfs_format (int argc, char* argv[])
{
rtems_rfs_format_config config;
const char* driver = NULL;
2020da0: b8 10 20 00 clr %i4 <== NOT EXECUTED
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
2020da4: 10 80 00 5b b 2020f10 <rtems_shell_rfs_format+0x188> <== NOT EXECUTED
2020da8: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
2020dac: d2 06 40 01 ld [ %i1 + %g1 ], %o1 <== NOT EXECUTED
2020db0: c2 4a 40 00 ldsb [ %o1 ], %g1 <== NOT EXECUTED
2020db4: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
2020db8: 12 80 00 4e bne 2020ef0 <rtems_shell_rfs_format+0x168> <== NOT EXECUTED
2020dbc: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
{
switch (argv[arg][1])
2020dc0: c2 4a 60 01 ldsb [ %o1 + 1 ], %g1 <== NOT EXECUTED
2020dc4: 80 a0 60 69 cmp %g1, 0x69 <== NOT EXECUTED
2020dc8: 22 80 00 2e be,a 2020e80 <rtems_shell_rfs_format+0xf8> <== NOT EXECUTED
2020dcc: ba 07 60 01 inc %i5 <== NOT EXECUTED
2020dd0: 14 80 00 09 bg 2020df4 <rtems_shell_rfs_format+0x6c> <== NOT EXECUTED
2020dd4: 80 a0 60 73 cmp %g1, 0x73 <== NOT EXECUTED
2020dd8: 80 a0 60 49 cmp %g1, 0x49 <== NOT EXECUTED
2020ddc: 02 80 00 35 be 2020eb0 <rtems_shell_rfs_format+0x128> <== NOT EXECUTED
2020de0: 80 a0 60 62 cmp %g1, 0x62 <== NOT EXECUTED
2020de4: 12 80 00 41 bne 2020ee8 <rtems_shell_rfs_format+0x160> <== NOT EXECUTED
2020de8: 11 00 81 57 sethi %hi(0x2055c00), %o0 <== NOT EXECUTED
}
config.block_size = strtoul (argv[arg], 0, 0);
break;
case 'b':
arg++;
2020dec: 10 80 00 19 b 2020e50 <rtems_shell_rfs_format+0xc8> <== NOT EXECUTED
2020df0: ba 07 60 01 inc %i5 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
2020df4: 02 80 00 0a be 2020e1c <rtems_shell_rfs_format+0x94> <== NOT EXECUTED
2020df8: 80 a0 60 76 cmp %g1, 0x76 <== NOT EXECUTED
2020dfc: 02 80 00 06 be 2020e14 <rtems_shell_rfs_format+0x8c> <== NOT EXECUTED
2020e00: 80 a0 60 6f cmp %g1, 0x6f <== NOT EXECUTED
2020e04: 12 80 00 39 bne 2020ee8 <rtems_shell_rfs_format+0x160> <== NOT EXECUTED
2020e08: 11 00 81 57 sethi %hi(0x2055c00), %o0 <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
case 'o':
arg++;
2020e0c: 10 80 00 2b b 2020eb8 <rtems_shell_rfs_format+0x130> <== NOT EXECUTED
2020e10: ba 07 60 01 inc %i5 <== NOT EXECUTED
{
switch (argv[arg][1])
{
case 'v':
config.verbose = true;
break;
2020e14: 10 80 00 3e b 2020f0c <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020e18: f6 2f bf fd stb %i3, [ %fp + -3 ] <== NOT EXECUTED
case 's':
arg++;
2020e1c: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
2020e20: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2020e24: 06 80 00 05 bl 2020e38 <rtems_shell_rfs_format+0xb0> <== NOT EXECUTED
2020e28: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: block size needs an argument\n");
2020e2c: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020e30: 10 80 00 40 b 2020f30 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2020e34: 90 12 22 98 or %o0, 0x298, %o0 ! 2057e98 <rtems_rtc_shell_usage+0x17a0><== NOT EXECUTED
return 1;
}
config.block_size = strtoul (argv[arg], 0, 0);
2020e38: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2020e3c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020e40: 40 00 79 4f call 203f37c <strtoul> <== NOT EXECUTED
2020e44: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2020e48: 10 80 00 31 b 2020f0c <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020e4c: d0 27 bf e8 st %o0, [ %fp + -24 ] <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
2020e50: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2020e54: 06 80 00 05 bl 2020e68 <rtems_shell_rfs_format+0xe0> <== NOT EXECUTED
2020e58: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group block count needs an argument\n");
2020e5c: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020e60: 10 80 00 34 b 2020f30 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2020e64: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 2057ec0 <rtems_rtc_shell_usage+0x17c8><== NOT EXECUTED
return 1;
}
config.group_blocks = strtoul (argv[arg], 0, 0);
2020e68: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2020e6c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020e70: 40 00 79 43 call 203f37c <strtoul> <== NOT EXECUTED
2020e74: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2020e78: 10 80 00 25 b 2020f0c <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020e7c: d0 27 bf ec st %o0, [ %fp + -20 ] <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
2020e80: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2020e84: 06 80 00 05 bl 2020e98 <rtems_shell_rfs_format+0x110> <== NOT EXECUTED
2020e88: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group inode count needs an argument\n");
2020e8c: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020e90: 10 80 00 28 b 2020f30 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2020e94: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 2057ef0 <rtems_rtc_shell_usage+0x17f8><== NOT EXECUTED
return 1;
}
config.group_inodes = strtoul (argv[arg], 0, 0);
2020e98: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2020e9c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020ea0: 40 00 79 37 call 203f37c <strtoul> <== NOT EXECUTED
2020ea4: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2020ea8: 10 80 00 19 b 2020f0c <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020eac: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
2020eb0: 10 80 00 17 b 2020f0c <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020eb4: f6 2f bf fc stb %i3, [ %fp + -4 ] <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
2020eb8: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2020ebc: 06 80 00 05 bl 2020ed0 <rtems_shell_rfs_format+0x148> <== NOT EXECUTED
2020ec0: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: inode percentage overhead needs an argument\n");
2020ec4: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020ec8: 10 80 00 1a b 2020f30 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2020ecc: 90 12 23 20 or %o0, 0x320, %o0 ! 2057f20 <rtems_rtc_shell_usage+0x1828><== NOT EXECUTED
return 1;
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
2020ed0: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2020ed4: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020ed8: 40 00 79 29 call 203f37c <strtoul> <== NOT EXECUTED
2020edc: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2020ee0: 10 80 00 0b b 2020f0c <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020ee4: d0 27 bf f4 st %o0, [ %fp + -12 ] <== NOT EXECUTED
default:
printf ("error: invalid option: %s\n", argv[arg]);
2020ee8: 10 80 00 06 b 2020f00 <rtems_shell_rfs_format+0x178> <== NOT EXECUTED
2020eec: 90 12 23 68 or %o0, 0x368, %o0 <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
2020ef0: 22 80 00 07 be,a 2020f0c <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020ef4: b8 10 00 09 mov %o1, %i4 <== NOT EXECUTED
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
2020ef8: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020efc: 90 12 23 58 or %o0, 0x358, %o0 ! 2057f58 <rtems_rtc_shell_usage+0x1860><== NOT EXECUTED
2020f00: 40 00 69 24 call 203b390 <printf> <== NOT EXECUTED
2020f04: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2020f08: 30 80 00 1c b,a 2020f78 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
2020f0c: ba 07 60 01 inc %i5 <== NOT EXECUTED
2020f10: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2020f14: 06 bf ff a6 bl 2020dac <rtems_shell_rfs_format+0x24> <== NOT EXECUTED
2020f18: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
2020f1c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2020f20: 12 80 00 07 bne 2020f3c <rtems_shell_rfs_format+0x1b4> <== NOT EXECUTED
2020f24: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
printf ("error: no driver name provided\n");
2020f28: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020f2c: 90 12 23 88 or %o0, 0x388, %o0 ! 2057f88 <rtems_rtc_shell_usage+0x1890><== NOT EXECUTED
2020f30: 40 00 69 b0 call 203b5f0 <puts> <== NOT EXECUTED
2020f34: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2020f38: 30 80 00 10 b,a 2020f78 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
2020f3c: 92 07 bf e8 add %fp, -24, %o1 <== NOT EXECUTED
2020f40: 40 00 34 4e call 202e078 <rtems_rfs_format> <== NOT EXECUTED
2020f44: b0 10 20 00 clr %i0 <== NOT EXECUTED
2020f48: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020f4c: 16 80 00 0b bge 2020f78 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
2020f50: 01 00 00 00 nop <== NOT EXECUTED
{
printf ("error: format of %s failed: %s\n",
driver, strerror (errno));
2020f54: 40 00 56 c0 call 2036a54 <__errno> <== NOT EXECUTED
2020f58: b0 10 20 01 mov 1, %i0 ! 1 <PROM_START+0x1> <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
{
printf ("error: format of %s failed: %s\n",
2020f5c: 40 00 72 8b call 203d988 <strerror> <== NOT EXECUTED
2020f60: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2020f64: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2020f68: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2020f6c: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020f70: 40 00 69 08 call 203b390 <printf> <== NOT EXECUTED
2020f74: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 2057fa8 <rtems_rtc_shell_usage+0x18b0><== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
2020f78: 81 c7 e0 08 ret <== NOT EXECUTED
2020f7c: 81 e8 00 00 restore <== NOT EXECUTED
0201789c <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
201789c: 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 )
20178a0: 80 a6 60 00 cmp %i1, 0
20178a4: 02 80 00 35 be 2017978 <rtems_signal_send+0xdc>
20178a8: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
20178ac: 90 10 00 18 mov %i0, %o0
20178b0: 40 00 12 ca call 201c3d8 <_Thread_Get>
20178b4: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
20178b8: c2 07 bf fc ld [ %fp + -4 ], %g1
20178bc: 80 a0 60 00 cmp %g1, 0
20178c0: 12 80 00 2d bne 2017974 <rtems_signal_send+0xd8>
20178c4: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
20178c8: fa 02 21 58 ld [ %o0 + 0x158 ], %i5
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
20178cc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
20178d0: 80 a0 60 00 cmp %g1, 0
20178d4: 02 80 00 24 be 2017964 <rtems_signal_send+0xc8>
20178d8: 01 00 00 00 nop
if ( asr->is_enabled ) {
20178dc: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
20178e0: 80 a0 60 00 cmp %g1, 0
20178e4: 02 80 00 15 be 2017938 <rtems_signal_send+0x9c>
20178e8: 01 00 00 00 nop
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
20178ec: 7f ff e3 91 call 2010730 <sparc_disable_interrupts>
20178f0: 01 00 00 00 nop
*signal_set |= signals;
20178f4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
20178f8: b2 10 40 19 or %g1, %i1, %i1
20178fc: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
_ISR_Enable( _level );
2017900: 7f ff e3 90 call 2010740 <sparc_enable_interrupts>
2017904: 01 00 00 00 nop
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
2017908: 03 00 80 f3 sethi %hi(0x203cc00), %g1
201790c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 203cee0 <_Per_CPU_Information>
2017910: c4 00 60 08 ld [ %g1 + 8 ], %g2
2017914: 80 a0 a0 00 cmp %g2, 0
2017918: 02 80 00 0f be 2017954 <rtems_signal_send+0xb8>
201791c: 01 00 00 00 nop
2017920: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
2017924: 80 a7 00 02 cmp %i4, %g2
2017928: 12 80 00 0b bne 2017954 <rtems_signal_send+0xb8> <== NEVER TAKEN
201792c: 84 10 20 01 mov 1, %g2
_Thread_Dispatch_necessary = true;
2017930: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
2017934: 30 80 00 08 b,a 2017954 <rtems_signal_send+0xb8>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
2017938: 7f ff e3 7e call 2010730 <sparc_disable_interrupts>
201793c: 01 00 00 00 nop
*signal_set |= signals;
2017940: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
2017944: b2 10 40 19 or %g1, %i1, %i1
2017948: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
_ISR_Enable( _level );
201794c: 7f ff e3 7d call 2010740 <sparc_enable_interrupts>
2017950: 01 00 00 00 nop
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
2017954: 40 00 12 95 call 201c3a8 <_Thread_Enable_dispatch>
2017958: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
201795c: 10 80 00 07 b 2017978 <rtems_signal_send+0xdc>
2017960: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
_Thread_Enable_dispatch();
2017964: 40 00 12 91 call 201c3a8 <_Thread_Enable_dispatch>
2017968: 01 00 00 00 nop
return RTEMS_NOT_DEFINED;
201796c: 10 80 00 03 b 2017978 <rtems_signal_send+0xdc>
2017970: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
2017974: 82 10 20 04 mov 4, %g1
}
2017978: 81 c7 e0 08 ret
201797c: 91 e8 00 01 restore %g0, %g1, %o0
0200ef2c <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 )
{
200ef2c: 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 )
200ef30: 92 10 00 1a mov %i2, %o1
200ef34: 7f ff cd c7 call 2002650 <.umul>
200ef38: 90 06 60 08 add %i1, 8, %o0
+ key_table_size + data_size;
rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(
200ef3c: 7f ff da 50 call 200587c <malloc>
200ef40: 90 02 20 1c add %o0, 0x1c, %o0
200ef44: 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 ) {
200ef48: 80 a2 60 00 cmp %o1, 0
200ef4c: 02 80 00 0b be 200ef78 <rtems_sparse_disk_create_and_register+0x4c><== NEVER TAKEN
200ef50: 90 10 20 1a mov 0x1a, %o0
sc = rtems_sparse_disk_register(
200ef54: 03 00 80 3a sethi %hi(0x200e800), %g1
200ef58: 82 10 63 b4 or %g1, 0x3b4, %g1 ! 200ebb4 <rtems_sparse_disk_free>
200ef5c: 90 10 00 18 mov %i0, %o0
200ef60: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
200ef64: 94 10 00 19 mov %i1, %o2
200ef68: 96 10 00 1a mov %i2, %o3
200ef6c: 98 10 00 1b mov %i3, %o4
200ef70: 7f ff ff b7 call 200ee4c <rtems_sparse_disk_register>
200ef74: 9a 10 00 1c mov %i4, %o5
} else {
sc = RTEMS_NO_MEMORY;
}
return sc;
}
200ef78: 81 c7 e0 08 ret
200ef7c: 91 e8 00 08 restore %g0, %o0, %o0
0200ee4c <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 )
{
200ee4c: 9d e3 bf a0 save %sp, -96, %sp
sparse_disk_ioctl,
sparse_disk
);
}
} else {
sc = RTEMS_INVALID_NUMBER;
200ee50: 90 10 20 0a mov 0xa, %o0
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 )
{
200ee54: a0 10 00 19 mov %i1, %l0
200ee58: e4 07 a0 5c ld [ %fp + 0x5c ], %l2
rtems_status_code sc;
if ( blocks_with_buffer <= media_block_count ) {
200ee5c: 80 a6 c0 1c cmp %i3, %i4
200ee60: 18 80 00 31 bgu 200ef24 <rtems_sparse_disk_register+0xd8> <== NEVER TAKEN
200ee64: b2 10 00 1a mov %i2, %i1
const uint8_t fill_pattern )
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
200ee68: 80 a4 20 00 cmp %l0, 0
200ee6c: 02 80 00 2d be 200ef20 <rtems_sparse_disk_register+0xd4> <== NEVER TAKEN
200ee70: 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
200ee74: b5 2e e0 03 sll %i3, 3, %i2
* 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 );
200ee78: 90 10 00 10 mov %l0, %o0
200ee7c: a2 06 a0 1c add %i2, 0x1c, %l1
200ee80: 40 00 34 c7 call 201c19c <memset>
200ee84: 94 10 00 11 mov %l1, %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;
200ee88: 92 10 00 19 mov %i1, %o1
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
sd->fill_pattern = fill_pattern;
200ee8c: 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;
200ee90: 7f ff cd f0 call 2002650 <.umul>
200ee94: 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 ),
200ee98: 92 10 00 1d mov %i5, %o1
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;
200ee9c: 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 ),
200eea0: a2 04 00 11 add %l0, %l1, %l1
200eea4: 40 00 34 be call 201c19c <memset>
200eea8: 90 10 00 11 mov %l1, %o0
sd->fill_pattern,
data_size );
sd->delete_handler = sparse_disk_delete;
sc = rtems_semaphore_create(
200eeac: 11 14 d4 10 sethi %hi(0x53504000), %o0
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;
200eeb0: e4 24 20 10 st %l2, [ %l0 + 0x10 ]
sc = rtems_semaphore_create(
200eeb4: 90 12 21 52 or %o0, 0x152, %o0
200eeb8: 92 10 20 01 mov 1, %o1
200eebc: 94 10 20 54 mov 0x54, %o2
200eec0: 96 10 20 00 clr %o3
200eec4: 7f ff e9 d3 call 2009610 <rtems_semaphore_create>
200eec8: 98 10 00 10 mov %l0, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY,
0,
&sd->mutex
);
if ( sc != RTEMS_SUCCESSFUL ) {
200eecc: 80 a2 20 00 cmp %o0, 0
200eed0: 12 80 00 15 bne 200ef24 <rtems_sparse_disk_register+0xd8> <== NEVER TAKEN
200eed4: 84 04 20 1c add %l0, 0x1c, %g2
return sc;
}
data += sizeof( rtems_sparse_disk );
sd->blocks_with_buffer = blocks_with_buffer;
200eed8: f6 24 20 04 st %i3, [ %l0 + 4 ]
sd->key_table = (rtems_sparse_disk_key *) data;
200eedc: c4 24 20 18 st %g2, [ %l0 + 0x18 ]
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
200eee0: 82 10 20 00 clr %g1
data += sizeof( rtems_sparse_disk );
sd->blocks_with_buffer = blocks_with_buffer;
sd->key_table = (rtems_sparse_disk_key *) data;
data += key_table_size;
200eee4: 10 80 00 06 b 200eefc <rtems_sparse_disk_register+0xb0>
200eee8: 84 00 80 1a add %g2, %i2, %g2
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
200eeec: 82 00 60 01 inc %g1
}
return sc;
}
rtems_status_code rtems_sparse_disk_register(
200eef0: 86 04 00 03 add %l0, %g3, %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;
200eef4: c4 20 e0 20 st %g2, [ %g3 + 0x20 ]
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 ) {
200eef8: 84 00 80 19 add %g2, %i1, %g2
200eefc: 80 a0 40 1b cmp %g1, %i3
200ef00: 12 bf ff fb bne 200eeec <rtems_sparse_disk_register+0xa0>
200ef04: 87 28 60 03 sll %g1, 3, %g3
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
200ef08: b4 10 00 1c mov %i4, %i2
200ef0c: 37 00 80 3a sethi %hi(0x200e800), %i3
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
sd->key_table[i].data = data;
}
sd->media_block_size = media_block_size;
200ef10: f2 24 20 0c st %i1, [ %l0 + 0xc ]
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
200ef14: b6 16 e3 c0 or %i3, 0x3c0, %i3
200ef18: 40 00 0a 93 call 2011964 <rtems_blkdev_create>
200ef1c: 99 e8 00 10 restore %g0, %l0, %o4
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
return RTEMS_INVALID_ADDRESS;
200ef20: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
200ef24: 81 c7 e0 08 ret <== NOT EXECUTED
200ef28: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
020226e0 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
20226e0: 9d e3 bf a0 save %sp, -96, %sp
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
20226e4: c2 06 20 08 ld [ %i0 + 8 ], %g1
20226e8: 80 a0 60 00 cmp %g1, 0
20226ec: 02 80 00 07 be 2022708 <rtems_stack_checker_begin_extension+0x28><== NEVER TAKEN
20226f0: 13 00 81 8a sethi %hi(0x2062800), %o1
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
20226f4: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
20226f8: 90 02 20 08 add %o0, 8, %o0
20226fc: 92 12 62 8c or %o1, 0x28c, %o1
2022700: 40 00 5e 24 call 2039f90 <memcpy>
2022704: 94 10 20 10 mov 0x10, %o2
2022708: 81 c7 e0 08 ret
202270c: 81 e8 00 00 restore
02022628 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
2022628: 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 )
202262c: 03 00 81 86 sethi %hi(0x2061800), %g1
2022630: c2 00 60 a0 ld [ %g1 + 0xa0 ], %g1 ! 20618a0 <Stack_check_Initialized>
2022634: 80 a0 60 00 cmp %g1, 0
2022638: 12 80 00 21 bne 20226bc <rtems_stack_checker_create_extension+0x94>
202263c: 05 00 81 8a sethi %hi(0x2062800), %g2
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
2022640: 07 3f bb 7c sethi %hi(0xfeedf000), %g3
2022644: 82 10 a2 8c or %g2, 0x28c, %g1
2022648: 86 10 e0 0d or %g3, 0xd, %g3
202264c: c6 20 a2 8c st %g3, [ %g2 + 0x28c ]
2022650: 05 02 eb 43 sethi %hi(0xbad0c00), %g2
2022654: 84 10 a1 06 or %g2, 0x106, %g2 ! bad0d06 <RAM_END+0x96d0d06>
2022658: c4 20 60 04 st %g2, [ %g1 + 4 ]
202265c: 05 37 ab 7c sethi %hi(0xdeadf000), %g2
2022660: 84 10 a0 0d or %g2, 0xd, %g2 ! deadf00d <RAM_END+0xdc6df00d>
2022664: c4 20 60 08 st %g2, [ %g1 + 8 ]
2022668: 05 18 03 43 sethi %hi(0x600d0c00), %g2
202266c: 84 10 a1 06 or %g2, 0x106, %g2 ! 600d0d06 <RAM_END+0x5dcd0d06>
2022670: c4 20 60 0c st %g2, [ %g1 + 0xc ]
/*
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
2022674: 03 00 81 89 sethi %hi(0x2062400), %g1
2022678: d0 00 61 60 ld [ %g1 + 0x160 ], %o0 ! 2062560 <_Per_CPU_Information>
202267c: 80 a2 20 00 cmp %o0, 0
2022680: 02 80 00 0c be 20226b0 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
2022684: 84 10 61 60 or %g1, 0x160, %g2
2022688: d4 00 a0 04 ld [ %g2 + 4 ], %o2
202268c: 80 a2 a0 00 cmp %o2, 0
2022690: 02 80 00 08 be 20226b0 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
2022694: 03 00 81 8a sethi %hi(0x2062800), %g1
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
2022698: 84 10 62 9c or %g1, 0x29c, %g2 ! 2062a9c <Stack_check_Interrupt_stack>
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
202269c: 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;
20226a0: d0 20 a0 04 st %o0, [ %g2 + 4 ]
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
20226a4: d4 20 62 9c st %o2, [ %g1 + 0x29c ]
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
20226a8: 40 00 5e c9 call 203a1cc <memset>
20226ac: 92 10 20 a5 mov 0xa5, %o1
}
#endif
Stack_check_Initialized = 1;
20226b0: 84 10 20 01 mov 1, %g2
20226b4: 03 00 81 86 sethi %hi(0x2061800), %g1
20226b8: c4 20 60 a0 st %g2, [ %g1 + 0xa0 ] ! 20618a0 <Stack_check_Initialized>
Thread_Control *the_thread
)
{
Stack_check_Initialize();
if (the_thread)
20226bc: 80 a6 60 00 cmp %i1, 0
20226c0: 02 80 00 06 be 20226d8 <rtems_stack_checker_create_extension+0xb0><== NEVER TAKEN
20226c4: 01 00 00 00 nop
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
20226c8: d0 06 60 b8 ld [ %i1 + 0xb8 ], %o0
20226cc: d4 06 60 b4 ld [ %i1 + 0xb4 ], %o2
20226d0: 40 00 5e bf call 203a1cc <memset>
20226d4: 92 10 20 a5 mov 0xa5, %o1
return true;
}
20226d8: 81 c7 e0 08 ret
20226dc: 91 e8 20 01 restore %g0, 1, %o0
02022830 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
2022830: 9d e3 bf a0 save %sp, -96, %sp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
2022834: 03 00 81 89 sethi %hi(0x2062400), %g1
2022838: fa 00 61 70 ld [ %g1 + 0x170 ], %i5 ! 2062570 <_Per_CPU_Information+0x10>
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
202283c: d0 07 60 b8 ld [ %i5 + 0xb8 ], %o0
2022840: 80 a7 80 08 cmp %fp, %o0
2022844: 0a 80 00 06 bcs 202285c <rtems_stack_checker_is_blown+0x2c><== NEVER TAKEN
2022848: b8 10 20 00 clr %i4
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
202284c: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2022850: 82 02 00 01 add %o0, %g1, %g1
2022854: 80 a0 40 1e cmp %g1, %fp
2022858: b8 60 3f ff subx %g0, -1, %i4
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
202285c: 03 00 81 86 sethi %hi(0x2061800), %g1
2022860: c2 00 60 a0 ld [ %g1 + 0xa0 ], %g1 ! 20618a0 <Stack_check_Initialized>
2022864: 80 a0 60 00 cmp %g1, 0
2022868: 02 80 00 09 be 202288c <rtems_stack_checker_is_blown+0x5c><== NEVER TAKEN
202286c: 92 10 20 01 mov 1, %o1
pattern_ok = (!memcmp(
2022870: 90 02 20 08 add %o0, 8, %o0
2022874: 13 00 81 8a sethi %hi(0x2062800), %o1
2022878: 94 10 20 10 mov 0x10, %o2
202287c: 40 00 5d 9b call 2039ee8 <memcmp>
2022880: 92 12 62 8c or %o1, 0x28c, %o1
2022884: 80 a0 00 08 cmp %g0, %o0
2022888: 92 60 3f ff subx %g0, -1, %o1
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
202288c: 82 1a 60 01 xor %o1, 1, %g1
2022890: 80 88 60 ff btst 0xff, %g1
2022894: 12 80 00 05 bne 20228a8 <rtems_stack_checker_is_blown+0x78><== NEVER TAKEN
2022898: b8 1f 20 01 xor %i4, 1, %i4
202289c: 80 8f 20 ff btst 0xff, %i4
20228a0: 02 80 00 05 be 20228b4 <rtems_stack_checker_is_blown+0x84><== ALWAYS TAKEN
20228a4: 01 00 00 00 nop
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
20228a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20228ac: 7f ff ff 99 call 2022710 <Stack_check_report_blown_task> <== NOT EXECUTED
20228b0: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
20228b4: 81 c7 e0 08 ret
20228b8: 91 e8 20 00 restore %g0, 0, %o0
020228bc <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
20228bc: 9d e3 bf a0 save %sp, -96, %sp
if ( !print )
20228c0: 80 a6 60 00 cmp %i1, 0
20228c4: 02 80 00 14 be 2022914 <rtems_stack_checker_report_usage_with_plugin+0x58><== NEVER TAKEN
20228c8: 39 00 81 86 sethi %hi(0x2061800), %i4
return;
print_context = context;
print_handler = print;
20228cc: 3b 00 81 86 sethi %hi(0x2061800), %i5
)
{
if ( !print )
return;
print_context = context;
20228d0: f0 27 20 a4 st %i0, [ %i4 + 0xa4 ]
print_handler = print;
20228d4: f2 27 60 a8 st %i1, [ %i5 + 0xa8 ]
(*print)( context, "Stack usage by thread\n");
20228d8: 90 10 00 18 mov %i0, %o0
20228dc: 13 00 81 62 sethi %hi(0x2058800), %o1
20228e0: 9f c6 40 00 call %i1
20228e4: 92 12 61 28 or %o1, 0x128, %o1 ! 2058928 <RTEMS_BDPART_MBR_MASTER_TYPE+0x3f8>
(*print)( context,
20228e8: 90 10 00 18 mov %i0, %o0
20228ec: 13 00 81 62 sethi %hi(0x2058800), %o1
20228f0: 9f c6 40 00 call %i1
20228f4: 92 12 61 40 or %o1, 0x140, %o1 ! 2058940 <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 );
20228f8: 11 00 80 89 sethi %hi(0x2022400), %o0
20228fc: 40 00 10 96 call 2026b54 <rtems_iterate_over_all_threads>
2022900: 90 12 20 b8 or %o0, 0xb8, %o0 ! 20224b8 <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);
2022904: 7f ff fe ed call 20224b8 <Stack_check_Dump_threads_usage>
2022908: 90 10 3f ff mov -1, %o0
#endif
print_context = NULL;
202290c: c0 27 20 a4 clr [ %i4 + 0xa4 ]
print_handler = NULL;
2022910: c0 27 60 a8 clr [ %i5 + 0xa8 ]
2022914: 81 c7 e0 08 ret
2022918: 81 e8 00 00 restore
020227c0 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
20227c0: 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);
20227c4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
20227c8: ba 10 20 00 clr %i5
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
20227cc: 80 a7 80 01 cmp %fp, %g1
20227d0: 0a 80 00 06 bcs 20227e8 <rtems_stack_checker_switch_extension+0x28><== NEVER TAKEN
20227d4: 90 00 60 08 add %g1, 8, %o0
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
20227d8: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2
20227dc: 82 00 40 02 add %g1, %g2, %g1
20227e0: 80 a0 40 1e cmp %g1, %fp
20227e4: ba 60 3f ff subx %g0, -1, %i5
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
20227e8: 13 00 81 8a sethi %hi(0x2062800), %o1
20227ec: 94 10 20 10 mov 0x10, %o2
20227f0: 40 00 5d be call 2039ee8 <memcmp>
20227f4: 92 12 62 8c or %o1, 0x28c, %o1
20227f8: 80 a0 00 08 cmp %g0, %o0
20227fc: 82 60 3f ff subx %g0, -1, %g1
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
2022800: 80 a0 60 00 cmp %g1, 0
2022804: 02 80 00 06 be 202281c <rtems_stack_checker_switch_extension+0x5c>
2022808: 92 10 00 01 mov %g1, %o1
202280c: ba 1f 60 01 xor %i5, 1, %i5
2022810: 80 8f 60 ff btst 0xff, %i5
2022814: 02 80 00 05 be 2022828 <rtems_stack_checker_switch_extension+0x68><== ALWAYS TAKEN
2022818: 01 00 00 00 nop
Stack_check_report_blown_task( running, pattern_ok );
202281c: 90 10 00 18 mov %i0, %o0
2022820: 7f ff ff bc call 2022710 <Stack_check_report_blown_task>
2022824: 92 0a 60 01 and %o1, 1, %o1
2022828: 81 c7 e0 08 ret
202282c: 81 e8 00 00 restore
0201d66c <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
201d66c: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
201d670: 80 a6 60 00 cmp %i1, 0
201d674: 02 80 00 25 be 201d708 <rtems_string_to_int+0x9c>
201d678: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
201d67c: 40 00 64 f6 call 2036a54 <__errno>
201d680: 01 00 00 00 nop
201d684: c0 22 00 00 clr [ %o0 ]
*n = 0;
201d688: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
201d68c: 90 10 00 18 mov %i0, %o0
201d690: 92 07 bf fc add %fp, -4, %o1
201d694: 40 00 85 ec call 203ee44 <strtol>
201d698: 94 10 00 1b mov %i3, %o2
if ( endptr )
201d69c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
201d6a0: ba 10 00 08 mov %o0, %i5
if ( endptr )
201d6a4: 02 80 00 03 be 201d6b0 <rtems_string_to_int+0x44>
201d6a8: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
201d6ac: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
201d6b0: 80 a0 80 18 cmp %g2, %i0
201d6b4: 02 80 00 15 be 201d708 <rtems_string_to_int+0x9c>
201d6b8: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201d6bc: 40 00 64 e6 call 2036a54 <__errno>
201d6c0: 01 00 00 00 nop
201d6c4: c2 02 00 00 ld [ %o0 ], %g1
201d6c8: 80 a0 60 22 cmp %g1, 0x22
201d6cc: 32 80 00 0e bne,a 201d704 <rtems_string_to_int+0x98>
201d6d0: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
201d6d4: 03 20 00 00 sethi %hi(0x80000000), %g1
201d6d8: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201d6dc: 80 a0 60 00 cmp %g1, 0
201d6e0: 02 80 00 0a be 201d708 <rtems_string_to_int+0x9c>
201d6e4: 82 10 20 0a mov 0xa, %g1
201d6e8: 80 a7 60 00 cmp %i5, 0
201d6ec: 02 80 00 07 be 201d708 <rtems_string_to_int+0x9c> <== NEVER TAKEN
201d6f0: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
201d6f4: 80 a7 40 02 cmp %i5, %g2
201d6f8: 02 80 00 04 be 201d708 <rtems_string_to_int+0x9c> <== ALWAYS TAKEN
201d6fc: 01 00 00 00 nop
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
201d700: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
201d704: 82 10 20 00 clr %g1
}
201d708: 81 c7 e0 08 ret
201d70c: 91 e8 00 01 restore %g0, %g1, %o0
0200d970 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
200d970: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
200d974: 80 a6 60 00 cmp %i1, 0
200d978: 02 80 00 25 be 200da0c <rtems_string_to_long+0x9c>
200d97c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200d980: 40 00 0b 63 call 201070c <__errno>
200d984: 01 00 00 00 nop
200d988: c0 22 00 00 clr [ %o0 ]
*n = 0;
200d98c: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
200d990: 90 10 00 18 mov %i0, %o0
200d994: 92 07 bf fc add %fp, -4, %o1
200d998: 40 00 17 1a call 2013600 <strtol>
200d99c: 94 10 00 1b mov %i3, %o2
if ( endptr )
200d9a0: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
200d9a4: ba 10 00 08 mov %o0, %i5
if ( endptr )
200d9a8: 02 80 00 03 be 200d9b4 <rtems_string_to_long+0x44>
200d9ac: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200d9b0: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200d9b4: 80 a0 80 18 cmp %g2, %i0
200d9b8: 02 80 00 15 be 200da0c <rtems_string_to_long+0x9c>
200d9bc: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200d9c0: 40 00 0b 53 call 201070c <__errno>
200d9c4: 01 00 00 00 nop
200d9c8: c2 02 00 00 ld [ %o0 ], %g1
200d9cc: 80 a0 60 22 cmp %g1, 0x22
200d9d0: 32 80 00 0e bne,a 200da08 <rtems_string_to_long+0x98>
200d9d4: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
200d9d8: 03 20 00 00 sethi %hi(0x80000000), %g1
200d9dc: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200d9e0: 80 a0 60 00 cmp %g1, 0
200d9e4: 02 80 00 0a be 200da0c <rtems_string_to_long+0x9c>
200d9e8: 82 10 20 0a mov 0xa, %g1
200d9ec: 80 a7 60 00 cmp %i5, 0
200d9f0: 02 80 00 07 be 200da0c <rtems_string_to_long+0x9c> <== NEVER TAKEN
200d9f4: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
200d9f8: 80 a7 40 02 cmp %i5, %g2
200d9fc: 02 80 00 04 be 200da0c <rtems_string_to_long+0x9c> <== ALWAYS TAKEN
200da00: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
200da04: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200da08: 82 10 20 00 clr %g1
}
200da0c: 81 c7 e0 08 ret
200da10: 91 e8 00 01 restore %g0, %g1, %o0
0200d8a4 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
200d8a4: 9d e3 bf 98 save %sp, -104, %sp
long long result;
char *end;
if ( !n )
200d8a8: 80 a6 60 00 cmp %i1, 0
200d8ac: 02 80 00 2f be 200d968 <rtems_string_to_long_long+0xc4>
200d8b0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200d8b4: 40 00 0b 96 call 201070c <__errno>
200d8b8: 01 00 00 00 nop
200d8bc: c0 22 00 00 clr [ %o0 ]
*n = 0;
200d8c0: c0 26 40 00 clr [ %i1 ]
200d8c4: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoll( s, &end, base );
200d8c8: 90 10 00 18 mov %i0, %o0
200d8cc: 92 07 bf fc add %fp, -4, %o1
200d8d0: 40 00 17 55 call 2013624 <strtoll>
200d8d4: 94 10 00 1b mov %i3, %o2
if ( endptr )
200d8d8: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
200d8dc: b8 10 00 08 mov %o0, %i4
200d8e0: ba 10 00 09 mov %o1, %i5
if ( endptr )
200d8e4: 02 80 00 03 be 200d8f0 <rtems_string_to_long_long+0x4c>
200d8e8: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200d8ec: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200d8f0: 80 a0 80 18 cmp %g2, %i0
200d8f4: 02 80 00 1d be 200d968 <rtems_string_to_long_long+0xc4>
200d8f8: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200d8fc: 40 00 0b 84 call 201070c <__errno>
200d900: 01 00 00 00 nop
200d904: c2 02 00 00 ld [ %o0 ], %g1
200d908: 80 a0 60 22 cmp %g1, 0x22
200d90c: 32 80 00 16 bne,a 200d964 <rtems_string_to_long_long+0xc0>
200d910: f8 3e 40 00 std %i4, [ %i1 ]
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
200d914: 05 1f ff ff sethi %hi(0x7ffffc00), %g2
200d918: 07 3f ff ff sethi %hi(0xfffffc00), %g3
200d91c: 84 10 a3 ff or %g2, 0x3ff, %g2
200d920: 86 10 e3 ff or %g3, 0x3ff, %g3
200d924: 84 1f 00 02 xor %i4, %g2, %g2
200d928: 86 1f 40 03 xor %i5, %g3, %g3
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200d92c: 80 90 80 03 orcc %g2, %g3, %g0
200d930: 02 80 00 0e be 200d968 <rtems_string_to_long_long+0xc4>
200d934: 82 10 20 0a mov 0xa, %g1
200d938: 80 97 00 1d orcc %i4, %i5, %g0
200d93c: 02 80 00 0b be 200d968 <rtems_string_to_long_long+0xc4> <== NEVER TAKEN
200d940: 01 00 00 00 nop
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
200d944: 03 20 00 00 sethi %hi(0x80000000), %g1
200d948: 80 a7 00 01 cmp %i4, %g1
200d94c: 32 80 00 06 bne,a 200d964 <rtems_string_to_long_long+0xc0><== NEVER TAKEN
200d950: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
200d954: 80 a7 60 00 cmp %i5, 0
200d958: 22 80 00 04 be,a 200d968 <rtems_string_to_long_long+0xc4><== ALWAYS TAKEN
200d95c: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
*n = result;
200d960: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
200d964: 82 10 20 00 clr %g1
return RTEMS_SUCCESSFUL;
}
200d968: 81 c7 e0 08 ret
200d96c: 91 e8 00 01 restore %g0, %g1, %o0
0201d720 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
201d720: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
201d724: 80 a6 60 00 cmp %i1, 0
201d728: 02 80 00 26 be 201d7c0 <rtems_string_to_unsigned_char+0xa0>
201d72c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
201d730: 40 00 64 c9 call 2036a54 <__errno>
201d734: 01 00 00 00 nop
201d738: c0 22 00 00 clr [ %o0 ]
*n = 0;
201d73c: c0 2e 40 00 clrb [ %i1 ]
result = strtoul( s, &end, base );
201d740: 90 10 00 18 mov %i0, %o0
201d744: 92 07 bf fc add %fp, -4, %o1
201d748: 40 00 87 0d call 203f37c <strtoul>
201d74c: 94 10 00 1b mov %i3, %o2
if ( endptr )
201d750: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
201d754: ba 10 00 08 mov %o0, %i5
if ( endptr )
201d758: 02 80 00 03 be 201d764 <rtems_string_to_unsigned_char+0x44>
201d75c: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
201d760: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
201d764: 80 a0 80 18 cmp %g2, %i0
201d768: 02 80 00 16 be 201d7c0 <rtems_string_to_unsigned_char+0xa0>
201d76c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201d770: 40 00 64 b9 call 2036a54 <__errno>
201d774: 01 00 00 00 nop
201d778: c2 02 00 00 ld [ %o0 ], %g1
201d77c: 80 a0 60 22 cmp %g1, 0x22
201d780: 12 80 00 07 bne 201d79c <rtems_string_to_unsigned_char+0x7c>
201d784: 80 a7 60 ff cmp %i5, 0xff
(( result == 0 ) || ( result == ULONG_MAX )))
201d788: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201d78c: 80 a0 bf fd cmp %g2, -3
201d790: 18 80 00 0c bgu 201d7c0 <rtems_string_to_unsigned_char+0xa0><== ALWAYS TAKEN
201d794: 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 ) {
201d798: 80 a7 60 ff cmp %i5, 0xff <== NOT EXECUTED
201d79c: 28 80 00 08 bleu,a 201d7bc <rtems_string_to_unsigned_char+0x9c>
201d7a0: fa 2e 40 00 stb %i5, [ %i1 ]
errno = ERANGE;
201d7a4: 40 00 64 ac call 2036a54 <__errno>
201d7a8: 01 00 00 00 nop
201d7ac: 82 10 20 22 mov 0x22, %g1 ! 22 <PROM_START+0x22>
201d7b0: c2 22 00 00 st %g1, [ %o0 ]
return RTEMS_INVALID_NUMBER;
201d7b4: 10 80 00 03 b 201d7c0 <rtems_string_to_unsigned_char+0xa0>
201d7b8: 82 10 20 0a mov 0xa, %g1
}
#endif
*n = result;
return RTEMS_SUCCESSFUL;
201d7bc: 82 10 20 00 clr %g1
}
201d7c0: 81 c7 e0 08 ret
201d7c4: 91 e8 00 01 restore %g0, %g1, %o0
0200dacc <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
200dacc: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
200dad0: 80 a6 60 00 cmp %i1, 0
200dad4: 02 80 00 1e be 200db4c <rtems_string_to_unsigned_int+0x80>
200dad8: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200dadc: 40 00 0b 0c call 201070c <__errno>
200dae0: 01 00 00 00 nop
200dae4: c0 22 00 00 clr [ %o0 ]
*n = 0;
200dae8: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
200daec: 90 10 00 18 mov %i0, %o0
200daf0: 92 07 bf fc add %fp, -4, %o1
200daf4: 40 00 18 11 call 2013b38 <strtoul>
200daf8: 94 10 00 1b mov %i3, %o2
if ( endptr )
200dafc: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
200db00: ba 10 00 08 mov %o0, %i5
if ( endptr )
200db04: 02 80 00 03 be 200db10 <rtems_string_to_unsigned_int+0x44>
200db08: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200db0c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200db10: 80 a0 80 18 cmp %g2, %i0
200db14: 02 80 00 0e be 200db4c <rtems_string_to_unsigned_int+0x80>
200db18: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200db1c: 40 00 0a fc call 201070c <__errno>
200db20: 01 00 00 00 nop
200db24: c2 02 00 00 ld [ %o0 ], %g1
200db28: 80 a0 60 22 cmp %g1, 0x22
200db2c: 32 80 00 07 bne,a 200db48 <rtems_string_to_unsigned_int+0x7c>
200db30: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == ULONG_MAX )))
200db34: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200db38: 80 a0 bf fd cmp %g2, -3
200db3c: 18 80 00 04 bgu 200db4c <rtems_string_to_unsigned_int+0x80><== ALWAYS TAKEN
200db40: 82 10 20 0a mov 0xa, %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
200db44: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200db48: 82 10 20 00 clr %g1
}
200db4c: 81 c7 e0 08 ret
200db50: 91 e8 00 01 restore %g0, %g1, %o0
0200ba40 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
200ba40: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
200ba44: 80 a6 60 00 cmp %i1, 0
200ba48: 02 80 00 1e be 200bac0 <rtems_string_to_unsigned_long+0x80>
200ba4c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200ba50: 40 00 ac 01 call 2036a54 <__errno>
200ba54: 01 00 00 00 nop
200ba58: c0 22 00 00 clr [ %o0 ]
*n = 0;
200ba5c: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
200ba60: 90 10 00 18 mov %i0, %o0
200ba64: 92 07 bf fc add %fp, -4, %o1
200ba68: 40 00 ce 45 call 203f37c <strtoul>
200ba6c: 94 10 00 1b mov %i3, %o2
if ( endptr )
200ba70: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
200ba74: ba 10 00 08 mov %o0, %i5
if ( endptr )
200ba78: 02 80 00 03 be 200ba84 <rtems_string_to_unsigned_long+0x44>
200ba7c: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200ba80: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200ba84: 80 a0 80 18 cmp %g2, %i0
200ba88: 02 80 00 0e be 200bac0 <rtems_string_to_unsigned_long+0x80>
200ba8c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200ba90: 40 00 ab f1 call 2036a54 <__errno>
200ba94: 01 00 00 00 nop
200ba98: c2 02 00 00 ld [ %o0 ], %g1
200ba9c: 80 a0 60 22 cmp %g1, 0x22
200baa0: 32 80 00 07 bne,a 200babc <rtems_string_to_unsigned_long+0x7c>
200baa4: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == ULONG_MAX )))
200baa8: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200baac: 80 a0 bf fd cmp %g2, -3
200bab0: 18 80 00 04 bgu 200bac0 <rtems_string_to_unsigned_long+0x80><== ALWAYS TAKEN
200bab4: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
200bab8: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200babc: 82 10 20 00 clr %g1
}
200bac0: 81 c7 e0 08 ret
200bac4: 91 e8 00 01 restore %g0, %g1, %o0
0200db54 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
200db54: 9d e3 bf 98 save %sp, -104, %sp
unsigned long long result;
char *end;
if ( !n )
200db58: 80 a6 60 00 cmp %i1, 0
200db5c: 02 80 00 23 be 200dbe8 <rtems_string_to_unsigned_long_long+0x94>
200db60: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200db64: 40 00 0a ea call 201070c <__errno>
200db68: 01 00 00 00 nop
200db6c: c0 22 00 00 clr [ %o0 ]
*n = 0;
200db70: c0 26 40 00 clr [ %i1 ]
200db74: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoull( s, &end, base );
200db78: 90 10 00 18 mov %i0, %o0
200db7c: 92 07 bf fc add %fp, -4, %o1
200db80: 40 00 17 f7 call 2013b5c <strtoull>
200db84: 94 10 00 1b mov %i3, %o2
if ( endptr )
200db88: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
200db8c: b8 10 00 08 mov %o0, %i4
200db90: ba 10 00 09 mov %o1, %i5
if ( endptr )
200db94: 02 80 00 03 be 200dba0 <rtems_string_to_unsigned_long_long+0x4c>
200db98: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200db9c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200dba0: 80 a0 80 18 cmp %g2, %i0
200dba4: 02 80 00 11 be 200dbe8 <rtems_string_to_unsigned_long_long+0x94>
200dba8: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dbac: 40 00 0a d8 call 201070c <__errno>
200dbb0: 01 00 00 00 nop
200dbb4: c2 02 00 00 ld [ %o0 ], %g1
200dbb8: 80 a0 60 22 cmp %g1, 0x22
200dbbc: 32 80 00 0a bne,a 200dbe4 <rtems_string_to_unsigned_long_long+0x90>
200dbc0: f8 3e 40 00 std %i4, [ %i1 ]
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
200dbc4: 86 87 7f ff addcc %i5, -1, %g3
200dbc8: 84 47 3f ff addx %i4, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dbcc: 80 a0 bf ff cmp %g2, -1
200dbd0: 12 80 00 04 bne 200dbe0 <rtems_string_to_unsigned_long_long+0x8c><== NEVER TAKEN
200dbd4: 80 a0 ff fd cmp %g3, -3
200dbd8: 18 80 00 04 bgu 200dbe8 <rtems_string_to_unsigned_long_long+0x94><== ALWAYS TAKEN
200dbdc: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
200dbe0: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200dbe4: 82 10 20 00 clr %g1
}
200dbe8: 81 c7 e0 08 ret
200dbec: 91 e8 00 01 restore %g0, %g1, %o0
02002ee4 <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
2002ee4: 9d e3 bd e8 save %sp, -536, %sp
IMFS_jnode_t *node;
int rv = 0;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
rtems_filesystem_eval_path_context_t ctx;
rtems_filesystem_location_info_t rootloc;
rtems_filesystem_location_info_t *currentloc =
2002ee8: 94 10 20 18 mov 0x18, %o2
2002eec: 92 10 00 18 mov %i0, %o1
2002ef0: 40 00 07 ed call 2004ea4 <rtems_filesystem_eval_path_start>
2002ef4: 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(
2002ef8: 92 07 be 78 add %fp, -392, %o1
2002efc: b6 10 00 08 mov %o0, %i3
2002f00: 40 00 08 e3 call 200528c <rtems_filesystem_location_copy_and_detach>
2002f04: 90 07 be 48 add %fp, -440, %o0
static inline void rtems_filesystem_eval_path_set_flags(
rtems_filesystem_eval_path_context_t *ctx,
int flags
)
{
ctx->flags = flags;
2002f08: 82 10 20 60 mov 0x60, %g1
2002f0c: c2 27 be 70 st %g1, [ %fp + -400 ]
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
rootloc.mt_entry->ops != &IMFS_ops
2002f10: c2 07 be 5c ld [ %fp + -420 ], %g1
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
2002f14: 05 00 80 7d sethi %hi(0x201f400), %g2
rootloc.mt_entry->ops != &IMFS_ops
2002f18: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
2002f1c: 84 10 a2 10 or %g2, 0x210, %g2
2002f20: 80 a0 40 02 cmp %g1, %g2
2002f24: 02 80 00 06 be 2002f3c <rtems_tarfs_load+0x58>
2002f28: 05 00 80 7f sethi %hi(0x201fc00), %g2
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
2002f2c: 84 10 a3 80 or %g2, 0x380, %g2 ! 201ff80 <fifoIMFS_ops>
2002f30: 80 a0 40 02 cmp %g1, %g2
2002f34: 32 80 00 66 bne,a 20030cc <rtems_tarfs_load+0x1e8> <== ALWAYS TAKEN
2002f38: b0 10 3f ff mov -1, %i0
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
2002f3c: 25 00 80 7d sethi %hi(0x201f400), %l2
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
2002f40: 27 00 80 7f sethi %hi(0x201fc00), %l3
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
if (full_filename[strlen(full_filename)-1] != '/')
strcat(full_filename, "/");
2002f44: 29 00 80 71 sethi %hi(0x201c400), %l4
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
2002f48: ba 10 20 00 clr %i5
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
2002f4c: a4 14 a2 98 or %l2, 0x298, %l2
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
2002f50: a0 07 be 98 add %fp, -360, %l0
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
2002f54: a6 14 e0 dc or %l3, 0xdc, %l3
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
if (full_filename[strlen(full_filename)-1] != '/')
strcat(full_filename, "/");
2002f58: a8 15 21 f0 or %l4, 0x1f0, %l4
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
2002f5c: b8 07 62 00 add %i5, 0x200, %i4
2002f60: 80 a7 00 1a cmp %i4, %i2
2002f64: 18 80 00 59 bgu 20030c8 <rtems_tarfs_load+0x1e4> <== NEVER TAKEN
2002f68: ba 06 40 1d add %i1, %i5, %i5
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
2002f6c: 92 10 00 12 mov %l2, %o1
2002f70: 90 07 61 01 add %i5, 0x101, %o0
2002f74: 40 00 43 8a call 2013d9c <strncmp>
2002f78: 94 10 20 05 mov 5, %o2
2002f7c: 80 a2 20 00 cmp %o0, 0
2002f80: 12 80 00 52 bne 20030c8 <rtems_tarfs_load+0x1e4>
2002f84: 94 10 20 63 mov 0x63, %o2
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
2002f88: 92 10 00 1d mov %i5, %o1
2002f8c: 40 00 43 da call 2013ef4 <strncpy>
2002f90: 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);
2002f94: 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';
2002f98: c0 2f be fb clrb [ %fp + -261 ]
linkflag = hdr_ptr[156];
2002f9c: ec 0f 60 9c ldub [ %i5 + 0x9c ], %l6
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
2002fa0: 40 00 21 c5 call 200b6b4 <_rtems_octal2ulong>
2002fa4: 90 07 60 64 add %i5, 0x64, %o0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
2002fa8: 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);
2002fac: aa 10 00 08 mov %o0, %l5
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
2002fb0: 40 00 21 c1 call 200b6b4 <_rtems_octal2ulong>
2002fb4: 90 07 60 7c add %i5, 0x7c, %o0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
2002fb8: 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);
2002fbc: a2 10 00 08 mov %o0, %l1
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
2002fc0: 40 00 21 bd call 200b6b4 <_rtems_octal2ulong>
2002fc4: 90 07 60 94 add %i5, 0x94, %o0
2002fc8: ae 10 00 08 mov %o0, %l7
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
2002fcc: 40 00 21 cd call 200b700 <_rtems_tar_header_checksum>
2002fd0: 90 10 00 1d mov %i5, %o0
2002fd4: 80 a2 00 17 cmp %o0, %l7
2002fd8: 12 80 00 3c bne 20030c8 <rtems_tarfs_load+0x1e4> <== NEVER TAKEN
2002fdc: 82 0d a0 ff and %l6, 0xff, %g1
* Generate an IMFS node depending on the file type.
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
2002fe0: 80 a0 60 35 cmp %g1, 0x35
2002fe4: 12 80 00 16 bne 200303c <rtems_tarfs_load+0x158>
2002fe8: 80 a0 60 30 cmp %g1, 0x30
strcpy(full_filename, mountpoint);
2002fec: 92 10 00 18 mov %i0, %o1
2002ff0: 40 00 41 77 call 20135cc <strcpy>
2002ff4: 90 07 bf 00 add %fp, -256, %o0
if (full_filename[strlen(full_filename)-1] != '/')
2002ff8: 40 00 43 37 call 2013cd4 <strlen>
2002ffc: 90 07 bf 00 add %fp, -256, %o0
2003000: 90 07 80 08 add %fp, %o0, %o0
2003004: c2 4a 3e ff ldsb [ %o0 + -257 ], %g1
2003008: 80 a0 60 2f cmp %g1, 0x2f
200300c: 02 80 00 04 be 200301c <rtems_tarfs_load+0x138> <== ALWAYS TAKEN
2003010: 90 07 bf 00 add %fp, -256, %o0
strcat(full_filename, "/");
2003014: 40 00 41 1d call 2013488 <strcat> <== NOT EXECUTED
2003018: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
strcat(full_filename, filename);
200301c: 92 10 00 10 mov %l0, %o1
2003020: 40 00 41 1a call 2013488 <strcat>
2003024: 90 07 bf 00 add %fp, -256, %o0
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
2003028: 90 07 bf 00 add %fp, -256, %o0
200302c: 40 00 03 dc call 2003f9c <mkdir>
2003030: 92 10 21 ff mov 0x1ff, %o1
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
2003034: 10 bf ff ca b 2002f5c <rtems_tarfs_load+0x78>
2003038: ba 10 00 1c mov %i4, %i5
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
}
/*
* Create a LINEAR_FILE node
*/
else if (linkflag == REGTYPE) {
200303c: 12 bf ff c8 bne 2002f5c <rtems_tarfs_load+0x78>
2003040: ba 10 00 1c mov %i4, %i5
rtems_filesystem_location_free( currentloc );
2003044: 40 00 02 3f call 2003940 <rtems_filesystem_location_free>
2003048: 90 10 00 1b mov %i3, %o0
rtems_filesystem_location_clone( currentloc, &rootloc );
200304c: 92 07 be 48 add %fp, -440, %o1
2003050: 40 00 01 6d call 2003604 <rtems_filesystem_location_clone>
2003054: 90 10 00 1b mov %i3, %o0
rtems_filesystem_eval_path_set_path(
2003058: 40 00 43 1f call 2013cd4 <strlen>
200305c: 90 10 00 10 mov %l0, %o0
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
ctx->path = path;
2003060: e0 27 be 60 st %l0, [ %fp + -416 ]
ctx->pathlen = pathlen;
2003064: d0 27 be 64 st %o0, [ %fp + -412 ]
&ctx,
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
2003068: 40 00 07 31 call 2004d2c <rtems_filesystem_eval_path_continue>
200306c: 90 07 be 60 add %fp, -416, %o0
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
2003070: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
2003074: 80 a0 40 13 cmp %g1, %l3
2003078: 02 80 00 0f be 20030b4 <rtems_tarfs_load+0x1d0> <== NEVER TAKEN
200307c: d4 1f be 68 ldd [ %fp + -408 ], %o2
size_t namelen,
mode_t mode,
const IMFS_types_union *info
)
{
const IMFS_fs_info_t *fs_info =
2003080: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
2003084: c2 00 60 08 ld [ %g1 + 8 ], %g1
node = IMFS_create_node(
currentloc,
IMFS_LINEAR_FILE,
rtems_filesystem_eval_path_get_token( &ctx ),
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
2003088: 98 0d 61 ff and %l5, 0x1ff, %o4
200308c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
2003090: 03 00 00 20 sethi %hi(0x8000), %g1
2003094: 90 10 00 1b mov %i3, %o0
2003098: 98 13 00 01 or %o4, %g1, %o4
200309c: 40 00 23 32 call 200bd64 <IMFS_create_node_with_control>
20030a0: 9a 10 20 00 clr %o5
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
20030a4: 84 06 40 1c add %i1, %i4, %g2
rtems_filesystem_eval_path_get_token( &ctx ),
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
20030a8: c0 22 20 50 clr [ %o0 + 0x50 ]
20030ac: e2 22 20 54 st %l1, [ %o0 + 0x54 ]
node->info.linearfile.direct = &tar_image[offset];
20030b0: c4 22 20 58 st %g2, [ %o0 + 0x58 ]
}
nblocks = (((file_size) + 511) & ~511) / 512;
20030b4: a2 04 61 ff add %l1, 0x1ff, %l1
offset += 512 * nblocks;
20030b8: a2 0c 7e 00 and %l1, -512, %l1
20030bc: b8 04 40 1c add %l1, %i4, %i4
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
20030c0: 10 bf ff a7 b 2002f5c <rtems_tarfs_load+0x78>
20030c4: ba 10 00 1c mov %i4, %i5
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
20030c8: b0 10 20 00 clr %i0
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
20030cc: 40 00 02 1d call 2003940 <rtems_filesystem_location_free>
20030d0: 90 07 be 48 add %fp, -440, %o0
rtems_filesystem_eval_path_cleanup( &ctx );
20030d4: 40 00 07 b0 call 2004f94 <rtems_filesystem_eval_path_cleanup>
20030d8: 90 07 be 60 add %fp, -416, %o0
return rv;
}
20030dc: 81 c7 e0 08 ret
20030e0: 81 e8 00 00 restore
020110fc <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
20110fc: 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 )
2011100: 80 a6 a0 00 cmp %i2, 0
2011104: 02 80 00 5a be 201126c <rtems_task_mode+0x170>
2011108: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
201110c: 03 00 80 87 sethi %hi(0x2021c00), %g1
2011110: f8 00 63 20 ld [ %g1 + 0x320 ], %i4 ! 2021f20 <_Per_CPU_Information+0x10>
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
2011114: c2 0f 20 70 ldub [ %i4 + 0x70 ], %g1
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
2011118: fa 07 21 58 ld [ %i4 + 0x158 ], %i5
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
201111c: 80 a0 00 01 cmp %g0, %g1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
2011120: c2 07 20 78 ld [ %i4 + 0x78 ], %g1
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
2011124: b6 60 3f ff subx %g0, -1, %i3
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
2011128: 80 a0 60 00 cmp %g1, 0
201112c: 02 80 00 03 be 2011138 <rtems_task_mode+0x3c>
2011130: b7 2e e0 08 sll %i3, 8, %i3
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
2011134: b6 16 e2 00 or %i3, 0x200, %i3
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
2011138: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
201113c: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
2011140: 7f ff ed 22 call 200c5c8 <_CPU_ISR_Get_level>
2011144: a0 60 3f ff subx %g0, -1, %l0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
2011148: a1 2c 20 0a sll %l0, 0xa, %l0
201114c: 90 14 00 08 or %l0, %o0, %o0
old_mode |= _ISR_Get_level();
2011150: b6 12 00 1b or %o0, %i3, %i3
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
2011154: 80 8e 61 00 btst 0x100, %i1
2011158: 02 80 00 06 be 2011170 <rtems_task_mode+0x74>
201115c: 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;
2011160: 83 36 20 08 srl %i0, 8, %g1
2011164: 82 18 60 01 xor %g1, 1, %g1
2011168: 82 08 60 01 and %g1, 1, %g1
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
201116c: c2 2f 20 70 stb %g1, [ %i4 + 0x70 ]
if ( mask & RTEMS_TIMESLICE_MASK ) {
2011170: 80 8e 62 00 btst 0x200, %i1
2011174: 02 80 00 0b be 20111a0 <rtems_task_mode+0xa4>
2011178: 80 8e 60 0f btst 0xf, %i1
if ( _Modes_Is_timeslice(mode_set) ) {
201117c: 80 8e 22 00 btst 0x200, %i0
2011180: 22 80 00 07 be,a 201119c <rtems_task_mode+0xa0>
2011184: c0 27 20 78 clr [ %i4 + 0x78 ]
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
2011188: 82 10 20 01 mov 1, %g1
201118c: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
2011190: 03 00 80 86 sethi %hi(0x2021800), %g1
2011194: c2 00 61 50 ld [ %g1 + 0x150 ], %g1 ! 2021950 <_Thread_Ticks_per_timeslice>
2011198: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
201119c: 80 8e 60 0f btst 0xf, %i1
20111a0: 02 80 00 06 be 20111b8 <rtems_task_mode+0xbc>
20111a4: 80 8e 64 00 btst 0x400, %i1
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
20111a8: 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 ) );
20111ac: 7f ff c7 1c call 2002e1c <sparc_enable_interrupts>
20111b0: 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 ) {
20111b4: 80 8e 64 00 btst 0x400, %i1
20111b8: 02 80 00 14 be 2011208 <rtems_task_mode+0x10c>
20111bc: 88 10 20 00 clr %g4
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
20111c0: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
20111c4: b1 36 20 0a srl %i0, 0xa, %i0
20111c8: b0 1e 20 01 xor %i0, 1, %i0
20111cc: b0 0e 20 01 and %i0, 1, %i0
if ( is_asr_enabled != asr->is_enabled ) {
20111d0: 80 a6 00 01 cmp %i0, %g1
20111d4: 22 80 00 0e be,a 201120c <rtems_task_mode+0x110>
20111d8: 03 00 80 87 sethi %hi(0x2021c00), %g1
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
20111dc: 7f ff c7 0c call 2002e0c <sparc_disable_interrupts>
20111e0: f0 2f 60 08 stb %i0, [ %i5 + 8 ]
_signals = information->signals_pending;
20111e4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
information->signals_pending = information->signals_posted;
20111e8: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
information->signals_posted = _signals;
20111ec: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
20111f0: c4 27 60 18 st %g2, [ %i5 + 0x18 ]
information->signals_posted = _signals;
_ISR_Enable( _level );
20111f4: 7f ff c7 0a call 2002e1c <sparc_enable_interrupts>
20111f8: 01 00 00 00 nop
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
20111fc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2011200: 80 a0 00 01 cmp %g0, %g1
2011204: 88 40 20 00 addx %g0, 0, %g4
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
2011208: 03 00 80 87 sethi %hi(0x2021c00), %g1
201120c: c4 00 63 08 ld [ %g1 + 0x308 ], %g2 ! 2021f08 <_System_state_Current>
2011210: 80 a0 a0 03 cmp %g2, 3
2011214: 12 80 00 16 bne 201126c <rtems_task_mode+0x170>
2011218: 82 10 20 00 clr %g1
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
201121c: 07 00 80 87 sethi %hi(0x2021c00), %g3
if ( are_signals_pending ||
2011220: 80 89 20 ff btst 0xff, %g4
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
2011224: 86 10 e3 10 or %g3, 0x310, %g3
if ( are_signals_pending ||
2011228: 12 80 00 0a bne 2011250 <rtems_task_mode+0x154>
201122c: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2
2011230: c6 00 e0 14 ld [ %g3 + 0x14 ], %g3
2011234: 80 a0 80 03 cmp %g2, %g3
2011238: 02 80 00 0d be 201126c <rtems_task_mode+0x170>
201123c: 01 00 00 00 nop
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
2011240: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
2011244: 80 a0 a0 00 cmp %g2, 0
2011248: 02 80 00 09 be 201126c <rtems_task_mode+0x170> <== NEVER TAKEN
201124c: 01 00 00 00 nop
_Thread_Dispatch_necessary = true;
2011250: 84 10 20 01 mov 1, %g2 ! 1 <PROM_START+0x1>
2011254: 03 00 80 87 sethi %hi(0x2021c00), %g1
2011258: 82 10 63 10 or %g1, 0x310, %g1 ! 2021f10 <_Per_CPU_Information>
201125c: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
2011260: 40 00 02 6b call 2011c0c <_Thread_Dispatch>
2011264: 01 00 00 00 nop
}
return RTEMS_SUCCESSFUL;
2011268: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
201126c: 81 c7 e0 08 ret
2011270: 91 e8 00 01 restore %g0, %g1, %o0
0200bdf0 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
200bdf0: 9d e3 bf 98 save %sp, -104, %sp
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
200bdf4: 80 a6 60 00 cmp %i1, 0
200bdf8: 02 80 00 08 be 200be18 <rtems_task_set_priority+0x28>
200bdfc: 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 ) );
200be00: 03 00 80 83 sethi %hi(0x2020c00), %g1
200be04: c4 08 63 8c ldub [ %g1 + 0x38c ], %g2 ! 2020f8c <rtems_maximum_priority>
200be08: 80 a6 40 02 cmp %i1, %g2
200be0c: 18 80 00 1e bgu 200be84 <rtems_task_set_priority+0x94>
200be10: 82 10 20 13 mov 0x13, %g1
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
200be14: 80 a6 a0 00 cmp %i2, 0
200be18: 02 80 00 1b be 200be84 <rtems_task_set_priority+0x94>
200be1c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
200be20: 90 10 00 18 mov %i0, %o0
200be24: 40 00 09 a6 call 200e4bc <_Thread_Get>
200be28: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200be2c: c2 07 bf fc ld [ %fp + -4 ], %g1
200be30: 80 a0 60 00 cmp %g1, 0
200be34: 12 80 00 14 bne 200be84 <rtems_task_set_priority+0x94>
200be38: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
200be3c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
200be40: 80 a6 60 00 cmp %i1, 0
200be44: 02 80 00 0d be 200be78 <rtems_task_set_priority+0x88>
200be48: c2 26 80 00 st %g1, [ %i2 ]
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
200be4c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
200be50: 80 a0 60 00 cmp %g1, 0
200be54: 02 80 00 06 be 200be6c <rtems_task_set_priority+0x7c>
200be58: f2 22 20 18 st %i1, [ %o0 + 0x18 ]
200be5c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200be60: 80 a0 40 19 cmp %g1, %i1
200be64: 08 80 00 05 bleu 200be78 <rtems_task_set_priority+0x88> <== ALWAYS TAKEN
200be68: 01 00 00 00 nop
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
200be6c: 92 10 00 19 mov %i1, %o1
200be70: 40 00 08 55 call 200dfc4 <_Thread_Change_priority>
200be74: 94 10 20 00 clr %o2
}
_Thread_Enable_dispatch();
200be78: 40 00 09 85 call 200e48c <_Thread_Enable_dispatch>
200be7c: 01 00 00 00 nop
200be80: 82 10 20 00 clr %g1 ! 0 <PROM_START>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200be84: 81 c7 e0 08 ret
200be88: 91 e8 00 01 restore %g0, %g1, %o0
02006258 <rtems_termios_baud_to_index>:
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
2006258: 82 10 00 08 mov %o0, %g1
int baud_index;
switch (termios_baud) {
200625c: 80 a0 60 09 cmp %g1, 9
2006260: 02 80 00 17 be 20062bc <rtems_termios_baud_to_index+0x64>
2006264: 90 10 20 09 mov 9, %o0
2006268: 80 a0 60 09 cmp %g1, 9
200626c: 18 80 00 23 bgu 20062f8 <rtems_termios_baud_to_index+0xa0>
2006270: 80 a0 60 0e cmp %g1, 0xe
2006274: 80 a0 60 04 cmp %g1, 4
2006278: 02 80 00 11 be 20062bc <rtems_termios_baud_to_index+0x64>
200627c: 90 10 20 04 mov 4, %o0
2006280: 80 a0 60 04 cmp %g1, 4
2006284: 18 80 00 10 bgu 20062c4 <rtems_termios_baud_to_index+0x6c>
2006288: 80 a0 60 06 cmp %g1, 6
200628c: 80 a0 60 01 cmp %g1, 1
2006290: 02 80 00 0b be 20062bc <rtems_termios_baud_to_index+0x64>
2006294: 90 10 20 01 mov 1, %o0
2006298: 80 a0 60 01 cmp %g1, 1
200629c: 0a 80 00 08 bcs 20062bc <rtems_termios_baud_to_index+0x64>
20062a0: 90 10 20 00 clr %o0
20062a4: 80 a0 60 02 cmp %g1, 2
20062a8: 02 80 00 05 be 20062bc <rtems_termios_baud_to_index+0x64>
20062ac: 90 10 20 02 mov 2, %o0
20062b0: 80 a0 60 03 cmp %g1, 3
20062b4: 12 80 00 3b bne 20063a0 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
20062b8: 90 10 20 03 mov 3, %o0
20062bc: 81 c3 e0 08 retl
20062c0: 01 00 00 00 nop
20062c4: 02 bf ff fe be 20062bc <rtems_termios_baud_to_index+0x64>
20062c8: 90 10 20 06 mov 6, %o0 ! 6 <PROM_START+0x6>
20062cc: 80 a0 60 06 cmp %g1, 6
20062d0: 0a bf ff fb bcs 20062bc <rtems_termios_baud_to_index+0x64>
20062d4: 90 10 20 05 mov 5, %o0
20062d8: 80 a0 60 07 cmp %g1, 7
20062dc: 02 bf ff f8 be 20062bc <rtems_termios_baud_to_index+0x64>
20062e0: 90 10 20 07 mov 7, %o0
20062e4: 80 a0 60 08 cmp %g1, 8
20062e8: 12 80 00 2e bne 20063a0 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
20062ec: 90 10 20 08 mov 8, %o0
20062f0: 81 c3 e0 08 retl
20062f4: 01 00 00 00 nop
20062f8: 02 bf ff f1 be 20062bc <rtems_termios_baud_to_index+0x64>
20062fc: 90 10 20 0e mov 0xe, %o0 ! e <PROM_START+0xe>
2006300: 80 a0 60 0e cmp %g1, 0xe
2006304: 18 80 00 10 bgu 2006344 <rtems_termios_baud_to_index+0xec>
2006308: 05 00 00 04 sethi %hi(0x1000), %g2
200630c: 80 a0 60 0b cmp %g1, 0xb
2006310: 02 bf ff eb be 20062bc <rtems_termios_baud_to_index+0x64>
2006314: 90 10 20 0b mov 0xb, %o0
2006318: 80 a0 60 0b cmp %g1, 0xb
200631c: 0a bf ff e8 bcs 20062bc <rtems_termios_baud_to_index+0x64>
2006320: 90 10 20 0a mov 0xa, %o0
2006324: 80 a0 60 0c cmp %g1, 0xc
2006328: 02 bf ff e5 be 20062bc <rtems_termios_baud_to_index+0x64>
200632c: 90 10 20 0c mov 0xc, %o0
2006330: 80 a0 60 0d cmp %g1, 0xd
2006334: 12 80 00 1b bne 20063a0 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
2006338: 90 10 20 0d mov 0xd, %o0
200633c: 81 c3 e0 08 retl
2006340: 01 00 00 00 nop
2006344: 86 10 a0 02 or %g2, 2, %g3
2006348: 80 a0 40 03 cmp %g1, %g3
200634c: 02 bf ff dc be 20062bc <rtems_termios_baud_to_index+0x64>
2006350: 90 10 20 11 mov 0x11, %o0
2006354: 80 a0 40 03 cmp %g1, %g3
2006358: 38 80 00 0b bgu,a 2006384 <rtems_termios_baud_to_index+0x12c>
200635c: 86 10 a0 03 or %g2, 3, %g3
2006360: 80 a0 60 0f cmp %g1, 0xf
2006364: 02 bf ff d6 be 20062bc <rtems_termios_baud_to_index+0x64>
2006368: 90 10 20 0f mov 0xf, %o0
200636c: 84 10 a0 01 or %g2, 1, %g2
2006370: 80 a0 40 02 cmp %g1, %g2
2006374: 12 80 00 0b bne 20063a0 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
2006378: 90 10 20 10 mov 0x10, %o0
200637c: 81 c3 e0 08 retl
2006380: 01 00 00 00 nop
2006384: 80 a0 40 03 cmp %g1, %g3
2006388: 02 bf ff cd be 20062bc <rtems_termios_baud_to_index+0x64>
200638c: 90 10 20 12 mov 0x12, %o0
2006390: 84 10 a0 04 or %g2, 4, %g2
2006394: 80 a0 40 02 cmp %g1, %g2
2006398: 02 bf ff c9 be 20062bc <rtems_termios_baud_to_index+0x64>
200639c: 90 10 20 13 mov 0x13, %o0
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
20063a0: 90 10 3f ff mov -1, %o0
}
return baud_index;
}
20063a4: 81 c3 e0 08 retl
020055d4 <rtems_termios_close>:
rtems_interrupt_enable (level);
}
rtems_status_code
rtems_termios_close (void *arg)
{
20055d4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20055d8: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain(
20055dc: 92 10 20 00 clr %o1
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20055e0: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain(
20055e4: 03 00 80 75 sethi %hi(0x201d400), %g1
20055e8: d0 00 60 80 ld [ %g1 + 0x80 ], %o0 ! 201d480 <rtems_termios_ttyMutex>
20055ec: 40 00 08 36 call 20076c4 <rtems_semaphore_obtain>
20055f0: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
20055f4: 80 a2 20 00 cmp %o0, 0
20055f8: 22 80 00 03 be,a 2005604 <rtems_termios_close+0x30> <== ALWAYS TAKEN
20055fc: c2 07 60 08 ld [ %i5 + 8 ], %g1
2005600: 30 80 00 30 b,a 20056c0 <rtems_termios_close+0xec> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
2005604: 82 00 7f ff add %g1, -1, %g1
2005608: 80 a0 60 00 cmp %g1, 0
200560c: 12 80 00 64 bne 200579c <rtems_termios_close+0x1c8>
2005610: c2 27 60 08 st %g1, [ %i5 + 8 ]
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
2005614: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
2005618: 03 00 80 74 sethi %hi(0x201d000), %g1
200561c: 85 28 a0 05 sll %g2, 5, %g2
2005620: 82 10 61 c4 or %g1, 0x1c4, %g1
2005624: 82 00 40 02 add %g1, %g2, %g1
2005628: c2 00 60 04 ld [ %g1 + 4 ], %g1
200562c: 80 a0 60 00 cmp %g1, 0
2005630: 22 80 00 06 be,a 2005648 <rtems_termios_close+0x74>
2005634: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
2005638: 9f c0 40 00 call %g1
200563c: 90 10 00 1d mov %i5, %o0
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2005640: 10 80 00 11 b 2005684 <rtems_termios_close+0xb0>
2005644: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2005648: 92 10 20 00 clr %o1
200564c: 40 00 08 1e call 20076c4 <rtems_semaphore_obtain>
2005650: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
2005654: 80 a2 20 00 cmp %o0, 0
2005658: 22 80 00 03 be,a 2005664 <rtems_termios_close+0x90> <== ALWAYS TAKEN
200565c: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005660: 30 80 00 18 b,a 20056c0 <rtems_termios_close+0xec> <== NOT EXECUTED
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
2005664: 80 a0 60 00 cmp %g1, 0
2005668: 02 80 00 04 be 2005678 <rtems_termios_close+0xa4>
200566c: 01 00 00 00 nop
2005670: 7f ff fe ad call 2005124 <drainOutput.part.0>
2005674: 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);
2005678: 40 00 08 5c call 20077e8 <rtems_semaphore_release>
200567c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2005680: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005684: 80 a0 60 02 cmp %g1, 2
2005688: 32 80 00 10 bne,a 20056c8 <rtems_termios_close+0xf4>
200568c: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
2005690: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
2005694: 40 00 06 df call 2007210 <rtems_event_send>
2005698: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
200569c: 80 a2 20 00 cmp %o0, 0
20056a0: 22 80 00 03 be,a 20056ac <rtems_termios_close+0xd8> <== ALWAYS TAKEN
20056a4: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
20056a8: 30 80 00 06 b,a 20056c0 <rtems_termios_close+0xec> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
20056ac: 40 00 06 d9 call 2007210 <rtems_event_send>
20056b0: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
20056b4: 80 a2 20 00 cmp %o0, 0
20056b8: 22 80 00 04 be,a 20056c8 <rtems_termios_close+0xf4> <== ALWAYS TAKEN
20056bc: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
rtems_fatal_error_occurred (sc);
20056c0: 40 00 09 de call 2007e38 <rtems_fatal_error_occurred> <== NOT EXECUTED
20056c4: 01 00 00 00 nop <== NOT EXECUTED
}
if (tty->device.lastClose)
20056c8: 80 a0 60 00 cmp %g1, 0
20056cc: 22 80 00 07 be,a 20056e8 <rtems_termios_close+0x114> <== ALWAYS TAKEN
20056d0: c4 07 40 00 ld [ %i5 ], %g2
(*tty->device.lastClose)(tty->major, tty->minor, arg);
20056d4: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
20056d8: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
20056dc: 9f c0 40 00 call %g1 <== NOT EXECUTED
20056e0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
if (tty->forw == NULL) {
20056e4: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED
20056e8: 80 a0 a0 00 cmp %g2, 0
20056ec: 12 80 00 08 bne 200570c <rtems_termios_close+0x138>
20056f0: c2 07 60 04 ld [ %i5 + 4 ], %g1
rtems_termios_ttyTail = tty->back;
20056f4: 05 00 80 75 sethi %hi(0x201d400), %g2
if ( rtems_termios_ttyTail != NULL ) {
20056f8: 80 a0 60 00 cmp %g1, 0
20056fc: 02 80 00 05 be 2005710 <rtems_termios_close+0x13c> <== ALWAYS TAKEN
2005700: c2 20 a0 84 st %g1, [ %g2 + 0x84 ]
rtems_termios_ttyTail->forw = NULL;
2005704: 10 80 00 03 b 2005710 <rtems_termios_close+0x13c> <== NOT EXECUTED
2005708: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
}
} else {
tty->forw->back = tty->back;
200570c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
}
if (tty->back == NULL) {
2005710: c4 07 60 04 ld [ %i5 + 4 ], %g2
2005714: 80 a0 a0 00 cmp %g2, 0
2005718: 12 80 00 08 bne 2005738 <rtems_termios_close+0x164> <== NEVER TAKEN
200571c: c2 07 40 00 ld [ %i5 ], %g1
rtems_termios_ttyHead = tty->forw;
2005720: 05 00 80 75 sethi %hi(0x201d400), %g2
if ( rtems_termios_ttyHead != NULL ) {
2005724: 80 a0 60 00 cmp %g1, 0
2005728: 02 80 00 05 be 200573c <rtems_termios_close+0x168>
200572c: c2 20 a0 88 st %g1, [ %g2 + 0x88 ]
rtems_termios_ttyHead->back = NULL;
2005730: 10 80 00 03 b 200573c <rtems_termios_close+0x168>
2005734: c0 20 60 04 clr [ %g1 + 4 ]
}
} else {
tty->back->forw = tty->forw;
2005738: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
200573c: 40 00 07 b3 call 2007608 <rtems_semaphore_delete>
2005740: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
rtems_semaphore_delete (tty->osem);
2005744: 40 00 07 b1 call 2007608 <rtems_semaphore_delete>
2005748: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
200574c: 40 00 07 af call 2007608 <rtems_semaphore_delete>
2005750: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if ((tty->device.pollRead == NULL) ||
2005754: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
2005758: 80 a0 60 00 cmp %g1, 0
200575c: 02 80 00 06 be 2005774 <rtems_termios_close+0x1a0>
2005760: 01 00 00 00 nop
2005764: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005768: 80 a0 60 02 cmp %g1, 2
200576c: 12 80 00 04 bne 200577c <rtems_termios_close+0x1a8>
2005770: 01 00 00 00 nop
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
2005774: 40 00 07 a5 call 2007608 <rtems_semaphore_delete>
2005778: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
free (tty->rawInBuf.theBuf);
200577c: 7f ff f7 8d call 20035b0 <free>
2005780: d0 07 60 58 ld [ %i5 + 0x58 ], %o0
free (tty->rawOutBuf.theBuf);
2005784: 7f ff f7 8b call 20035b0 <free>
2005788: d0 07 60 7c ld [ %i5 + 0x7c ], %o0
free (tty->cbuf);
200578c: 7f ff f7 89 call 20035b0 <free>
2005790: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
free (tty);
2005794: 7f ff f7 87 call 20035b0 <free>
2005798: 90 10 00 1d mov %i5, %o0
}
rtems_semaphore_release (rtems_termios_ttyMutex);
200579c: 03 00 80 75 sethi %hi(0x201d400), %g1
20057a0: d0 00 60 80 ld [ %g1 + 0x80 ], %o0 ! 201d480 <rtems_termios_ttyMutex>
20057a4: 40 00 08 11 call 20077e8 <rtems_semaphore_release>
20057a8: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
20057ac: 81 c7 e0 08 ret
20057b0: 81 e8 00 00 restore
02006ba4 <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)
{
2006ba4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
2006ba8: c2 06 20 90 ld [ %i0 + 0x90 ], %g1
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
2006bac: 90 10 00 18 mov %i0, %o0
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
2006bb0: b2 00 40 19 add %g1, %i1, %i1
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2006bb4: c2 06 20 b4 ld [ %i0 + 0xb4 ], %g1
2006bb8: 80 a0 60 02 cmp %g1, 2
2006bbc: 12 80 00 0a bne 2006be4 <rtems_termios_dequeue_characters+0x40>
2006bc0: f2 26 20 90 st %i1, [ %i0 + 0x90 ]
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
2006bc4: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0
2006bc8: 40 00 01 92 call 2007210 <rtems_event_send>
2006bcc: 92 10 20 02 mov 2, %o1
if (sc != RTEMS_SUCCESSFUL)
2006bd0: 80 a2 20 00 cmp %o0, 0
2006bd4: 02 80 00 11 be 2006c18 <rtems_termios_dequeue_characters+0x74><== ALWAYS TAKEN
2006bd8: b0 10 20 00 clr %i0
rtems_fatal_error_occurred (sc);
2006bdc: 40 00 04 97 call 2007e38 <rtems_fatal_error_occurred> <== NOT EXECUTED
2006be0: 01 00 00 00 nop <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
2006be4: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
2006be8: 80 a0 60 05 cmp %g1, 5
2006bec: 12 80 00 09 bne 2006c10 <rtems_termios_dequeue_characters+0x6c>
2006bf0: 03 00 80 74 sethi %hi(0x201d000), %g1
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
2006bf4: c2 00 62 78 ld [ %g1 + 0x278 ], %g1 ! 201d278 <rtems_termios_linesw+0xb4>
2006bf8: 80 a0 60 00 cmp %g1, 0
2006bfc: 02 80 00 07 be 2006c18 <rtems_termios_dequeue_characters+0x74><== NEVER TAKEN
2006c00: b0 10 20 00 clr %i0
rtems_termios_linesw[tty->t_line].l_start(tty);
2006c04: 9f c0 40 00 call %g1
2006c08: 01 00 00 00 nop
2006c0c: 30 80 00 03 b,a 2006c18 <rtems_termios_dequeue_characters+0x74>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
2006c10: 7f ff f8 b0 call 2004ed0 <rtems_termios_refill_transmitter>
2006c14: 81 e8 00 00 restore
}
2006c18: 81 c7 e0 08 ret
2006c1c: 81 e8 00 00 restore
0200683c <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)
{
200683c: 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) {
2006840: c4 06 20 cc ld [ %i0 + 0xcc ], %g2
2006844: 03 00 80 74 sethi %hi(0x201d000), %g1
2006848: 85 28 a0 05 sll %g2, 5, %g2
200684c: 82 10 61 c4 or %g1, 0x1c4, %g1
2006850: 84 00 40 02 add %g1, %g2, %g2
2006854: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
2006858: ba 10 00 18 mov %i0, %i5
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
200685c: b8 10 00 01 mov %g1, %i4
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
2006860: 80 a0 a0 00 cmp %g2, 0
2006864: 12 80 00 10 bne 20068a4 <rtems_termios_enqueue_raw_characters+0x68>
2006868: b4 06 40 1a add %i1, %i2, %i2
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
200686c: b6 10 20 00 clr %i3
2006870: 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);
2006874: a2 07 60 30 add %i5, 0x30, %l1
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
2006878: 10 80 00 a5 b 2006b0c <rtems_termios_enqueue_raw_characters+0x2d0>
200687c: a4 07 60 4a add %i5, 0x4a, %l2
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
2006880: d0 0e 40 00 ldub [ %i1 ], %o0
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
2006884: 83 28 60 05 sll %g1, 5, %g1
2006888: 82 07 00 01 add %i4, %g1, %g1
200688c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
2006890: 91 2a 20 18 sll %o0, 0x18, %o0
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
2006894: b2 06 60 01 inc %i1
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
2006898: 91 3a 20 18 sra %o0, 0x18, %o0
200689c: 9f c0 40 00 call %g1
20068a0: 92 10 00 1d mov %i5, %o1
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
20068a4: 80 a6 40 1a cmp %i1, %i2
20068a8: 32 bf ff f6 bne,a 2006880 <rtems_termios_enqueue_raw_characters+0x44>
20068ac: c2 07 60 cc ld [ %i5 + 0xcc ], %g1
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
20068b0: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
20068b4: 80 a0 60 00 cmp %g1, 0
20068b8: 12 80 00 0b bne 20068e4 <rtems_termios_enqueue_raw_characters+0xa8><== NEVER TAKEN
20068bc: b0 10 20 00 clr %i0
20068c0: c2 07 60 dc ld [ %i5 + 0xdc ], %g1
20068c4: 80 a0 60 00 cmp %g1, 0
20068c8: 02 80 00 9b be 2006b34 <rtems_termios_enqueue_raw_characters+0x2f8>
20068cc: 01 00 00 00 nop
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
20068d0: d2 07 60 e0 ld [ %i5 + 0xe0 ], %o1
20068d4: 9f c0 40 00 call %g1
20068d8: 90 07 60 30 add %i5, 0x30, %o0
tty->tty_rcvwakeup = 1;
20068dc: 82 10 20 01 mov 1, %g1
20068e0: c2 27 60 e4 st %g1, [ %i5 + 0xe4 ]
20068e4: 81 c7 e0 08 ret
20068e8: 81 e8 00 00 restore
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
20068ec: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
}
return 0;
}
while (len--) {
c = *buf++;
20068f0: e0 0e 40 00 ldub [ %i1 ], %l0
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
20068f4: 80 88 62 00 btst 0x200, %g1
20068f8: 02 80 00 17 be 2006954 <rtems_termios_enqueue_raw_characters+0x118>
20068fc: 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]) {
2006900: c4 0f 60 4a ldub [ %i5 + 0x4a ], %g2
2006904: 83 2c 20 18 sll %l0, 0x18, %g1
2006908: 83 38 60 18 sra %g1, 0x18, %g1
200690c: 80 a0 40 02 cmp %g1, %g2
2006910: c4 0f 60 49 ldub [ %i5 + 0x49 ], %g2
2006914: 12 80 00 0a bne 200693c <rtems_termios_enqueue_raw_characters+0x100>
2006918: 84 08 a0 ff and %g2, 0xff, %g2
if (c == tty->termios.c_cc[VSTART]) {
200691c: 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;
2006920: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
2006924: 32 80 00 03 bne,a 2006930 <rtems_termios_enqueue_raw_characters+0xf4><== ALWAYS TAKEN
2006928: 82 10 60 10 or %g1, 0x10, %g1
200692c: 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;
2006930: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
2006934: 10 80 00 0b b 2006960 <rtems_termios_enqueue_raw_characters+0x124>
2006938: b6 10 20 01 mov 1, %i3
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
200693c: 80 a0 40 02 cmp %g1, %g2
2006940: 12 80 00 06 bne 2006958 <rtems_termios_enqueue_raw_characters+0x11c><== ALWAYS TAKEN
2006944: 80 8e e0 ff btst 0xff, %i3
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
2006948: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
200694c: 10 bf ff f9 b 2006930 <rtems_termios_enqueue_raw_characters+0xf4><== NOT EXECUTED
2006950: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
2006954: 80 8e e0 ff btst 0xff, %i3
2006958: 02 80 00 1c be 20069c8 <rtems_termios_enqueue_raw_characters+0x18c><== ALWAYS TAKEN
200695c: 01 00 00 00 nop
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
2006960: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2006964: 82 08 60 30 and %g1, 0x30, %g1
2006968: 80 a0 60 20 cmp %g1, 0x20
200696c: 12 80 00 69 bne 2006b10 <rtems_termios_enqueue_raw_characters+0x2d4><== ALWAYS TAKEN
2006970: 80 a6 40 1a cmp %i1, %i2
/* disable interrupts */
rtems_interrupt_disable(level);
2006974: 7f ff ef 14 call 20025c4 <sparc_disable_interrupts> <== NOT EXECUTED
2006978: 01 00 00 00 nop <== NOT EXECUTED
200697c: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
2006980: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006984: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
2006988: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
200698c: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
2006990: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006994: 02 80 00 09 be 20069b8 <rtems_termios_enqueue_raw_characters+0x17c><== NOT EXECUTED
2006998: 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);
200699c: 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)(
20069a0: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
20069a4: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
20069a8: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
20069ac: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
20069b0: 9f c0 40 00 call %g1 <== NOT EXECUTED
20069b4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
20069b8: 7f ff ef 07 call 20025d4 <sparc_enable_interrupts> <== NOT EXECUTED
20069bc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
20069c0: 10 80 00 54 b 2006b10 <rtems_termios_enqueue_raw_characters+0x2d4><== NOT EXECUTED
20069c4: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
20069c8: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
20069cc: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
20069d0: 40 00 47 72 call 2018798 <.urem>
20069d4: 90 02 20 01 inc %o0
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
20069d8: 7f ff ee fb call 20025c4 <sparc_disable_interrupts>
20069dc: b8 10 00 08 mov %o0, %i4
20069e0: a6 10 00 08 mov %o0, %l3
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
20069e4: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
20069e8: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
% tty->rawInBuf.Size) > tty->highwater) &&
20069ec: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
20069f0: 90 22 00 01 sub %o0, %g1, %o0
% tty->rawInBuf.Size) > tty->highwater) &&
20069f4: 40 00 47 69 call 2018798 <.urem>
20069f8: 90 02 00 1c add %o0, %i4, %o0
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
20069fc: c2 07 60 c0 ld [ %i5 + 0xc0 ], %g1
2006a00: 80 a2 00 01 cmp %o0, %g1
2006a04: 08 80 00 2b bleu 2006ab0 <rtems_termios_enqueue_raw_characters+0x274><== ALWAYS TAKEN
2006a08: 01 00 00 00 nop
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
2006a0c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
2006a10: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
2006a14: 12 80 00 27 bne 2006ab0 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
2006a18: 01 00 00 00 nop <== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
2006a1c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006a20: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
2006a24: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
2006a28: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006a2c: 82 08 64 02 and %g1, 0x402, %g1 <== NOT EXECUTED
2006a30: 80 a0 64 00 cmp %g1, 0x400 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
2006a34: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
2006a38: 32 80 00 12 bne,a 2006a80 <rtems_termios_enqueue_raw_characters+0x244><== NOT EXECUTED
2006a3c: 82 08 61 04 and %g1, 0x104, %g1 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
2006a40: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
2006a44: 12 80 00 06 bne 2006a5c <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
2006a48: 01 00 00 00 nop <== NOT EXECUTED
2006a4c: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
2006a50: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006a54: 12 80 00 17 bne 2006ab0 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
2006a58: 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;
2006a5c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2006a60: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
2006a64: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED
2006a68: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2006a6c: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
2006a70: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
2006a74: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006a78: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2006a7c: 30 80 00 0d b,a 2006ab0 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
2006a80: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED
2006a84: 12 80 00 0b bne 2006ab0 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
2006a88: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
2006a8c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006a90: 82 10 60 04 or %g1, 4, %g1 <== NOT EXECUTED
2006a94: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
2006a98: c2 07 60 ac ld [ %i5 + 0xac ], %g1 <== NOT EXECUTED
2006a9c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006aa0: 02 80 00 04 be 2006ab0 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
2006aa4: 01 00 00 00 nop <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
2006aa8: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006aac: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2006ab0: 7f ff ee c9 call 20025d4 <sparc_enable_interrupts>
2006ab4: 90 10 00 13 mov %l3, %o0
if (newTail == tty->rawInBuf.Head) {
2006ab8: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
2006abc: 80 a7 00 01 cmp %i4, %g1
2006ac0: 32 80 00 04 bne,a 2006ad0 <rtems_termios_enqueue_raw_characters+0x294><== ALWAYS TAKEN
2006ac4: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
dropped++;
2006ac8: 10 80 00 11 b 2006b0c <rtems_termios_enqueue_raw_characters+0x2d0><== NOT EXECUTED
2006acc: b0 06 20 01 inc %i0 <== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
2006ad0: e0 28 40 1c stb %l0, [ %g1 + %i4 ]
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
2006ad4: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
2006ad8: f8 27 60 60 st %i4, [ %i5 + 0x60 ]
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
2006adc: 80 a0 60 00 cmp %g1, 0
2006ae0: 12 80 00 0c bne 2006b10 <rtems_termios_enqueue_raw_characters+0x2d4><== NEVER TAKEN
2006ae4: 80 a6 40 1a cmp %i1, %i2
2006ae8: c2 07 60 dc ld [ %i5 + 0xdc ], %g1
2006aec: 80 a0 60 00 cmp %g1, 0
2006af0: 02 80 00 08 be 2006b10 <rtems_termios_enqueue_raw_characters+0x2d4><== ALWAYS TAKEN
2006af4: 80 a6 40 1a cmp %i1, %i2
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
2006af8: d2 07 60 e0 ld [ %i5 + 0xe0 ], %o1 <== NOT EXECUTED
2006afc: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006b00: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
2006b04: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2006b08: c2 27 60 e4 st %g1, [ %i5 + 0xe4 ] <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
2006b0c: 80 a6 40 1a cmp %i1, %i2
2006b10: 12 bf ff 77 bne 20068ec <rtems_termios_enqueue_raw_characters+0xb0>
2006b14: 01 00 00 00 nop
}
}
}
}
tty->rawInBufDropped += dropped;
2006b18: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
2006b1c: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
}
}
}
}
tty->rawInBufDropped += dropped;
2006b20: 82 00 40 18 add %g1, %i0, %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
2006b24: 40 00 03 31 call 20077e8 <rtems_semaphore_release>
2006b28: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
return dropped;
2006b2c: 81 c7 e0 08 ret
2006b30: 81 e8 00 00 restore
}
2006b34: 81 c7 e0 08 ret
2006b38: 81 e8 00 00 restore
020057d4 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
20057d4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20057d8: c2 06 00 00 ld [ %i0 ], %g1
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
20057dc: 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;
20057e0: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
20057e4: 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);
20057e8: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
20057ec: c0 26 20 0c clr [ %i0 + 0xc ]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
20057f0: 92 10 20 00 clr %o1
20057f4: 40 00 07 b4 call 20076c4 <rtems_semaphore_obtain>
20057f8: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
20057fc: b0 92 20 00 orcc %o0, 0, %i0
2005800: 12 80 01 1a bne 2005c68 <rtems_termios_ioctl+0x494> <== NEVER TAKEN
2005804: 01 00 00 00 nop
return sc;
}
switch (args->command) {
2005808: c2 07 20 04 ld [ %i4 + 4 ], %g1
200580c: 80 a0 60 05 cmp %g1, 5
2005810: 22 80 00 e4 be,a 2005ba0 <rtems_termios_ioctl+0x3cc>
2005814: c2 06 c0 00 ld [ %i3 ], %g1
2005818: 18 80 00 12 bgu 2005860 <rtems_termios_ioctl+0x8c>
200581c: 05 10 01 19 sethi %hi(0x40046400), %g2
2005820: 80 a0 60 02 cmp %g1, 2
2005824: 22 80 00 34 be,a 20058f4 <rtems_termios_ioctl+0x120>
2005828: d2 07 20 08 ld [ %i4 + 8 ], %o1
200582c: 18 80 00 07 bgu 2005848 <rtems_termios_ioctl+0x74>
2005830: 80 a0 60 03 cmp %g1, 3
2005834: 80 a0 60 01 cmp %g1, 1
2005838: 32 80 00 1e bne,a 20058b0 <rtems_termios_ioctl+0xdc> <== NEVER TAKEN
200583c: c4 07 60 cc ld [ %i5 + 0xcc ], %g2 <== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
2005840: 10 80 00 29 b 20058e4 <rtems_termios_ioctl+0x110>
2005844: d0 07 20 08 ld [ %i4 + 8 ], %o0
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
2005848: 02 80 00 b3 be 2005b14 <rtems_termios_ioctl+0x340>
200584c: 80 a0 60 04 cmp %g1, 4
2005850: 32 80 00 18 bne,a 20058b0 <rtems_termios_ioctl+0xdc> <== NEVER TAKEN
2005854: 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;
2005858: 10 80 00 d6 b 2005bb0 <rtems_termios_ioctl+0x3dc>
200585c: c2 06 c0 00 ld [ %i3 ], %g1
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
2005860: 84 10 a2 7f or %g2, 0x27f, %g2
2005864: 80 a0 40 02 cmp %g1, %g2
2005868: 02 80 00 f1 be 2005c2c <rtems_termios_ioctl+0x458> <== NEVER TAKEN
200586c: 01 00 00 00 nop
2005870: 38 80 00 07 bgu,a 200588c <rtems_termios_ioctl+0xb8>
2005874: 05 10 01 1d sethi %hi(0x40047400), %g2
2005878: 80 a0 60 06 cmp %g1, 6
200587c: 32 80 00 0d bne,a 20058b0 <rtems_termios_ioctl+0xdc>
2005880: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
2005884: 10 80 00 ab b 2005b30 <rtems_termios_ioctl+0x35c>
2005888: c2 07 20 08 ld [ %i4 + 8 ], %g1
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
200588c: 84 10 a0 1a or %g2, 0x1a, %g2
2005890: 80 a0 40 02 cmp %g1, %g2
2005894: 02 80 00 e3 be 2005c20 <rtems_termios_ioctl+0x44c>
2005898: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
200589c: 07 20 01 1d sethi %hi(0x80047400), %g3
20058a0: 86 10 e0 1b or %g3, 0x1b, %g3 ! 8004741b <RAM_END+0x7dc4741b>
20058a4: 80 a0 40 03 cmp %g1, %g3
20058a8: 02 80 00 c6 be 2005bc0 <rtems_termios_ioctl+0x3ec> <== ALWAYS TAKEN
20058ac: 03 00 80 74 sethi %hi(0x201d000), %g1
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
20058b0: 03 00 80 74 sethi %hi(0x201d000), %g1
20058b4: 85 28 a0 05 sll %g2, 5, %g2
20058b8: 82 10 61 c4 or %g1, 0x1c4, %g1
20058bc: 82 00 40 02 add %g1, %g2, %g1
20058c0: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
20058c4: 80 a0 60 00 cmp %g1, 0
20058c8: 02 80 00 e6 be 2005c60 <rtems_termios_ioctl+0x48c>
20058cc: b0 10 20 0a mov 0xa, %i0
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
20058d0: 90 10 00 1d mov %i5, %o0
20058d4: 9f c0 40 00 call %g1
20058d8: 92 10 00 1c mov %i4, %o1
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
20058dc: 10 80 00 e1 b 2005c60 <rtems_termios_ioctl+0x48c>
20058e0: b0 10 00 08 mov %o0, %i0
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
20058e4: 92 07 60 30 add %i5, 0x30, %o1
20058e8: 40 00 29 b2 call 200ffb0 <memcpy>
20058ec: 94 10 20 24 mov 0x24, %o2
break;
20058f0: 30 80 00 dc b,a 2005c60 <rtems_termios_ioctl+0x48c>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
20058f4: 90 07 60 30 add %i5, 0x30, %o0
20058f8: 40 00 29 ae call 200ffb0 <memcpy>
20058fc: 94 10 20 24 mov 0x24, %o2
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
2005900: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005904: 80 88 62 00 btst 0x200, %g1
2005908: 02 80 00 20 be 2005988 <rtems_termios_ioctl+0x1b4>
200590c: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
2005910: 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) &&
2005914: 80 88 64 00 btst 0x400, %g1
2005918: 12 80 00 1c bne 2005988 <rtems_termios_ioctl+0x1b4>
200591c: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
2005920: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005924: 82 08 7d ef and %g1, -529, %g1
2005928: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
200592c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005930: 80 88 60 20 btst 0x20, %g1
2005934: 02 80 00 15 be 2005988 <rtems_termios_ioctl+0x1b4> <== ALWAYS TAKEN
2005938: 01 00 00 00 nop
/* disable interrupts */
rtems_interrupt_disable(level);
200593c: 7f ff f3 22 call 20025c4 <sparc_disable_interrupts> <== NOT EXECUTED
2005940: 01 00 00 00 nop <== NOT EXECUTED
2005944: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
2005948: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
200594c: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
2005950: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
2005954: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
2005958: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200595c: 02 80 00 09 be 2005980 <rtems_termios_ioctl+0x1ac> <== NOT EXECUTED
2005960: 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);
2005964: 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)(
2005968: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
200596c: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
2005970: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
2005974: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
2005978: 9f c0 40 00 call %g1 <== NOT EXECUTED
200597c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2005980: 7f ff f3 15 call 20025d4 <sparc_enable_interrupts> <== NOT EXECUTED
2005984: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
2005988: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
200598c: 80 88 64 00 btst 0x400, %g1
2005990: 02 80 00 0c be 20059c0 <rtems_termios_ioctl+0x1ec>
2005994: 03 00 00 04 sethi %hi(0x1000), %g1
2005998: c4 07 60 30 ld [ %i5 + 0x30 ], %g2
200599c: 80 88 80 01 btst %g2, %g1
20059a0: 12 80 00 08 bne 20059c0 <rtems_termios_ioctl+0x1ec> <== NEVER TAKEN
20059a4: 01 00 00 00 nop
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
20059a8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20059ac: 82 08 7b ff and %g1, -1025, %g1
20059b0: 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);
20059b4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20059b8: 82 08 7f fd and %g1, -3, %g1
20059bc: 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)) {
20059c0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20059c4: 80 88 61 00 btst 0x100, %g1
20059c8: 02 80 00 16 be 2005a20 <rtems_termios_ioctl+0x24c> <== ALWAYS TAKEN
20059cc: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
20059d0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20059d4: 06 80 00 14 bl 2005a24 <rtems_termios_ioctl+0x250> <== NOT EXECUTED
20059d8: 01 00 00 00 nop <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
20059dc: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
20059e0: 82 08 7e ff and %g1, -257, %g1 <== NOT EXECUTED
20059e4: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
20059e8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
20059ec: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED
20059f0: 02 80 00 08 be 2005a10 <rtems_termios_ioctl+0x23c> <== NOT EXECUTED
20059f4: 01 00 00 00 nop <== NOT EXECUTED
20059f8: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 <== NOT EXECUTED
20059fc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005a00: 02 80 00 04 be 2005a10 <rtems_termios_ioctl+0x23c> <== NOT EXECUTED
2005a04: 01 00 00 00 nop <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
2005a08: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005a0c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
2005a10: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005a14: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
2005a18: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
2005a1c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
2005a20: 80 a0 60 00 cmp %g1, 0
2005a24: 36 80 00 06 bge,a 2005a3c <rtems_termios_ioctl+0x268> <== ALWAYS TAKEN
2005a28: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
tty->flow_ctrl |= FL_MDRTS;
2005a2c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005a30: 82 10 61 00 or %g1, 0x100, %g1 <== NOT EXECUTED
2005a34: 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) {
2005a38: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
2005a3c: 05 00 00 04 sethi %hi(0x1000), %g2
2005a40: 80 88 40 02 btst %g1, %g2
2005a44: 02 80 00 06 be 2005a5c <rtems_termios_ioctl+0x288>
2005a48: 80 88 64 00 btst 0x400, %g1
tty->flow_ctrl |= FL_MDXOF;
2005a4c: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2
2005a50: 84 10 a4 00 or %g2, 0x400, %g2
2005a54: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ]
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
2005a58: 80 88 64 00 btst 0x400, %g1
2005a5c: 22 80 00 06 be,a 2005a74 <rtems_termios_ioctl+0x2a0>
2005a60: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl |= FL_MDXON;
2005a64: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005a68: 82 10 62 00 or %g1, 0x200, %g1
2005a6c: 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) {
2005a70: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
2005a74: 80 88 60 02 btst 2, %g1
2005a78: 02 80 00 04 be 2005a88 <rtems_termios_ioctl+0x2b4>
2005a7c: 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;
2005a80: 10 80 00 19 b 2005ae4 <rtems_termios_ioctl+0x310>
2005a84: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
2005a88: 40 00 05 55 call 2006fdc <rtems_clock_get_ticks_per_second>
2005a8c: f8 0f 60 46 ldub [ %i5 + 0x46 ], %i4
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
2005a90: 40 00 4a 5c call 2018400 <.umul>
2005a94: 92 10 00 1c mov %i4, %o1
rtems_clock_get_ticks_per_second() / 10;
2005a98: 40 00 4a 94 call 20184e8 <.udiv>
2005a9c: 92 10 20 0a mov 0xa, %o1
if (tty->termios.c_cc[VTIME]) {
2005aa0: 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] *
2005aa4: d0 27 60 54 st %o0, [ %i5 + 0x54 ]
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
2005aa8: 80 a0 60 00 cmp %g1, 0
2005aac: 02 80 00 0a be 2005ad4 <rtems_termios_ioctl+0x300>
2005ab0: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
2005ab4: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
2005ab8: 80 88 60 ff btst 0xff, %g1
2005abc: 02 80 00 04 be 2005acc <rtems_termios_ioctl+0x2f8>
2005ac0: d0 27 60 70 st %o0, [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
2005ac4: 10 80 00 0c b 2005af4 <rtems_termios_ioctl+0x320>
2005ac8: c0 27 60 74 clr [ %i5 + 0x74 ]
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
2005acc: 10 80 00 0a b 2005af4 <rtems_termios_ioctl+0x320>
2005ad0: d0 27 60 74 st %o0, [ %i5 + 0x74 ]
} else {
if (tty->termios.c_cc[VMIN]) {
2005ad4: 80 88 60 ff btst 0xff, %g1
2005ad8: 02 80 00 06 be 2005af0 <rtems_termios_ioctl+0x31c> <== ALWAYS TAKEN
2005adc: 82 10 20 01 mov 1, %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
2005ae0: c0 27 60 6c clr [ %i5 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
2005ae4: c0 27 60 70 clr [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
2005ae8: 10 80 00 03 b 2005af4 <rtems_termios_ioctl+0x320>
2005aec: c0 27 60 74 clr [ %i5 + 0x74 ]
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
2005af0: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
}
}
}
if (tty->device.setAttributes)
2005af4: c2 07 60 a8 ld [ %i5 + 0xa8 ], %g1
2005af8: 80 a0 60 00 cmp %g1, 0
2005afc: 02 80 00 59 be 2005c60 <rtems_termios_ioctl+0x48c>
2005b00: 01 00 00 00 nop
(*tty->device.setAttributes)(tty->minor, &tty->termios);
2005b04: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
2005b08: 9f c0 40 00 call %g1
2005b0c: 92 07 60 30 add %i5, 0x30, %o1
2005b10: 30 80 00 54 b,a 2005c60 <rtems_termios_ioctl+0x48c>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
2005b14: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005b18: 80 a0 60 00 cmp %g1, 0
2005b1c: 02 80 00 51 be 2005c60 <rtems_termios_ioctl+0x48c> <== ALWAYS TAKEN
2005b20: 01 00 00 00 nop
2005b24: 7f ff fd 80 call 2005124 <drainOutput.part.0> <== NOT EXECUTED
2005b28: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2005b2c: 30 80 00 4d b,a 2005c60 <rtems_termios_ioctl+0x48c> <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
2005b30: 80 a0 60 01 cmp %g1, 1
2005b34: 02 80 00 07 be 2005b50 <rtems_termios_ioctl+0x37c>
2005b38: 80 a0 60 02 cmp %g1, 2
2005b3c: 02 80 00 0b be 2005b68 <rtems_termios_ioctl+0x394>
2005b40: 80 a0 60 00 cmp %g1, 0
2005b44: 32 80 00 47 bne,a 2005c60 <rtems_termios_ioctl+0x48c>
2005b48: b0 10 20 03 mov 3, %i0
2005b4c: 30 80 00 0e b,a 2005b84 <rtems_termios_ioctl+0x3b0>
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
2005b50: 7f ff f2 9d call 20025c4 <sparc_disable_interrupts>
2005b54: 01 00 00 00 nop
tty->rawOutBuf.Tail = 0;
2005b58: c0 27 60 84 clr [ %i5 + 0x84 ]
tty->rawOutBuf.Head = 0;
2005b5c: c0 27 60 80 clr [ %i5 + 0x80 ]
tty->rawOutBufState = rob_idle;
2005b60: 10 80 00 0d b 2005b94 <rtems_termios_ioctl+0x3c0>
2005b64: c0 27 60 94 clr [ %i5 + 0x94 ]
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
2005b68: 7f ff f2 97 call 20025c4 <sparc_disable_interrupts>
2005b6c: 01 00 00 00 nop
tty->rawOutBuf.Tail = 0;
2005b70: c0 27 60 84 clr [ %i5 + 0x84 ]
tty->rawOutBuf.Head = 0;
2005b74: c0 27 60 80 clr [ %i5 + 0x80 ]
tty->rawOutBufState = rob_idle;
2005b78: c0 27 60 94 clr [ %i5 + 0x94 ]
rtems_interrupt_enable (level);
2005b7c: 7f ff f2 96 call 20025d4 <sparc_enable_interrupts>
2005b80: 01 00 00 00 nop
static void
flushInput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
2005b84: 7f ff f2 90 call 20025c4 <sparc_disable_interrupts>
2005b88: 01 00 00 00 nop
tty->rawInBuf.Tail = 0;
2005b8c: c0 27 60 60 clr [ %i5 + 0x60 ]
tty->rawInBuf.Head = 0;
2005b90: c0 27 60 5c clr [ %i5 + 0x5c ]
rtems_interrupt_enable (level);
2005b94: 7f ff f2 90 call 20025d4 <sparc_enable_interrupts>
2005b98: 01 00 00 00 nop
2005b9c: 30 80 00 31 b,a 2005c60 <rtems_termios_ioctl+0x48c>
break;
}
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
2005ba0: c2 27 60 d4 st %g1, [ %i5 + 0xd4 ]
2005ba4: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
2005ba8: 10 80 00 2e b 2005c60 <rtems_termios_ioctl+0x48c>
2005bac: c2 27 60 d8 st %g1, [ %i5 + 0xd8 ]
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
2005bb0: c2 27 60 dc st %g1, [ %i5 + 0xdc ]
2005bb4: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
2005bb8: 10 80 00 2a b 2005c60 <rtems_termios_ioctl+0x48c>
2005bbc: c2 27 60 e0 st %g1, [ %i5 + 0xe0 ]
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
2005bc0: 82 10 61 c4 or %g1, 0x1c4, %g1
2005bc4: 85 28 a0 05 sll %g2, 5, %g2
2005bc8: 84 00 40 02 add %g1, %g2, %g2
2005bcc: c2 00 a0 04 ld [ %g2 + 4 ], %g1
2005bd0: 80 a0 60 00 cmp %g1, 0
2005bd4: 22 80 00 06 be,a 2005bec <rtems_termios_ioctl+0x418>
2005bd8: c2 07 20 08 ld [ %i4 + 8 ], %g1
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
2005bdc: 9f c0 40 00 call %g1
2005be0: 90 10 00 1d mov %i5, %o0
2005be4: b0 10 00 08 mov %o0, %i0
}
tty->t_line=*(int*)(args->buffer);
2005be8: c2 07 20 08 ld [ %i4 + 8 ], %g1
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
2005bec: 05 00 80 74 sethi %hi(0x201d000), %g2
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
2005bf0: c2 00 40 00 ld [ %g1 ], %g1
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
2005bf4: 84 10 a1 c4 or %g2, 0x1c4, %g2
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
2005bf8: c2 27 60 cc st %g1, [ %i5 + 0xcc ]
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
2005bfc: 83 28 60 05 sll %g1, 5, %g1
2005c00: c2 00 80 01 ld [ %g2 + %g1 ], %g1
2005c04: 80 a0 60 00 cmp %g1, 0
2005c08: 02 80 00 16 be 2005c60 <rtems_termios_ioctl+0x48c>
2005c0c: c0 27 60 d0 clr [ %i5 + 0xd0 ]
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
2005c10: 9f c0 40 00 call %g1
2005c14: 90 10 00 1d mov %i5, %o0
2005c18: 10 80 00 12 b 2005c60 <rtems_termios_ioctl+0x48c>
2005c1c: b0 10 00 08 mov %o0, %i0
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
2005c20: c2 07 20 08 ld [ %i4 + 8 ], %g1
break;
2005c24: 10 80 00 0f b 2005c60 <rtems_termios_ioctl+0x48c>
2005c28: c4 20 40 00 st %g2, [ %g1 ]
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
2005c2c: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
2005c30: c2 07 60 5c ld [ %i5 + 0x5c ], %g1 <== NOT EXECUTED
if ( rawnc < 0 )
2005c34: 82 a0 80 01 subcc %g2, %g1, %g1 <== NOT EXECUTED
2005c38: 3c 80 00 05 bpos,a 2005c4c <rtems_termios_ioctl+0x478> <== NOT EXECUTED
2005c3c: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
2005c40: c4 07 60 64 ld [ %i5 + 0x64 ], %g2 <== NOT EXECUTED
2005c44: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
2005c48: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
2005c4c: c6 07 60 24 ld [ %i5 + 0x24 ], %g3 <== NOT EXECUTED
2005c50: c4 07 20 08 ld [ %i4 + 8 ], %g2 <== NOT EXECUTED
2005c54: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
2005c58: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
2005c5c: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
2005c60: 40 00 06 e2 call 20077e8 <rtems_semaphore_release>
2005c64: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
}
2005c68: 81 c7 e0 08 ret
2005c6c: 81 e8 00 00 restore
02005188 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
2005188: 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(
200518c: 03 00 80 75 sethi %hi(0x201d400), %g1
2005190: d0 00 60 80 ld [ %g1 + 0x80 ], %o0 ! 201d480 <rtems_termios_ttyMutex>
2005194: 92 10 20 00 clr %o1
2005198: 40 00 09 4b call 20076c4 <rtems_semaphore_obtain>
200519c: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
20051a0: b8 92 20 00 orcc %o0, 0, %i4
20051a4: 12 80 01 09 bne 20055c8 <rtems_termios_open+0x440> <== NEVER TAKEN
20051a8: 03 00 80 75 sethi %hi(0x201d400), %g1
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
20051ac: e0 00 60 88 ld [ %g1 + 0x88 ], %l0 ! 201d488 <rtems_termios_ttyHead>
20051b0: 10 80 00 0a b 20051d8 <rtems_termios_open+0x50>
20051b4: ba 10 00 10 mov %l0, %i5
if ((tty->major == major) && (tty->minor == minor))
20051b8: 80 a0 40 18 cmp %g1, %i0
20051bc: 32 80 00 07 bne,a 20051d8 <rtems_termios_open+0x50>
20051c0: fa 07 40 00 ld [ %i5 ], %i5
20051c4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
20051c8: 80 a0 40 19 cmp %g1, %i1
20051cc: 22 80 00 d0 be,a 200550c <rtems_termios_open+0x384> <== ALWAYS TAKEN
20051d0: c2 06 80 00 ld [ %i2 ], %g1
sc = rtems_semaphore_obtain(
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
20051d4: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
20051d8: 80 a7 60 00 cmp %i5, 0
20051dc: 32 bf ff f7 bne,a 20051b8 <rtems_termios_open+0x30>
20051e0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
20051e4: 10 80 00 f2 b 20055ac <rtems_termios_open+0x424>
20051e8: 90 10 20 01 mov 1, %o0
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
20051ec: c2 00 62 d8 ld [ %g1 + 0x2d8 ], %g1
20051f0: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
20051f4: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
20051f8: 7f ff f9 c2 call 2003900 <malloc>
20051fc: 01 00 00 00 nop
2005200: d0 27 60 58 st %o0, [ %i5 + 0x58 ]
if (tty->rawInBuf.theBuf == NULL) {
2005204: 80 a2 20 00 cmp %o0, 0
2005208: 02 80 00 16 be 2005260 <rtems_termios_open+0xd8>
200520c: a2 10 00 08 mov %o0, %l1
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
2005210: 03 00 80 72 sethi %hi(0x201c800), %g1
2005214: c2 00 62 dc ld [ %g1 + 0x2dc ], %g1 ! 201cadc <rtems_termios_raw_output_size>
2005218: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
200521c: d0 07 60 88 ld [ %i5 + 0x88 ], %o0
2005220: 7f ff f9 b8 call 2003900 <malloc>
2005224: 01 00 00 00 nop
2005228: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
if (tty->rawOutBuf.theBuf == NULL) {
200522c: 80 a2 20 00 cmp %o0, 0
2005230: 02 80 00 0a be 2005258 <rtems_termios_open+0xd0>
2005234: a4 10 00 08 mov %o0, %l2
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
2005238: 03 00 80 72 sethi %hi(0x201c800), %g1
200523c: 7f ff f9 b1 call 2003900 <malloc>
2005240: d0 00 62 e0 ld [ %g1 + 0x2e0 ], %o0 ! 201cae0 <rtems_termios_cbufsize>
if (tty->cbuf == NULL) {
2005244: 80 a2 20 00 cmp %o0, 0
2005248: 12 80 00 0e bne 2005280 <rtems_termios_open+0xf8>
200524c: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
free((void *)(tty->rawOutBuf.theBuf));
2005250: 7f ff f8 d8 call 20035b0 <free>
2005254: 90 10 00 12 mov %l2, %o0
free((void *)(tty->rawInBuf.theBuf));
2005258: 7f ff f8 d6 call 20035b0 <free>
200525c: 90 10 00 11 mov %l1, %o0
free(tty);
2005260: 7f ff f8 d4 call 20035b0 <free>
2005264: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release (rtems_termios_ttyMutex);
2005268: 03 00 80 75 sethi %hi(0x201d400), %g1
200526c: d0 00 60 80 ld [ %g1 + 0x80 ], %o0 ! 201d480 <rtems_termios_ttyMutex>
2005270: 40 00 09 5e call 20077e8 <rtems_semaphore_release>
2005274: b8 10 20 1a mov 0x1a, %i4
return RTEMS_NO_MEMORY;
2005278: 81 c7 e0 08 ret
200527c: 91 e8 00 1c restore %g0, %i4, %o0
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
2005280: c0 27 60 d4 clr [ %i5 + 0xd4 ]
tty->tty_snd.sw_arg = NULL;
2005284: c0 27 60 d8 clr [ %i5 + 0xd8 ]
tty->tty_rcv.sw_pfn = NULL;
2005288: c0 27 60 dc clr [ %i5 + 0xdc ]
tty->tty_rcv.sw_arg = NULL;
200528c: c0 27 60 e0 clr [ %i5 + 0xe0 ]
tty->tty_rcvwakeup = 0;
2005290: c0 27 60 e4 clr [ %i5 + 0xe4 ]
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
2005294: e0 27 40 00 st %l0, [ %i5 ]
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
2005298: 80 a4 20 00 cmp %l0, 0
200529c: 02 80 00 03 be 20052a8 <rtems_termios_open+0x120>
20052a0: c0 27 60 04 clr [ %i5 + 4 ]
rtems_termios_ttyHead->back = tty;
20052a4: fa 24 20 04 st %i5, [ %l0 + 4 ]
rtems_termios_ttyHead = tty;
20052a8: 03 00 80 75 sethi %hi(0x201d400), %g1
20052ac: fa 20 60 88 st %i5, [ %g1 + 0x88 ] ! 201d488 <rtems_termios_ttyHead>
if (rtems_termios_ttyTail == NULL)
20052b0: 03 00 80 75 sethi %hi(0x201d400), %g1
20052b4: c4 00 60 84 ld [ %g1 + 0x84 ], %g2 ! 201d484 <rtems_termios_ttyTail>
20052b8: 80 a0 a0 00 cmp %g2, 0
20052bc: 22 80 00 02 be,a 20052c4 <rtems_termios_open+0x13c>
20052c0: fa 20 60 84 st %i5, [ %g1 + 0x84 ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
20052c4: 21 00 80 72 sethi %hi(0x201c800), %l0
20052c8: d0 4c 22 e4 ldsb [ %l0 + 0x2e4 ], %o0 ! 201cae4 <c.6880>
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
20052cc: 03 15 14 9a sethi %hi(0x54526800), %g1
20052d0: 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;
20052d4: f2 27 60 10 st %i1, [ %i5 + 0x10 ]
tty->major = major;
20052d8: f0 27 60 0c st %i0, [ %i5 + 0xc ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
20052dc: 90 12 00 01 or %o0, %g1, %o0
20052e0: 92 10 20 01 mov 1, %o1
20052e4: 94 10 20 54 mov 0x54, %o2
20052e8: 96 10 20 00 clr %o3
20052ec: 40 00 08 59 call 2007450 <rtems_semaphore_create>
20052f0: 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)
20052f4: 80 a2 20 00 cmp %o0, 0
20052f8: 22 80 00 03 be,a 2005304 <rtems_termios_open+0x17c>
20052fc: d0 4c 22 e4 ldsb [ %l0 + 0x2e4 ], %o0
2005300: 30 80 00 a4 b,a 2005590 <rtems_termios_open+0x408>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
2005304: 03 15 14 9b sethi %hi(0x54526c00), %g1
2005308: 82 10 63 00 or %g1, 0x300, %g1 ! 54526f00 <RAM_END+0x52126f00>
200530c: 92 10 20 01 mov 1, %o1
2005310: 90 12 00 01 or %o0, %g1, %o0
2005314: 94 10 20 54 mov 0x54, %o2
2005318: 96 10 20 00 clr %o3
200531c: 40 00 08 4d call 2007450 <rtems_semaphore_create>
2005320: 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)
2005324: 80 a2 20 00 cmp %o0, 0
2005328: 22 80 00 03 be,a 2005334 <rtems_termios_open+0x1ac>
200532c: d0 4c 22 e4 ldsb [ %l0 + 0x2e4 ], %o0
2005330: 30 80 00 98 b,a 2005590 <rtems_termios_open+0x408>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
2005334: 03 15 14 9e sethi %hi(0x54527800), %g1
2005338: 92 10 20 00 clr %o1
200533c: 90 12 00 01 or %o0, %g1, %o0
2005340: 94 10 20 20 mov 0x20, %o2
2005344: 96 10 20 00 clr %o3
2005348: 40 00 08 42 call 2007450 <rtems_semaphore_create>
200534c: 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)
2005350: 80 a2 20 00 cmp %o0, 0
2005354: 22 80 00 03 be,a 2005360 <rtems_termios_open+0x1d8>
2005358: c0 27 60 94 clr [ %i5 + 0x94 ]
200535c: 30 80 00 8d b,a 2005590 <rtems_termios_open+0x408>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
2005360: 90 07 60 98 add %i5, 0x98, %o0
2005364: 92 10 00 1b mov %i3, %o1
2005368: 40 00 2b 12 call 200ffb0 <memcpy>
200536c: 94 10 20 20 mov 0x20, %o2
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2005370: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005374: 80 a0 60 02 cmp %g1, 2
2005378: 32 80 00 1b bne,a 20053e4 <rtems_termios_open+0x25c>
200537c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
2005380: d0 4c 22 e4 ldsb [ %l0 + 0x2e4 ], %o0
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
2005384: 03 15 1e 15 sethi %hi(0x54785400), %g1
2005388: 92 10 20 0a mov 0xa, %o1
200538c: 90 12 00 01 or %o0, %g1, %o0
2005390: 94 10 24 00 mov 0x400, %o2
2005394: 96 10 25 00 mov 0x500, %o3
2005398: 98 10 20 00 clr %o4
200539c: 40 00 09 55 call 20078f0 <rtems_task_create>
20053a0: 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)
20053a4: 80 a2 20 00 cmp %o0, 0
20053a8: 22 80 00 03 be,a 20053b4 <rtems_termios_open+0x22c> <== ALWAYS TAKEN
20053ac: d0 4c 22 e4 ldsb [ %l0 + 0x2e4 ], %o0
20053b0: 30 80 00 78 b,a 2005590 <rtems_termios_open+0x408> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
20053b4: 03 14 9e 15 sethi %hi(0x52785400), %g1
20053b8: 92 10 20 09 mov 9, %o1
20053bc: 90 12 00 01 or %o0, %g1, %o0
20053c0: 94 10 24 00 mov 0x400, %o2
20053c4: 96 10 25 00 mov 0x500, %o3
20053c8: 98 10 20 00 clr %o4
20053cc: 40 00 09 49 call 20078f0 <rtems_task_create>
20053d0: 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)
20053d4: 80 a2 20 00 cmp %o0, 0
20053d8: 22 80 00 03 be,a 20053e4 <rtems_termios_open+0x25c> <== ALWAYS TAKEN
20053dc: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
20053e0: 30 80 00 6c b,a 2005590 <rtems_termios_open+0x408> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
20053e4: 80 a0 60 00 cmp %g1, 0
20053e8: 02 80 00 07 be 2005404 <rtems_termios_open+0x27c>
20053ec: 03 00 80 72 sethi %hi(0x201c800), %g1
20053f0: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
20053f4: 80 a0 60 02 cmp %g1, 2
20053f8: 12 80 00 0f bne 2005434 <rtems_termios_open+0x2ac>
20053fc: 03 00 00 09 sethi %hi(0x2400), %g1
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'r', c),
2005400: 03 00 80 72 sethi %hi(0x201c800), %g1
2005404: d0 48 62 e4 ldsb [ %g1 + 0x2e4 ], %o0 ! 201cae4 <c.6880>
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
2005408: 03 15 14 9c sethi %hi(0x54527000), %g1
200540c: 82 10 62 00 or %g1, 0x200, %g1 ! 54527200 <RAM_END+0x52127200>
2005410: 92 10 20 00 clr %o1
2005414: 90 12 00 01 or %o0, %g1, %o0
2005418: 94 10 20 24 mov 0x24, %o2
200541c: 96 10 20 00 clr %o3
2005420: 40 00 08 0c call 2007450 <rtems_semaphore_create>
2005424: 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)
2005428: 80 a2 20 00 cmp %o0, 0
200542c: 12 80 00 59 bne 2005590 <rtems_termios_open+0x408> <== NEVER TAKEN
2005430: 03 00 00 09 sethi %hi(0x2400), %g1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
2005434: 82 10 61 02 or %g1, 0x102, %g1 ! 2502 <PROM_START+0x2502>
2005438: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
200543c: 03 00 00 06 sethi %hi(0x1800), %g1
2005440: 82 10 60 05 or %g1, 5, %g1 ! 1805 <PROM_START+0x1805>
2005444: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
2005448: 82 10 28 bd mov 0x8bd, %g1
200544c: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
tty->termios.c_lflag =
2005450: 03 00 00 20 sethi %hi(0x8000), %g1
2005454: 82 10 62 3b or %g1, 0x23b, %g1 ! 823b <PROM_START+0x823b>
2005458: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
200545c: 82 10 20 03 mov 3, %g1
2005460: c2 2f 60 41 stb %g1, [ %i5 + 0x41 ]
tty->termios.c_cc[VQUIT] = '\034';
2005464: 82 10 20 1c mov 0x1c, %g1
2005468: c2 2f 60 42 stb %g1, [ %i5 + 0x42 ]
tty->termios.c_cc[VERASE] = '\177';
200546c: 82 10 20 7f mov 0x7f, %g1
2005470: c2 2f 60 43 stb %g1, [ %i5 + 0x43 ]
tty->termios.c_cc[VKILL] = '\025';
2005474: 82 10 20 15 mov 0x15, %g1
2005478: c2 2f 60 44 stb %g1, [ %i5 + 0x44 ]
tty->termios.c_cc[VEOF] = '\004';
200547c: 82 10 20 04 mov 4, %g1
2005480: c2 2f 60 45 stb %g1, [ %i5 + 0x45 ]
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
2005484: 82 10 20 11 mov 0x11, %g1
2005488: c2 2f 60 49 stb %g1, [ %i5 + 0x49 ]
tty->termios.c_cc[VSTOP] = '\023';
200548c: 82 10 20 13 mov 0x13, %g1
2005490: c2 2f 60 4a stb %g1, [ %i5 + 0x4a ]
tty->termios.c_cc[VSUSP] = '\032';
2005494: 82 10 20 1a mov 0x1a, %g1
2005498: c2 2f 60 4b stb %g1, [ %i5 + 0x4b ]
tty->termios.c_cc[VREPRINT] = '\022';
200549c: 82 10 20 12 mov 0x12, %g1
20054a0: c2 2f 60 4d stb %g1, [ %i5 + 0x4d ]
tty->termios.c_cc[VDISCARD] = '\017';
20054a4: 82 10 20 0f mov 0xf, %g1
20054a8: c2 2f 60 4e stb %g1, [ %i5 + 0x4e ]
tty->termios.c_cc[VWERASE] = '\027';
20054ac: 82 10 20 17 mov 0x17, %g1
20054b0: c2 2f 60 4f stb %g1, [ %i5 + 0x4f ]
tty->termios.c_cc[VLNEXT] = '\026';
20054b4: 82 10 20 16 mov 0x16, %g1
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
20054b8: c0 27 60 b8 clr [ %i5 + 0xb8 ]
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
20054bc: c2 2f 60 50 stb %g1, [ %i5 + 0x50 ]
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
20054c0: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
20054c4: c0 2f 60 4c clrb [ %i5 + 0x4c ]
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
20054c8: 83 30 60 01 srl %g1, 1, %g1
20054cc: c2 27 60 bc st %g1, [ %i5 + 0xbc ]
tty->highwater = tty->rawInBuf.Size * 3/4;
20054d0: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
20054d4: c0 2f 60 51 clrb [ %i5 + 0x51 ]
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
20054d8: 85 28 60 01 sll %g1, 1, %g2
20054dc: 82 00 80 01 add %g2, %g1, %g1
20054e0: 83 30 60 02 srl %g1, 2, %g1
20054e4: c2 27 60 c0 st %g1, [ %i5 + 0xc0 ]
/*
* Bump name characer
*/
if (c++ == 'z')
20054e8: 03 00 80 72 sethi %hi(0x201c800), %g1
20054ec: c4 08 62 e4 ldub [ %g1 + 0x2e4 ], %g2 ! 201cae4 <c.6880>
20054f0: c6 48 62 e4 ldsb [ %g1 + 0x2e4 ], %g3
20054f4: 80 a0 e0 7a cmp %g3, 0x7a
20054f8: 12 80 00 03 bne 2005504 <rtems_termios_open+0x37c>
20054fc: 84 00 a0 01 inc %g2
c = 'a';
2005500: 84 10 20 61 mov 0x61, %g2
2005504: c4 28 62 e4 stb %g2, [ %g1 + 0x2e4 ]
}
args->iop->data1 = tty;
2005508: c2 06 80 00 ld [ %i2 ], %g1
200550c: fa 20 60 30 st %i5, [ %g1 + 0x30 ]
if (!tty->refcount++) {
2005510: c2 07 60 08 ld [ %i5 + 8 ], %g1
2005514: 84 00 60 01 add %g1, 1, %g2
2005518: 80 a0 60 00 cmp %g1, 0
200551c: 12 80 00 1f bne 2005598 <rtems_termios_open+0x410>
2005520: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (tty->device.firstOpen)
2005524: c2 07 60 98 ld [ %i5 + 0x98 ], %g1
2005528: 80 a0 60 00 cmp %g1, 0
200552c: 02 80 00 05 be 2005540 <rtems_termios_open+0x3b8>
2005530: 90 10 00 18 mov %i0, %o0
(*tty->device.firstOpen)(major, minor, arg);
2005534: 92 10 00 19 mov %i1, %o1
2005538: 9f c0 40 00 call %g1
200553c: 94 10 00 1a mov %i2, %o2
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2005540: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005544: 80 a0 60 02 cmp %g1, 2
2005548: 12 80 00 15 bne 200559c <rtems_termios_open+0x414>
200554c: 03 00 80 75 sethi %hi(0x201d400), %g1
sc = rtems_task_start(
2005550: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
2005554: 13 00 80 1a sethi %hi(0x2006800), %o1
2005558: 94 10 00 1d mov %i5, %o2
200555c: 40 00 09 8a call 2007b84 <rtems_task_start>
2005560: 92 12 63 3c or %o1, 0x33c, %o1
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
2005564: 80 a2 20 00 cmp %o0, 0
2005568: 22 80 00 03 be,a 2005574 <rtems_termios_open+0x3ec> <== ALWAYS TAKEN
200556c: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
2005570: 30 80 00 08 b,a 2005590 <rtems_termios_open+0x408> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
2005574: 13 00 80 14 sethi %hi(0x2005000), %o1
2005578: 94 10 00 1d mov %i5, %o2
200557c: 40 00 09 82 call 2007b84 <rtems_task_start>
2005580: 92 12 60 b4 or %o1, 0xb4, %o1
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
2005584: 80 a2 20 00 cmp %o0, 0
2005588: 02 80 00 05 be 200559c <rtems_termios_open+0x414> <== ALWAYS TAKEN
200558c: 03 00 80 75 sethi %hi(0x201d400), %g1
rtems_fatal_error_occurred (sc);
2005590: 40 00 0a 2a call 2007e38 <rtems_fatal_error_occurred>
2005594: 01 00 00 00 nop
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
2005598: 03 00 80 75 sethi %hi(0x201d400), %g1
200559c: 40 00 08 93 call 20077e8 <rtems_semaphore_release>
20055a0: d0 00 60 80 ld [ %g1 + 0x80 ], %o0 ! 201d480 <rtems_termios_ttyMutex>
return RTEMS_SUCCESSFUL;
20055a4: 81 c7 e0 08 ret
20055a8: 91 e8 00 1c restore %g0, %i4, %o0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
20055ac: 7f ff f7 4e call 20032e4 <calloc>
20055b0: 92 10 20 e8 mov 0xe8, %o1
if (tty == NULL) {
20055b4: ba 92 20 00 orcc %o0, 0, %i5
20055b8: 32 bf ff 0d bne,a 20051ec <rtems_termios_open+0x64>
20055bc: 03 00 80 72 sethi %hi(0x201c800), %g1
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
free((void *)(tty->rawInBuf.theBuf));
free(tty);
rtems_semaphore_release (rtems_termios_ttyMutex);
20055c0: 10 bf ff 2b b 200526c <rtems_termios_open+0xe4>
20055c4: 03 00 80 75 sethi %hi(0x201d400), %g1
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
return RTEMS_SUCCESSFUL;
}
20055c8: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
20055cc: 81 c7 e0 08 ret <== NOT EXECUTED
20055d0: 81 e8 00 00 restore <== NOT EXECUTED
02005c70 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, size_t len, struct rtems_termios_tty *tty)
{
2005c70: 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) {
2005c74: c2 06 a0 b4 ld [ %i2 + 0xb4 ], %g1
2005c78: 80 a0 60 00 cmp %g1, 0
2005c7c: 12 80 00 08 bne 2005c9c <rtems_termios_puts+0x2c>
2005c80: 92 10 00 18 mov %i0, %o1
(*tty->device.write)(tty->minor, buf, len);
2005c84: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
2005c88: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
2005c8c: 9f c0 40 00 call %g1
2005c90: 94 10 00 19 mov %i1, %o2
return;
2005c94: 81 c7 e0 08 ret
2005c98: 81 e8 00 00 restore
}
newHead = tty->rawOutBuf.Head;
2005c9c: fa 06 a0 80 ld [ %i2 + 0x80 ], %i5
/*
* Send characters to device-specific code
*/
void
rtems_termios_puts (
2005ca0: b2 06 00 19 add %i0, %i1, %i1
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
2005ca4: 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) {
2005ca8: 10 80 00 36 b 2005d80 <rtems_termios_puts+0x110>
2005cac: a0 10 20 01 mov 1, %l0
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
2005cb0: d2 06 a0 88 ld [ %i2 + 0x88 ], %o1
2005cb4: 40 00 4a b9 call 2018798 <.urem>
2005cb8: 90 07 60 01 add %i5, 1, %o0
2005cbc: 10 80 00 0d b 2005cf0 <rtems_termios_puts+0x80>
2005cc0: ba 10 00 08 mov %o0, %i5
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
2005cc4: 7f ff f2 44 call 20025d4 <sparc_enable_interrupts>
2005cc8: 90 10 00 1c mov %i4, %o0
sc = rtems_semaphore_obtain(
2005ccc: d0 06 a0 8c ld [ %i2 + 0x8c ], %o0
2005cd0: 92 10 20 00 clr %o1
2005cd4: 40 00 06 7c call 20076c4 <rtems_semaphore_obtain>
2005cd8: 94 10 20 00 clr %o2
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2005cdc: 80 a2 20 00 cmp %o0, 0
2005ce0: 02 80 00 04 be 2005cf0 <rtems_termios_puts+0x80> <== ALWAYS TAKEN
2005ce4: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
2005ce8: 40 00 08 54 call 2007e38 <rtems_fatal_error_occurred> <== NOT EXECUTED
2005cec: 01 00 00 00 nop <== NOT EXECUTED
rtems_interrupt_disable (level);
2005cf0: 7f ff f2 35 call 20025c4 <sparc_disable_interrupts>
2005cf4: 01 00 00 00 nop
2005cf8: b8 10 00 08 mov %o0, %i4
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
2005cfc: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1
2005d00: 80 a7 40 01 cmp %i5, %g1
2005d04: 22 bf ff f0 be,a 2005cc4 <rtems_termios_puts+0x54>
2005d08: f6 26 a0 94 st %i3, [ %i2 + 0x94 ]
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
2005d0c: c2 06 a0 80 ld [ %i2 + 0x80 ], %g1
2005d10: c6 0e 00 00 ldub [ %i0 ], %g3
2005d14: c4 06 a0 7c ld [ %i2 + 0x7c ], %g2
2005d18: b0 06 20 01 inc %i0
2005d1c: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
2005d20: 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;
2005d24: fa 26 a0 80 st %i5, [ %i2 + 0x80 ]
if (tty->rawOutBufState == rob_idle) {
2005d28: 80 a0 60 00 cmp %g1, 0
2005d2c: 12 80 00 13 bne 2005d78 <rtems_termios_puts+0x108>
2005d30: 01 00 00 00 nop
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
2005d34: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1
2005d38: 80 88 60 10 btst 0x10, %g1
2005d3c: 12 80 00 0b bne 2005d68 <rtems_termios_puts+0xf8> <== NEVER TAKEN
2005d40: 01 00 00 00 nop
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
2005d44: 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)(
2005d48: d2 06 a0 7c ld [ %i2 + 0x7c ], %o1
2005d4c: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
2005d50: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
2005d54: 92 02 40 02 add %o1, %g2, %o1
2005d58: 9f c0 40 00 call %g1
2005d5c: 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;
2005d60: 10 80 00 06 b 2005d78 <rtems_termios_puts+0x108>
2005d64: e0 26 a0 94 st %l0, [ %i2 + 0x94 ]
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
2005d68: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED
2005d6c: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
2005d70: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ] <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
2005d74: e0 26 a0 94 st %l0, [ %i2 + 0x94 ] <== NOT EXECUTED
}
rtems_interrupt_enable (level);
2005d78: 7f ff f2 17 call 20025d4 <sparc_enable_interrupts>
2005d7c: 90 10 00 1c mov %i4, %o0
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
2005d80: 80 a6 00 19 cmp %i0, %i1
2005d84: 12 bf ff cb bne 2005cb0 <rtems_termios_puts+0x40>
2005d88: 01 00 00 00 nop
2005d8c: 81 c7 e0 08 ret
2005d90: 81 e8 00 00 restore
02006484 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
2006484: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2006488: c2 06 00 00 ld [ %i0 ], %g1
uint32_t count = args->count;
char *buffer = args->buffer;
200648c: f4 1e 20 10 ldd [ %i0 + 0x10 ], %i2
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2006490: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
2006494: b8 10 00 18 mov %i0, %i4
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2006498: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
200649c: 92 10 20 00 clr %o1
20064a0: 40 00 04 89 call 20076c4 <rtems_semaphore_obtain>
20064a4: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
20064a8: b0 92 20 00 orcc %o0, 0, %i0
20064ac: 12 80 00 dd bne 2006820 <rtems_termios_read+0x39c> <== NEVER TAKEN
20064b0: 03 00 80 74 sethi %hi(0x201d000), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
20064b4: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
20064b8: 85 28 a0 05 sll %g2, 5, %g2
20064bc: 82 10 61 c4 or %g1, 0x1c4, %g1
20064c0: 82 00 40 02 add %g1, %g2, %g1
20064c4: c2 00 60 08 ld [ %g1 + 8 ], %g1
20064c8: 80 a0 60 00 cmp %g1, 0
20064cc: 02 80 00 06 be 20064e4 <rtems_termios_read+0x60>
20064d0: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
20064d4: 9f c0 40 00 call %g1
20064d8: 92 10 00 1c mov %i4, %o1
20064dc: 10 80 00 ce b 2006814 <rtems_termios_read+0x390>
20064e0: b0 10 00 08 mov %o0, %i0
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
20064e4: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
20064e8: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
20064ec: 80 a0 80 01 cmp %g2, %g1
20064f0: 12 80 00 bf bne 20067ec <rtems_termios_read+0x368> <== NEVER TAKEN
20064f4: 80 a6 e0 00 cmp %i3, 0
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
20064f8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
20064fc: c0 27 60 20 clr [ %i5 + 0x20 ]
tty->read_start_column = tty->column;
2006500: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
if (tty->device.pollRead != NULL &&
2006504: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
2006508: 80 a0 60 00 cmp %g1, 0
200650c: 02 80 00 4c be 200663c <rtems_termios_read+0x1b8>
2006510: c0 27 60 24 clr [ %i5 + 0x24 ]
2006514: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2006518: 80 a0 60 00 cmp %g1, 0
200651c: 32 80 00 49 bne,a 2006640 <rtems_termios_read+0x1bc>
2006520: e0 07 60 74 ld [ %i5 + 0x74 ], %l0
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
2006524: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
2006528: 80 88 60 02 btst 2, %g1
200652c: 02 80 00 13 be 2006578 <rtems_termios_read+0xf4>
2006530: 01 00 00 00 nop
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
2006534: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
2006538: 9f c0 40 00 call %g1
200653c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
2006540: 80 a2 20 00 cmp %o0, 0
2006544: 16 80 00 06 bge 200655c <rtems_termios_read+0xd8>
2006548: 90 0a 20 ff and %o0, 0xff, %o0
rtems_task_wake_after (1);
200654c: 40 00 05 aa call 2007bf4 <rtems_task_wake_after>
2006550: 90 10 20 01 mov 1, %o0
{
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
2006554: 10 bf ff f9 b 2006538 <rtems_termios_read+0xb4>
2006558: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
if (n < 0) {
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
200655c: 7f ff ff 88 call 200637c <siproc>
2006560: 92 10 00 1d mov %i5, %o1
2006564: 80 a2 20 00 cmp %o0, 0
2006568: 22 bf ff f4 be,a 2006538 <rtems_termios_read+0xb4>
200656c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
2006570: 10 80 00 9f b 20067ec <rtems_termios_read+0x368>
2006574: 80 a6 e0 00 cmp %i3, 0
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
2006578: 40 00 02 a1 call 2006ffc <rtems_clock_get_ticks_since_boot>
200657c: 01 00 00 00 nop
2006580: b2 10 00 08 mov %o0, %i1
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
2006584: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
2006588: 9f c0 40 00 call %g1
200658c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
2006590: 80 a2 20 00 cmp %o0, 0
2006594: 36 80 00 1c bge,a 2006604 <rtems_termios_read+0x180>
2006598: 90 0a 20 ff and %o0, 0xff, %o0
if (tty->termios.c_cc[VMIN]) {
200659c: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
20065a0: 80 a0 60 00 cmp %g1, 0
20065a4: 02 80 00 0d be 20065d8 <rtems_termios_read+0x154>
20065a8: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
if (tty->termios.c_cc[VTIME] && tty->ccount) {
20065ac: 80 88 60 ff btst 0xff, %g1
20065b0: 32 80 00 06 bne,a 20065c8 <rtems_termios_read+0x144> <== ALWAYS TAKEN
20065b4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
20065b8: 40 00 05 8f call 2007bf4 <rtems_task_wake_after>
20065bc: 90 10 20 01 mov 1, %o0
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
20065c0: 10 bf ff f2 b 2006588 <rtems_termios_read+0x104>
20065c4: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
if (tty->termios.c_cc[VTIME] && tty->ccount) {
20065c8: 80 a0 60 00 cmp %g1, 0
20065cc: 02 bf ff fb be 20065b8 <rtems_termios_read+0x134>
20065d0: 01 00 00 00 nop
20065d4: 30 80 00 04 b,a 20065e4 <rtems_termios_read+0x160>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
20065d8: 80 88 60 ff btst 0xff, %g1
20065dc: 02 80 00 84 be 20067ec <rtems_termios_read+0x368> <== NEVER TAKEN
20065e0: 80 a6 e0 00 cmp %i3, 0
break;
now = rtems_clock_get_ticks_since_boot();
20065e4: 40 00 02 86 call 2006ffc <rtems_clock_get_ticks_since_boot>
20065e8: 01 00 00 00 nop
if ((now - then) > tty->vtimeTicks) {
20065ec: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
20065f0: 90 22 00 19 sub %o0, %i1, %o0
20065f4: 80 a2 00 01 cmp %o0, %g1
20065f8: 08 bf ff f0 bleu 20065b8 <rtems_termios_read+0x134>
20065fc: 80 a6 e0 00 cmp %i3, 0
2006600: 30 80 00 7b b,a 20067ec <rtems_termios_read+0x368>
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
2006604: 7f ff ff 5e call 200637c <siproc>
2006608: 92 10 00 1d mov %i5, %o1
if (tty->ccount >= tty->termios.c_cc[VMIN])
200660c: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
2006610: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
2006614: 80 a0 80 01 cmp %g2, %g1
2006618: 16 80 00 74 bge 20067e8 <rtems_termios_read+0x364>
200661c: 80 a0 60 00 cmp %g1, 0
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
2006620: 22 bf ff da be,a 2006588 <rtems_termios_read+0x104> <== NEVER TAKEN
2006624: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
2006628: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
200662c: 80 a0 60 00 cmp %g1, 0
2006630: 22 bf ff d6 be,a 2006588 <rtems_termios_read+0x104> <== NEVER TAKEN
2006634: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
2006638: 30 bf ff d0 b,a 2006578 <rtems_termios_read+0xf4>
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
200663c: e0 07 60 74 ld [ %i5 + 0x74 ], %l0
rtems_status_code sc;
int wait = 1;
2006640: 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))) {
2006644: 23 00 80 72 sethi %hi(0x201c800), %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);
2006648: 10 80 00 4b b 2006774 <rtems_termios_read+0x2f0>
200664c: a4 07 60 49 add %i5, 0x49, %l2
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
2006650: d0 07 60 5c ld [ %i5 + 0x5c ], %o0
2006654: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
2006658: 40 00 48 50 call 2018798 <.urem>
200665c: 90 02 20 01 inc %o0
c = tty->rawInBuf.theBuf[newHead];
2006660: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
2006664: e0 08 40 08 ldub [ %g1 + %o0 ], %l0
tty->rawInBuf.Head = newHead;
2006668: d0 27 60 5c st %o0, [ %i5 + 0x5c ]
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
200666c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2006670: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
% tty->rawInBuf.Size)
2006674: 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)
2006678: 82 00 80 01 add %g2, %g1, %g1
% tty->rawInBuf.Size)
200667c: 40 00 48 47 call 2018798 <.urem>
2006680: 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)
2006684: c2 07 60 bc ld [ %i5 + 0xbc ], %g1
2006688: 80 a2 00 01 cmp %o0, %g1
200668c: 3a 80 00 27 bcc,a 2006728 <rtems_termios_read+0x2a4> <== NEVER TAKEN
2006690: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
2006694: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2006698: 82 08 7f fe and %g1, -2, %g1
200669c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
20066a0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20066a4: 82 08 62 02 and %g1, 0x202, %g1
20066a8: 80 a0 62 02 cmp %g1, 0x202
20066ac: 12 80 00 11 bne 20066f0 <rtems_termios_read+0x26c> <== ALWAYS TAKEN
20066b0: 01 00 00 00 nop
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
20066b4: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
20066b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20066bc: 22 80 00 07 be,a 20066d8 <rtems_termios_read+0x254> <== NOT EXECUTED
20066c0: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
20066c4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
20066c8: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
20066cc: 02 80 00 09 be 20066f0 <rtems_termios_read+0x26c> <== NOT EXECUTED
20066d0: 01 00 00 00 nop <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
20066d4: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
20066d8: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
20066dc: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
20066e0: 9f c0 40 00 call %g1 <== NOT EXECUTED
20066e4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
20066e8: 10 80 00 10 b 2006728 <rtems_termios_read+0x2a4> <== NOT EXECUTED
20066ec: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
20066f0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20066f4: 80 88 61 00 btst 0x100, %g1
20066f8: 22 80 00 0c be,a 2006728 <rtems_termios_read+0x2a4> <== ALWAYS TAKEN
20066fc: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl &= ~FL_IRTSOFF;
2006700: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006704: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
2006708: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
200670c: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 <== NOT EXECUTED
2006710: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006714: 22 80 00 05 be,a 2006728 <rtems_termios_read+0x2a4> <== NOT EXECUTED
2006718: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
200671c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006720: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
2006724: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
if (siproc (c, tty))
2006728: 92 10 00 1d mov %i5, %o1
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
200672c: 80 88 60 02 btst 2, %g1
2006730: 02 80 00 09 be 2006754 <rtems_termios_read+0x2d0> <== NEVER TAKEN
2006734: 90 0c 20 ff and %l0, 0xff, %o0
if (siproc (c, tty))
2006738: 7f ff ff 11 call 200637c <siproc>
200673c: 01 00 00 00 nop
2006740: 80 a2 20 00 cmp %o0, 0
2006744: 22 80 00 0c be,a 2006774 <rtems_termios_read+0x2f0>
2006748: e0 07 60 70 ld [ %i5 + 0x70 ], %l0
wait = 0;
200674c: 10 80 00 09 b 2006770 <rtems_termios_read+0x2ec>
2006750: b2 10 20 00 clr %i1
} else {
siproc (c, tty);
2006754: 7f ff ff 0a call 200637c <siproc> <== NOT EXECUTED
2006758: 01 00 00 00 nop <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
200675c: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1 <== NOT EXECUTED
2006760: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
2006764: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2006768: 36 80 00 02 bge,a 2006770 <rtems_termios_read+0x2ec> <== NOT EXECUTED
200676c: b2 10 20 00 clr %i1 <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
2006770: e0 07 60 70 ld [ %i5 + 0x70 ], %l0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
2006774: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
2006778: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
200677c: 80 a0 80 01 cmp %g2, %g1
2006780: 12 80 00 07 bne 200679c <rtems_termios_read+0x318>
2006784: c2 04 62 e0 ld [ %l1 + 0x2e0 ], %g1
}
/*
* Wait for characters
*/
if ( wait ) {
2006788: 80 a6 60 00 cmp %i1, 0
200678c: 02 80 00 18 be 20067ec <rtems_termios_read+0x368>
2006790: 80 a6 e0 00 cmp %i3, 0
sc = rtems_semaphore_obtain(
2006794: 10 80 00 08 b 20067b4 <rtems_termios_read+0x330>
2006798: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
200679c: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
(tty->ccount < (CBUFSIZE-1))) {
20067a0: 82 00 7f ff add %g1, -1, %g1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
20067a4: 80 a0 80 01 cmp %g2, %g1
20067a8: 0a bf ff aa bcs 2006650 <rtems_termios_read+0x1cc> <== ALWAYS TAKEN
20067ac: 80 a6 60 00 cmp %i1, 0
20067b0: 30 bf ff f7 b,a 200678c <rtems_termios_read+0x308> <== NOT EXECUTED
/*
* Wait for characters
*/
if ( wait ) {
sc = rtems_semaphore_obtain(
20067b4: d2 07 60 6c ld [ %i5 + 0x6c ], %o1
20067b8: 40 00 03 c3 call 20076c4 <rtems_semaphore_obtain>
20067bc: 94 10 00 10 mov %l0, %o2
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
20067c0: 80 a2 20 00 cmp %o0, 0
20067c4: 02 bf ff ec be 2006774 <rtems_termios_read+0x2f0> <== ALWAYS TAKEN
20067c8: 80 a6 e0 00 cmp %i3, 0
20067cc: 30 80 00 08 b,a 20067ec <rtems_termios_read+0x368> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
20067d0: b6 06 ff ff add %i3, -1, %i3
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
20067d4: c4 08 80 01 ldub [ %g2 + %g1 ], %g2
20067d8: 82 00 60 01 inc %g1
20067dc: c4 2e 80 00 stb %g2, [ %i2 ]
20067e0: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
20067e4: b4 06 a0 01 inc %i2
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
20067e8: 80 a6 e0 00 cmp %i3, 0
20067ec: 22 80 00 08 be,a 200680c <rtems_termios_read+0x388>
20067f0: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
20067f4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
20067f8: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
20067fc: 80 a0 40 02 cmp %g1, %g2
2006800: 26 bf ff f4 bl,a 20067d0 <rtems_termios_read+0x34c>
2006804: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
2006808: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
200680c: b6 20 40 1b sub %g1, %i3, %i3
2006810: f6 27 20 1c st %i3, [ %i4 + 0x1c ]
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
2006814: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
2006818: 40 00 03 f4 call 20077e8 <rtems_semaphore_release>
200681c: c0 27 60 e4 clr [ %i5 + 0xe4 ]
return sc;
}
2006820: 81 c7 e0 08 ret
2006824: 81 e8 00 00 restore
02004ed0 <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)
{
2004ed0: 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))
2004ed4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
2004ed8: 82 08 64 03 and %g1, 0x403, %g1
2004edc: 80 a0 64 01 cmp %g1, 0x401
2004ee0: 12 80 00 0f bne 2004f1c <rtems_termios_refill_transmitter+0x4c><== ALWAYS TAKEN
2004ee4: ba 10 00 18 mov %i0, %i5
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
2004ee8: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
2004eec: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
2004ef0: 92 06 20 4a add %i0, 0x4a, %o1 <== NOT EXECUTED
2004ef4: 9f c0 40 00 call %g1 <== NOT EXECUTED
2004ef8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
2004efc: 7f ff f5 b2 call 20025c4 <sparc_disable_interrupts> <== NOT EXECUTED
2004f00: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
2004f04: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
2004f08: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
2004f0c: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
2004f10: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
2004f14: 10 80 00 12 b 2004f5c <rtems_termios_refill_transmitter+0x8c><== NOT EXECUTED
2004f18: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
2004f1c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
2004f20: 82 08 60 03 and %g1, 3, %g1
2004f24: 80 a0 60 02 cmp %g1, 2
2004f28: 12 80 00 12 bne 2004f70 <rtems_termios_refill_transmitter+0xa0><== ALWAYS TAKEN
2004f2c: 92 06 20 49 add %i0, 0x49, %o1
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
2004f30: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
2004f34: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
2004f38: 9f c0 40 00 call %g1 <== NOT EXECUTED
2004f3c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
2004f40: 7f ff f5 a1 call 20025c4 <sparc_disable_interrupts> <== NOT EXECUTED
2004f44: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
2004f48: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
2004f4c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
2004f50: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
2004f54: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
2004f58: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED
2004f5c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
2004f60: 7f ff f5 9d call 20025d4 <sparc_enable_interrupts> <== NOT EXECUTED
2004f64: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2004f68: 81 c7 e0 08 ret
2004f6c: 81 e8 00 00 restore
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
2004f70: c4 06 20 80 ld [ %i0 + 0x80 ], %g2
2004f74: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
2004f78: 80 a0 80 01 cmp %g2, %g1
2004f7c: 12 80 00 0a bne 2004fa4 <rtems_termios_refill_transmitter+0xd4>
2004f80: 01 00 00 00 nop
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
2004f84: c2 06 20 94 ld [ %i0 + 0x94 ], %g1
2004f88: 80 a0 60 02 cmp %g1, 2
2004f8c: 12 bf ff f7 bne 2004f68 <rtems_termios_refill_transmitter+0x98><== ALWAYS TAKEN
2004f90: b0 10 20 00 clr %i0
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
2004f94: 40 00 0a 15 call 20077e8 <rtems_semaphore_release> <== NOT EXECUTED
2004f98: d0 07 60 8c ld [ %i5 + 0x8c ], %o0 <== NOT EXECUTED
2004f9c: 81 c7 e0 08 ret <== NOT EXECUTED
2004fa0: 81 e8 00 00 restore <== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
2004fa4: 7f ff f5 88 call 20025c4 <sparc_disable_interrupts>
2004fa8: 01 00 00 00 nop
len = tty->t_dqlen;
2004fac: f8 06 20 90 ld [ %i0 + 0x90 ], %i4
tty->t_dqlen = 0;
2004fb0: c0 26 20 90 clr [ %i0 + 0x90 ]
rtems_interrupt_enable(level);
2004fb4: 7f ff f5 88 call 20025d4 <sparc_enable_interrupts>
2004fb8: 01 00 00 00 nop
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
2004fbc: d0 06 20 84 ld [ %i0 + 0x84 ], %o0
2004fc0: d2 06 20 88 ld [ %i0 + 0x88 ], %o1
2004fc4: 40 00 4d f5 call 2018798 <.urem>
2004fc8: 90 07 00 08 add %i4, %o0, %o0
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
2004fcc: 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;
2004fd0: d0 27 60 84 st %o0, [ %i5 + 0x84 ]
if (tty->rawOutBufState == rob_wait) {
2004fd4: 80 a0 60 02 cmp %g1, 2
2004fd8: 12 80 00 04 bne 2004fe8 <rtems_termios_refill_transmitter+0x118>
2004fdc: b8 10 00 08 mov %o0, %i4
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
2004fe0: 40 00 0a 02 call 20077e8 <rtems_semaphore_release>
2004fe4: d0 06 20 8c ld [ %i0 + 0x8c ], %o0
}
if (newTail == tty->rawOutBuf.Head) {
2004fe8: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
2004fec: 80 a7 00 01 cmp %i4, %g1
2004ff0: 12 80 00 0b bne 200501c <rtems_termios_refill_transmitter+0x14c>
2004ff4: 01 00 00 00 nop
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
2004ff8: c2 07 60 d4 ld [ %i5 + 0xd4 ], %g1
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
2004ffc: 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) {
2005000: 80 a0 60 00 cmp %g1, 0
2005004: 02 80 00 29 be 20050a8 <rtems_termios_refill_transmitter+0x1d8><== ALWAYS TAKEN
2005008: b0 10 20 00 clr %i0
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
200500c: d2 07 60 d8 ld [ %i5 + 0xd8 ], %o1 <== NOT EXECUTED
2005010: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005014: 90 07 60 30 add %i5, 0x30, %o0 <== NOT EXECUTED
2005018: 30 80 00 24 b,a 20050a8 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
200501c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005020: 82 08 62 10 and %g1, 0x210, %g1
2005024: 80 a0 62 10 cmp %g1, 0x210
2005028: 12 80 00 0c bne 2005058 <rtems_termios_refill_transmitter+0x188><== ALWAYS TAKEN
200502c: 01 00 00 00 nop
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
2005030: 7f ff f5 65 call 20025c4 <sparc_disable_interrupts> <== NOT EXECUTED
2005034: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
2005038: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
200503c: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
2005040: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
2005044: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2005048: c2 27 60 94 st %g1, [ %i5 + 0x94 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
200504c: 7f ff f5 62 call 20025d4 <sparc_enable_interrupts> <== NOT EXECUTED
2005050: b0 10 20 00 clr %i0 <== NOT EXECUTED
2005054: 30 80 00 15 b,a 20050a8 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
2005058: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
200505c: 80 a7 00 01 cmp %i4, %g1
2005060: 08 80 00 04 bleu 2005070 <rtems_termios_refill_transmitter+0x1a0>
2005064: 01 00 00 00 nop
nToSend = tty->rawOutBuf.Size - newTail;
2005068: f0 07 60 88 ld [ %i5 + 0x88 ], %i0
200506c: 30 80 00 02 b,a 2005074 <rtems_termios_refill_transmitter+0x1a4>
else
nToSend = tty->rawOutBuf.Head - newTail;
2005070: f0 07 60 80 ld [ %i5 + 0x80 ], %i0
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
2005074: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005078: 80 88 66 00 btst 0x600, %g1
200507c: 02 80 00 03 be 2005088 <rtems_termios_refill_transmitter+0x1b8>
2005080: b0 26 00 1c sub %i0, %i4, %i0
nToSend = 1;
2005084: b0 10 20 01 mov 1, %i0
}
tty->rawOutBufState = rob_busy; /*apm*/
2005088: 82 10 20 01 mov 1, %g1
(*tty->device.write)(
200508c: d2 07 60 7c ld [ %i5 + 0x7c ], %o1
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
2005090: c2 27 60 94 st %g1, [ %i5 + 0x94 ]
(*tty->device.write)(
2005094: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
2005098: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
200509c: 92 02 40 1c add %o1, %i4, %o1
20050a0: 9f c0 40 00 call %g1
20050a4: 94 10 00 18 mov %i0, %o2
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
20050a8: f8 27 60 84 st %i4, [ %i5 + 0x84 ]
}
return nToSend;
}
20050ac: 81 c7 e0 08 ret
20050b0: 81 e8 00 00 restore
02006b3c <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
2006b3c: 9d e3 bf 98 save %sp, -104, %sp
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
2006b40: 90 10 20 03 mov 3, %o0
2006b44: 92 10 20 02 mov 2, %o1
2006b48: 94 10 20 00 clr %o2
2006b4c: 40 00 01 4f call 2007088 <rtems_event_receive>
2006b50: 96 07 bf fc add %fp, -4, %o3
(TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
2006b54: c2 07 bf fc ld [ %fp + -4 ], %g1
2006b58: 80 88 60 01 btst 1, %g1
2006b5c: 22 80 00 06 be,a 2006b74 <rtems_termios_rxdaemon+0x38> <== ALWAYS TAKEN
2006b60: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1
tty->rxTaskId = 0;
2006b64: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
2006b68: 40 00 03 ac call 2007a18 <rtems_task_delete> <== NOT EXECUTED
2006b6c: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
2006b70: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED
2006b74: 9f c0 40 00 call %g1
2006b78: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
if (c != EOF) {
2006b7c: 80 a2 3f ff cmp %o0, -1
2006b80: 22 bf ff f1 be,a 2006b44 <rtems_termios_rxdaemon+0x8>
2006b84: 90 10 20 03 mov 3, %o0
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
2006b88: d0 2f bf fb stb %o0, [ %fp + -5 ]
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
2006b8c: 92 07 bf fb add %fp, -5, %o1
2006b90: 90 10 00 18 mov %i0, %o0
2006b94: 7f ff ff 2a call 200683c <rtems_termios_enqueue_raw_characters>
2006b98: 94 10 20 01 mov 1, %o2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
2006b9c: 10 bf ff ea b 2006b44 <rtems_termios_rxdaemon+0x8>
2006ba0: 90 10 20 03 mov 3, %o0
020050b4 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
20050b4: 9d e3 bf 98 save %sp, -104, %sp
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
20050b8: 3b 00 80 74 sethi %hi(0x201d000), %i5
20050bc: ba 17 61 c4 or %i5, 0x1c4, %i5 ! 201d1c4 <rtems_termios_linesw>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
20050c0: 90 10 20 03 mov 3, %o0
20050c4: 92 10 20 02 mov 2, %o1
20050c8: 94 10 20 00 clr %o2
20050cc: 40 00 07 ef call 2007088 <rtems_event_receive>
20050d0: 96 07 bf fc add %fp, -4, %o3
(TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
20050d4: c2 07 bf fc ld [ %fp + -4 ], %g1
20050d8: 80 88 60 01 btst 1, %g1
20050dc: 22 80 00 06 be,a 20050f4 <rtems_termios_txdaemon+0x40> <== ALWAYS TAKEN
20050e0: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
tty->txTaskId = 0;
20050e4: c0 26 20 c8 clr [ %i0 + 0xc8 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
20050e8: 40 00 0a 4c call 2007a18 <rtems_task_delete> <== NOT EXECUTED
20050ec: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
20050f0: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
20050f4: 83 28 60 05 sll %g1, 5, %g1
20050f8: 82 07 40 01 add %i5, %g1, %g1
20050fc: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
2005100: 80 a0 60 00 cmp %g1, 0
2005104: 02 80 00 04 be 2005114 <rtems_termios_txdaemon+0x60> <== ALWAYS TAKEN
2005108: 01 00 00 00 nop
rtems_termios_linesw[tty->t_line].l_start(tty);
200510c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005110: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
2005114: 7f ff ff 6f call 2004ed0 <rtems_termios_refill_transmitter>
2005118: 90 10 00 18 mov %i0, %o0
}
200511c: 10 bf ff ea b 20050c4 <rtems_termios_txdaemon+0x10>
2005120: 90 10 20 03 mov 3, %o0
020063c4 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
20063c4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20063c8: c2 06 00 00 ld [ %i0 ], %g1
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
20063cc: b8 10 00 18 mov %i0, %i4
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20063d0: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
20063d4: 92 10 20 00 clr %o1
20063d8: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
20063dc: 40 00 04 ba call 20076c4 <rtems_semaphore_obtain>
20063e0: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
20063e4: b0 92 20 00 orcc %o0, 0, %i0
20063e8: 12 80 00 25 bne 200647c <rtems_termios_write+0xb8> <== NEVER TAKEN
20063ec: 03 00 80 74 sethi %hi(0x201d000), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
20063f0: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
20063f4: 85 28 a0 05 sll %g2, 5, %g2
20063f8: 82 10 61 c4 or %g1, 0x1c4, %g1
20063fc: 82 00 40 02 add %g1, %g2, %g1
2006400: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2006404: 80 a0 60 00 cmp %g1, 0
2006408: 02 80 00 06 be 2006420 <rtems_termios_write+0x5c>
200640c: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
2006410: 9f c0 40 00 call %g1
2006414: 92 10 00 1c mov %i4, %o1
2006418: 10 80 00 17 b 2006474 <rtems_termios_write+0xb0>
200641c: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
2006420: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
2006424: b6 10 20 00 clr %i3
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
2006428: 80 88 60 01 btst 1, %g1
200642c: f4 07 20 14 ld [ %i4 + 0x14 ], %i2
2006430: 12 80 00 07 bne 200644c <rtems_termios_write+0x88> <== ALWAYS TAKEN
2006434: f2 07 20 10 ld [ %i4 + 0x10 ], %i1
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
2006438: 10 80 00 0a b 2006460 <rtems_termios_write+0x9c> <== NOT EXECUTED
200643c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
2006440: 92 10 00 1d mov %i5, %o1
2006444: 7f ff fe 54 call 2005d94 <oproc>
2006448: b6 06 e0 01 inc %i3
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
200644c: 80 a6 c0 1a cmp %i3, %i2
2006450: 32 bf ff fc bne,a 2006440 <rtems_termios_write+0x7c>
2006454: d0 0e 40 1b ldub [ %i1 + %i3 ], %o0
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
2006458: 10 80 00 06 b 2006470 <rtems_termios_write+0xac>
200645c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
2006460: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2006464: 7f ff fe 03 call 2005c70 <rtems_termios_puts> <== NOT EXECUTED
2006468: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
args->bytes_moved = args->count;
200646c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 <== NOT EXECUTED
2006470: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
}
rtems_semaphore_release (tty->osem);
2006474: 40 00 04 dd call 20077e8 <rtems_semaphore_release>
2006478: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
}
200647c: 81 c7 e0 08 ret
2006480: 81 e8 00 00 restore
02018324 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
2018324: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
2018328: 11 00 80 f4 sethi %hi(0x203d000), %o0
201832c: 92 10 00 18 mov %i0, %o1
2018330: 90 12 23 28 or %o0, 0x328, %o0
2018334: 40 00 0c 3b call 201b420 <_Objects_Get>
2018338: 94 07 bf fc add %fp, -4, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
201833c: c2 07 bf fc ld [ %fp + -4 ], %g1
2018340: 80 a0 60 00 cmp %g1, 0
2018344: 12 80 00 0c bne 2018374 <rtems_timer_cancel+0x50>
2018348: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
201834c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
2018350: 80 a0 60 04 cmp %g1, 4
2018354: 02 80 00 04 be 2018364 <rtems_timer_cancel+0x40> <== NEVER TAKEN
2018358: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_timer->Ticker );
201835c: 40 00 14 07 call 201d378 <_Watchdog_Remove>
2018360: 90 02 20 10 add %o0, 0x10, %o0
_Thread_Enable_dispatch();
2018364: 40 00 10 11 call 201c3a8 <_Thread_Enable_dispatch>
2018368: b0 10 20 00 clr %i0
201836c: 81 c7 e0 08 ret
2018370: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2018374: 81 c7 e0 08 ret
2018378: 91 e8 20 04 restore %g0, 4, %o0
02018834 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
2018834: 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;
2018838: 03 00 80 f4 sethi %hi(0x203d000), %g1
201883c: f8 00 63 68 ld [ %g1 + 0x368 ], %i4 ! 203d368 <_Timer_server>
if ( !timer_server )
2018840: 80 a7 20 00 cmp %i4, 0
2018844: 02 80 00 3c be 2018934 <rtems_timer_server_fire_when+0x100>
2018848: 82 10 20 0e mov 0xe, %g1
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
201884c: 21 00 80 f2 sethi %hi(0x203c800), %l0
2018850: 82 14 20 f8 or %l0, 0xf8, %g1 ! 203c8f8 <_TOD>
2018854: c4 08 60 14 ldub [ %g1 + 0x14 ], %g2
2018858: 80 a0 a0 00 cmp %g2, 0
201885c: 02 80 00 36 be 2018934 <rtems_timer_server_fire_when+0x100><== NEVER TAKEN
2018860: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( !routine )
2018864: 80 a6 a0 00 cmp %i2, 0
2018868: 02 80 00 33 be 2018934 <rtems_timer_server_fire_when+0x100>
201886c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
2018870: 7f ff f3 7f call 201566c <_TOD_Validate>
2018874: 90 10 00 19 mov %i1, %o0
2018878: 80 8a 20 ff btst 0xff, %o0
201887c: 02 80 00 2e be 2018934 <rtems_timer_server_fire_when+0x100>
2018880: 82 10 20 14 mov 0x14, %g1
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
2018884: 7f ff f3 40 call 2015584 <_TOD_To_seconds>
2018888: 90 10 00 19 mov %i1, %o0
201888c: b2 10 00 08 mov %o0, %i1
2018890: d0 1c 20 f8 ldd [ %l0 + 0xf8 ], %o0
2018894: 94 10 20 00 clr %o2
2018898: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
201889c: 40 00 4f b7 call 202c778 <__divdi3>
20188a0: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
if ( seconds <= _TOD_Seconds_since_epoch() )
20188a4: 80 a6 40 09 cmp %i1, %o1
20188a8: 08 80 00 23 bleu 2018934 <rtems_timer_server_fire_when+0x100>
20188ac: 82 10 20 14 mov 0x14, %g1
20188b0: 11 00 80 f4 sethi %hi(0x203d000), %o0
20188b4: 92 10 00 18 mov %i0, %o1
20188b8: 90 12 23 28 or %o0, 0x328, %o0
20188bc: 40 00 0a d9 call 201b420 <_Objects_Get>
20188c0: 94 07 bf fc add %fp, -4, %o2
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
20188c4: c2 07 bf fc ld [ %fp + -4 ], %g1
20188c8: 80 a0 60 00 cmp %g1, 0
20188cc: 12 80 00 19 bne 2018930 <rtems_timer_server_fire_when+0xfc>
20188d0: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
20188d4: 40 00 12 a9 call 201d378 <_Watchdog_Remove>
20188d8: 90 02 20 10 add %o0, 0x10, %o0
20188dc: d0 1c 20 f8 ldd [ %l0 + 0xf8 ], %o0
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
20188e0: 82 10 20 03 mov 3, %g1
20188e4: 94 10 20 00 clr %o2
20188e8: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20188ec: c0 27 60 18 clr [ %i5 + 0x18 ]
the_watchdog->routine = routine;
20188f0: f4 27 60 2c st %i2, [ %i5 + 0x2c ]
the_watchdog->id = id;
20188f4: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
the_watchdog->user_data = user_data;
20188f8: f6 27 60 34 st %i3, [ %i5 + 0x34 ]
20188fc: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2018900: 40 00 4f 9e call 202c778 <__divdi3>
2018904: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
(*timer_server->schedule_operation)( timer_server, the_timer );
2018908: c2 07 20 04 ld [ %i4 + 4 ], %g1
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
201890c: 92 26 40 09 sub %i1, %o1, %o1
(*timer_server->schedule_operation)( timer_server, the_timer );
2018910: 90 10 00 1c mov %i4, %o0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
2018914: d2 27 60 1c st %o1, [ %i5 + 0x1c ]
(*timer_server->schedule_operation)( timer_server, the_timer );
2018918: 9f c0 40 00 call %g1
201891c: 92 10 00 1d mov %i5, %o1
_Thread_Enable_dispatch();
2018920: 40 00 0e a2 call 201c3a8 <_Thread_Enable_dispatch>
2018924: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
2018928: 10 80 00 03 b 2018934 <rtems_timer_server_fire_when+0x100>
201892c: 82 10 20 00 clr %g1 ! 0 <PROM_START>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
2018930: 82 10 20 04 mov 4, %g1
}
2018934: 81 c7 e0 08 ret
2018938: 91 e8 00 01 restore %g0, %g1, %o0
02003358 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
2003358: 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) {
200335c: 03 08 00 00 sethi %hi(0x20000000), %g1
2003360: 80 8e 00 01 btst %i0, %g1
2003364: 12 80 00 0e bne 200339c <rtems_verror+0x44>
2003368: ba 10 00 18 mov %i0, %i5
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
200336c: 03 00 80 73 sethi %hi(0x201cc00), %g1
2003370: c2 00 60 60 ld [ %g1 + 0x60 ], %g1 ! 201cc60 <_impure_ptr>
status = error_flag & ~RTEMS_ERROR_MASK;
2003374: 39 1c 00 00 sethi %hi(0x70000000), %i4
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
2003378: d0 00 60 08 ld [ %g1 + 8 ], %o0
200337c: 40 00 31 bf call 200fa78 <fflush>
2003380: b8 2f 40 1c andn %i5, %i4, %i4
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
2003384: 03 10 00 00 sethi %hi(0x40000000), %g1
2003388: 80 8f 40 01 btst %i5, %g1
200338c: 12 80 00 15 bne 20033e0 <rtems_verror+0x88>
2003390: ba 10 20 00 clr %i5
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
2003394: 10 80 00 17 b 20033f0 <rtems_verror+0x98>
2003398: 37 00 80 73 sethi %hi(0x201cc00), %i3
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
if (rtems_panic_in_progress++)
200339c: 05 00 80 75 sethi %hi(0x201d400), %g2
20033a0: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1 ! 201d440 <rtems_panic_in_progress>
20033a4: 86 00 60 01 add %g1, 1, %g3
20033a8: 80 a0 60 00 cmp %g1, 0
20033ac: 02 80 00 06 be 20033c4 <rtems_verror+0x6c> <== ALWAYS TAKEN
20033b0: c6 20 a0 40 st %g3, [ %g2 + 0x40 ]
*
* 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;
20033b4: 03 00 80 75 sethi %hi(0x201d400), %g1 <== NOT EXECUTED
20033b8: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 201d5d0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
++level;
20033bc: 84 00 a0 01 inc %g2 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
20033c0: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
20033c4: 03 00 80 75 sethi %hi(0x201d400), %g1
20033c8: c2 00 60 40 ld [ %g1 + 0x40 ], %g1 ! 201d440 <rtems_panic_in_progress>
20033cc: 80 a0 60 02 cmp %g1, 2
20033d0: 04 bf ff e7 ble 200336c <rtems_verror+0x14> <== ALWAYS TAKEN
20033d4: b0 10 20 00 clr %i0
20033d8: 81 c7 e0 08 ret <== NOT EXECUTED
20033dc: 81 e8 00 00 restore <== NOT EXECUTED
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
20033e0: 40 00 30 a3 call 200f66c <__errno>
20033e4: 01 00 00 00 nop
20033e8: fa 02 00 00 ld [ %o0 ], %i5
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
20033ec: 37 00 80 73 sethi %hi(0x201cc00), %i3
20033f0: c2 06 e0 60 ld [ %i3 + 0x60 ], %g1 ! 201cc60 <_impure_ptr>
20033f4: 92 10 00 19 mov %i1, %o1
20033f8: d0 00 60 0c ld [ %g1 + 0xc ], %o0
20033fc: 40 00 45 d3 call 2014b48 <vfprintf>
2003400: 94 10 00 1a mov %i2, %o2
if (status)
2003404: 80 a7 20 00 cmp %i4, 0
2003408: 02 80 00 0c be 2003438 <rtems_verror+0xe0>
200340c: b0 10 00 08 mov %o0, %i0
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
2003410: c2 06 e0 60 ld [ %i3 + 0x60 ], %g1
2003414: 90 10 00 1c mov %i4, %o0
2003418: 7f ff ff ca call 2003340 <rtems_status_text>
200341c: f6 00 60 0c ld [ %g1 + 0xc ], %i3
2003420: 13 00 80 6b sethi %hi(0x201ac00), %o1
2003424: 94 10 00 08 mov %o0, %o2
2003428: 92 12 62 20 or %o1, 0x220, %o1
200342c: 40 00 32 8f call 200fe68 <fprintf>
2003430: 90 10 00 1b mov %i3, %o0
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
2003434: b0 06 00 08 add %i0, %o0, %i0
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
2003438: 80 a7 60 00 cmp %i5, 0
200343c: 22 80 00 1c be,a 20034ac <rtems_verror+0x154>
2003440: 3b 00 80 73 sethi %hi(0x201cc00), %i5
if ((local_errno > 0) && *strerror(local_errno))
2003444: 80 a7 60 00 cmp %i5, 0
2003448: 04 80 00 11 ble 200348c <rtems_verror+0x134>
200344c: 03 00 80 73 sethi %hi(0x201cc00), %g1
2003450: 40 00 36 06 call 2010c68 <strerror>
2003454: 90 10 00 1d mov %i5, %o0
2003458: c2 4a 00 00 ldsb [ %o0 ], %g1
200345c: 80 a0 60 00 cmp %g1, 0
2003460: 02 80 00 0b be 200348c <rtems_verror+0x134> <== NEVER TAKEN
2003464: 03 00 80 73 sethi %hi(0x201cc00), %g1
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
2003468: c2 00 60 60 ld [ %g1 + 0x60 ], %g1 ! 201cc60 <_impure_ptr>
200346c: 90 10 00 1d mov %i5, %o0
2003470: 40 00 35 fe call 2010c68 <strerror>
2003474: f8 00 60 0c ld [ %g1 + 0xc ], %i4
2003478: 13 00 80 6b sethi %hi(0x201ac00), %o1
200347c: 94 10 00 08 mov %o0, %o2
2003480: 92 12 62 30 or %o1, 0x230, %o1
2003484: 10 80 00 07 b 20034a0 <rtems_verror+0x148>
2003488: 90 10 00 1c mov %i4, %o0
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
200348c: c2 00 60 60 ld [ %g1 + 0x60 ], %g1
2003490: 13 00 80 6b sethi %hi(0x201ac00), %o1
2003494: d0 00 60 0c ld [ %g1 + 0xc ], %o0
2003498: 92 12 62 40 or %o1, 0x240, %o1
200349c: 94 10 00 1d mov %i5, %o2
20034a0: 40 00 32 72 call 200fe68 <fprintf>
20034a4: 3b 00 80 73 sethi %hi(0x201cc00), %i5
20034a8: b0 06 00 08 add %i0, %o0, %i0
}
chars_written += fprintf(stderr, "\n");
20034ac: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
20034b0: 13 00 80 6b sethi %hi(0x201ac00), %o1
20034b4: d0 00 60 0c ld [ %g1 + 0xc ], %o0
20034b8: 40 00 32 6c call 200fe68 <fprintf>
20034bc: 92 12 60 78 or %o1, 0x78, %o1
(void) fflush(stderr);
20034c0: c2 07 60 60 ld [ %i5 + 0x60 ], %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");
20034c4: b0 06 00 08 add %i0, %o0, %i0
(void) fflush(stderr);
20034c8: 40 00 31 6c call 200fa78 <fflush>
20034cc: d0 00 60 0c ld [ %g1 + 0xc ], %o0
return chars_written;
}
20034d0: 81 c7 e0 08 ret
20034d4: 81 e8 00 00 restore
02023e88 <scanInt>:
/**
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
2023e88: 9d e3 bf a0 save %sp, -96, %sp
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
2023e8c: 37 1f ff ff sethi %hi(0x7ffffc00), %i3
int sign = 0;
2023e90: b8 10 20 00 clr %i4
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
2023e94: b6 16 e3 ff or %i3, 0x3ff, %i3
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
2023e98: ba 10 20 00 clr %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2023e9c: 21 00 81 79 sethi %hi(0x205e400), %l0
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
2023ea0: 23 00 81 79 sethi %hi(0x205e400), %l1
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2023ea4: c2 06 20 04 ld [ %i0 + 4 ], %g1
2023ea8: 82 00 7f ff add %g1, -1, %g1
2023eac: 80 a0 60 00 cmp %g1, 0
2023eb0: 16 80 00 07 bge 2023ecc <scanInt+0x44> <== ALWAYS TAKEN
2023eb4: c2 26 20 04 st %g1, [ %i0 + 4 ]
2023eb8: d0 04 23 58 ld [ %l0 + 0x358 ], %o0 <== NOT EXECUTED
2023ebc: 40 00 61 5c call 203c42c <__srget_r> <== NOT EXECUTED
2023ec0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (c == ':')
2023ec4: 10 80 00 07 b 2023ee0 <scanInt+0x58> <== NOT EXECUTED
2023ec8: 80 a2 20 3a cmp %o0, 0x3a <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2023ecc: c4 06 00 00 ld [ %i0 ], %g2
2023ed0: d0 08 80 00 ldub [ %g2 ], %o0
2023ed4: 84 00 a0 01 inc %g2
2023ed8: c4 26 00 00 st %g2, [ %i0 ]
if (c == ':')
2023edc: 80 a2 20 3a cmp %o0, 0x3a
2023ee0: 02 80 00 21 be 2023f64 <scanInt+0xdc>
2023ee4: 80 a7 20 00 cmp %i4, 0
break;
if (sign == 0) {
2023ee8: 12 80 00 08 bne 2023f08 <scanInt+0x80>
2023eec: c4 04 63 48 ld [ %l1 + 0x348 ], %g2
if (c == '-') {
2023ef0: 80 a2 20 2d cmp %o0, 0x2d
2023ef4: 12 80 00 05 bne 2023f08 <scanInt+0x80>
2023ef8: b8 10 20 01 mov 1, %i4
sign = -1;
limit++;
2023efc: b6 06 e0 01 inc %i3
continue;
2023f00: 10 bf ff e9 b 2023ea4 <scanInt+0x1c>
2023f04: b8 10 3f ff mov -1, %i4
}
sign = 1;
}
if (!isdigit(c))
2023f08: 84 00 80 08 add %g2, %o0, %g2
2023f0c: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
2023f10: 80 88 a0 04 btst 4, %g2
2023f14: 02 80 00 1d be 2023f88 <scanInt+0x100>
2023f18: b4 02 3f d0 add %o0, -48, %i2
return 0;
d = c - '0';
if ((i > (limit / 10))
2023f1c: 92 10 20 0a mov 0xa, %o1
2023f20: 40 00 af de call 204fe98 <.udiv>
2023f24: 90 10 00 1b mov %i3, %o0
2023f28: 80 a7 40 08 cmp %i5, %o0
2023f2c: 38 80 00 15 bgu,a 2023f80 <scanInt+0xf8>
2023f30: b0 10 20 00 clr %i0
|| ((i == (limit / 10)) && (d > (limit % 10))))
2023f34: 12 80 00 08 bne 2023f54 <scanInt+0xcc>
2023f38: 83 2f 60 01 sll %i5, 1, %g1
2023f3c: 90 10 00 1b mov %i3, %o0
2023f40: 40 00 b0 82 call 2050148 <.urem>
2023f44: 92 10 20 0a mov 0xa, %o1
2023f48: 80 a6 80 08 cmp %i2, %o0
2023f4c: 18 80 00 0f bgu 2023f88 <scanInt+0x100> <== ALWAYS TAKEN
2023f50: 83 2f 60 01 sll %i5, 1, %g1
return 0;
i = i * 10 + d;
2023f54: bb 2f 60 03 sll %i5, 3, %i5
2023f58: ba 00 40 1d add %g1, %i5, %i5
2023f5c: 10 bf ff d2 b 2023ea4 <scanInt+0x1c>
2023f60: ba 06 80 1d add %i2, %i5, %i5
}
if (sign == 0)
2023f64: 02 80 00 07 be 2023f80 <scanInt+0xf8> <== NEVER TAKEN
2023f68: b0 10 20 00 clr %i0
return 0;
*val = i * sign;
2023f6c: 90 10 00 1c mov %i4, %o0
2023f70: 92 10 00 1d mov %i5, %o1
2023f74: 40 00 af 8f call 204fdb0 <.umul>
2023f78: b0 10 20 01 mov 1, %i0
2023f7c: d0 26 40 00 st %o0, [ %i1 ]
return 1;
2023f80: 81 c7 e0 08 ret
2023f84: 81 e8 00 00 restore
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
2023f88: b0 10 20 00 clr %i0
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
2023f8c: 81 c7 e0 08 ret
2023f90: 81 e8 00 00 restore
02024084 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
2024084: 9d e3 bf 98 save %sp, -104, %sp
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2024088: 98 10 20 00 clr %o4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
202408c: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2024090: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2024094: 90 10 00 18 mov %i0, %o0
2024098: 92 10 00 19 mov %i1, %o1
202409c: 94 07 a0 4c add %fp, 0x4c, %o2
20240a0: 7f ff ff bd call 2023f94 <scanString>
20240a4: 96 07 a0 50 add %fp, 0x50, %o3
20240a8: 80 a2 20 00 cmp %o0, 0
20240ac: 12 80 00 04 bne 20240bc <scangr+0x38>
20240b0: 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;
20240b4: 81 c7 e0 08 ret
20240b8: 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)
20240bc: 92 06 60 04 add %i1, 4, %o1
20240c0: 94 07 a0 4c add %fp, 0x4c, %o2
20240c4: 96 07 a0 50 add %fp, 0x50, %o3
20240c8: 7f ff ff b3 call 2023f94 <scanString>
20240cc: 98 10 20 00 clr %o4
20240d0: 80 a2 20 00 cmp %o0, 0
20240d4: 02 bf ff f8 be 20240b4 <scangr+0x30> <== NEVER TAKEN
20240d8: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &grgid)
20240dc: 7f ff ff 6b call 2023e88 <scanInt>
20240e0: 92 07 bf f8 add %fp, -8, %o1
20240e4: 80 a2 20 00 cmp %o0, 0
20240e8: 02 bf ff f3 be 20240b4 <scangr+0x30> <== NEVER TAKEN
20240ec: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
20240f0: 92 07 bf fc add %fp, -4, %o1
20240f4: 94 07 a0 4c add %fp, 0x4c, %o2
20240f8: 96 07 a0 50 add %fp, 0x50, %o3
20240fc: 7f ff ff a6 call 2023f94 <scanString>
2024100: 98 10 20 01 mov 1, %o4
2024104: 80 a2 20 00 cmp %o0, 0
2024108: 02 bf ff eb be 20240b4 <scangr+0x30> <== NEVER TAKEN
202410c: c2 07 bf f8 ld [ %fp + -8 ], %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2024110: c6 07 bf fc ld [ %fp + -4 ], %g3
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
grp->gr_gid = grgid;
2024114: c2 36 60 08 sth %g1, [ %i1 + 8 ]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2024118: 84 10 00 03 mov %g3, %g2
202411c: 10 80 00 05 b 2024130 <scangr+0xac>
2024120: 82 10 20 01 mov 1, %g1
2024124: 84 00 a0 01 inc %g2
if(*cp == ',')
memcount++;
2024128: 80 a0 00 04 cmp %g0, %g4
202412c: 82 60 7f ff subx %g1, -1, %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2024130: c8 48 80 00 ldsb [ %g2 ], %g4
2024134: 80 a1 20 00 cmp %g4, 0
2024138: 32 bf ff fb bne,a 2024124 <scangr+0xa0>
202413c: 88 19 20 2c xor %g4, 0x2c, %g4
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
2024140: c4 07 a0 50 ld [ %fp + 0x50 ], %g2
2024144: 83 28 60 02 sll %g1, 2, %g1
2024148: 82 00 60 13 add %g1, 0x13, %g1
202414c: 80 a0 80 01 cmp %g2, %g1
2024150: 0a bf ff d9 bcs 20240b4 <scangr+0x30> <== NEVER TAKEN
2024154: c2 07 a0 4c ld [ %fp + 0x4c ], %g1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2024158: 84 10 20 01 mov 1, %g2
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
202415c: 82 00 60 0f add %g1, 0xf, %g1
2024160: 82 08 7f f0 and %g1, -16, %g1
2024164: c2 26 60 0c st %g1, [ %i1 + 0xc ]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
2024168: c6 20 40 00 st %g3, [ %g1 ]
}
/**
* Extract a single group record from the database
*/
static int scangr(
202416c: c2 07 bf fc ld [ %fp + -4 ], %g1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2024170: 10 80 00 0a b 2024198 <scangr+0x114>
2024174: 82 00 60 01 inc %g1
if(*cp == ',') {
2024178: 32 80 00 08 bne,a 2024198 <scangr+0x114>
202417c: 82 00 60 01 inc %g1
*cp = '\0';
2024180: c0 28 7f ff clrb [ %g1 + -1 ]
grp->gr_mem[memcount++] = cp + 1;
2024184: c8 06 60 0c ld [ %i1 + 0xc ], %g4
2024188: 87 28 a0 02 sll %g2, 2, %g3
202418c: 84 00 a0 01 inc %g2
2024190: c2 21 00 03 st %g1, [ %g4 + %g3 ]
2024194: 82 00 60 01 inc %g1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2024198: c6 48 7f ff ldsb [ %g1 + -1 ], %g3
202419c: 80 a0 e0 00 cmp %g3, 0
20241a0: 32 bf ff f6 bne,a 2024178 <scangr+0xf4>
20241a4: 80 a0 e0 2c cmp %g3, 0x2c
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
20241a8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
20241ac: 85 28 a0 02 sll %g2, 2, %g2
20241b0: c0 20 40 02 clr [ %g1 + %g2 ]
return 1;
}
20241b4: 81 c7 e0 08 ret
20241b8: 91 e8 20 01 restore %g0, 1, %o0
020241bc <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
20241bc: 9d e3 bf 98 save %sp, -104, %sp
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
20241c0: 98 10 20 00 clr %o4
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
20241c4: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
20241c8: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
20241cc: 90 10 00 18 mov %i0, %o0
20241d0: 92 10 00 19 mov %i1, %o1
20241d4: 94 07 a0 4c add %fp, 0x4c, %o2
20241d8: 7f ff ff 6f call 2023f94 <scanString>
20241dc: 96 07 a0 50 add %fp, 0x50, %o3
20241e0: 80 a2 20 00 cmp %o0, 0
20241e4: 12 80 00 04 bne 20241f4 <scanpw+0x38>
20241e8: 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;
20241ec: 81 c7 e0 08 ret
20241f0: 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)
20241f4: 92 06 60 04 add %i1, 4, %o1
20241f8: 94 07 a0 4c add %fp, 0x4c, %o2
20241fc: 96 07 a0 50 add %fp, 0x50, %o3
2024200: 7f ff ff 65 call 2023f94 <scanString>
2024204: 98 10 20 00 clr %o4
2024208: 80 a2 20 00 cmp %o0, 0
202420c: 02 bf ff f8 be 20241ec <scanpw+0x30> <== NEVER TAKEN
2024210: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwuid)
2024214: 7f ff ff 1d call 2023e88 <scanInt>
2024218: 92 07 bf f8 add %fp, -8, %o1
202421c: 80 a2 20 00 cmp %o0, 0
2024220: 02 bf ff f3 be 20241ec <scanpw+0x30>
2024224: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwgid)
2024228: 7f ff ff 18 call 2023e88 <scanInt>
202422c: 92 07 bf fc add %fp, -4, %o1
2024230: 80 a2 20 00 cmp %o0, 0
2024234: 02 bf ff ee be 20241ec <scanpw+0x30>
2024238: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
202423c: 92 06 60 0c add %i1, 0xc, %o1
2024240: 94 07 a0 4c add %fp, 0x4c, %o2
2024244: 96 07 a0 50 add %fp, 0x50, %o3
2024248: 7f ff ff 53 call 2023f94 <scanString>
202424c: 98 10 20 00 clr %o4
2024250: 80 a2 20 00 cmp %o0, 0
2024254: 02 bf ff e6 be 20241ec <scanpw+0x30> <== NEVER TAKEN
2024258: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
202425c: 92 06 60 10 add %i1, 0x10, %o1
2024260: 94 07 a0 4c add %fp, 0x4c, %o2
2024264: 96 07 a0 50 add %fp, 0x50, %o3
2024268: 7f ff ff 4b call 2023f94 <scanString>
202426c: 98 10 20 00 clr %o4
2024270: 80 a2 20 00 cmp %o0, 0
2024274: 02 bf ff de be 20241ec <scanpw+0x30> <== NEVER TAKEN
2024278: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
202427c: 92 06 60 14 add %i1, 0x14, %o1
2024280: 94 07 a0 4c add %fp, 0x4c, %o2
2024284: 96 07 a0 50 add %fp, 0x50, %o3
2024288: 7f ff ff 43 call 2023f94 <scanString>
202428c: 98 10 20 00 clr %o4
2024290: 80 a2 20 00 cmp %o0, 0
2024294: 02 bf ff d6 be 20241ec <scanpw+0x30> <== NEVER TAKEN
2024298: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
202429c: 92 06 60 18 add %i1, 0x18, %o1
20242a0: 94 07 a0 4c add %fp, 0x4c, %o2
20242a4: 96 07 a0 50 add %fp, 0x50, %o3
20242a8: 7f ff ff 3b call 2023f94 <scanString>
20242ac: 98 10 20 01 mov 1, %o4
20242b0: 80 a2 20 00 cmp %o0, 0
20242b4: 02 bf ff ce be 20241ec <scanpw+0x30>
20242b8: c2 07 bf f8 ld [ %fp + -8 ], %g1
return 0;
pwd->pw_uid = pwuid;
20242bc: c2 36 60 08 sth %g1, [ %i1 + 8 ]
pwd->pw_gid = pwgid;
20242c0: c2 07 bf fc ld [ %fp + -4 ], %g1
20242c4: c2 36 60 0a sth %g1, [ %i1 + 0xa ]
return 1;
}
20242c8: 81 c7 e0 08 ret
20242cc: 91 e8 20 01 restore %g0, 1, %o0
02007d24 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
2007d24: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
2007d28: 80 a6 20 04 cmp %i0, 4
2007d2c: 18 80 00 06 bgu 2007d44 <sched_get_priority_max+0x20>
2007d30: 82 10 20 01 mov 1, %g1
2007d34: b1 28 40 18 sll %g1, %i0, %i0
2007d38: 80 8e 20 17 btst 0x17, %i0
2007d3c: 12 80 00 08 bne 2007d5c <sched_get_priority_max+0x38> <== ALWAYS TAKEN
2007d40: 03 00 80 85 sethi %hi(0x2021400), %g1
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2007d44: 40 00 21 79 call 2010328 <__errno>
2007d48: b0 10 3f ff mov -1, %i0
2007d4c: 82 10 20 16 mov 0x16, %g1
2007d50: c2 22 00 00 st %g1, [ %o0 ]
2007d54: 81 c7 e0 08 ret
2007d58: 81 e8 00 00 restore
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
2007d5c: f0 08 63 6c ldub [ %g1 + 0x36c ], %i0
}
2007d60: 81 c7 e0 08 ret
2007d64: 91 ee 3f ff restore %i0, -1, %o0
02007d68 <sched_get_priority_min>:
* 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258
*/
int sched_get_priority_min(
int policy
)
{
2007d68: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
2007d6c: 80 a6 20 04 cmp %i0, 4
2007d70: 18 80 00 06 bgu 2007d88 <sched_get_priority_min+0x20>
2007d74: 82 10 20 01 mov 1, %g1
2007d78: 83 28 40 18 sll %g1, %i0, %g1
2007d7c: 80 88 60 17 btst 0x17, %g1
2007d80: 12 80 00 06 bne 2007d98 <sched_get_priority_min+0x30> <== ALWAYS TAKEN
2007d84: b0 10 20 01 mov 1, %i0
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2007d88: 40 00 21 68 call 2010328 <__errno>
2007d8c: b0 10 3f ff mov -1, %i0
2007d90: 82 10 20 16 mov 0x16, %g1
2007d94: c2 22 00 00 st %g1, [ %o0 ]
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
2007d98: 81 c7 e0 08 ret
2007d9c: 81 e8 00 00 restore
02007da0 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
2007da0: 9d e3 bf a0 save %sp, -96, %sp
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
2007da4: 80 a6 20 00 cmp %i0, 0
2007da8: 02 80 00 0b be 2007dd4 <sched_rr_get_interval+0x34> <== NEVER TAKEN
2007dac: 80 a6 60 00 cmp %i1, 0
2007db0: 7f ff ef 87 call 2003bcc <getpid>
2007db4: 01 00 00 00 nop
2007db8: 80 a6 00 08 cmp %i0, %o0
2007dbc: 02 80 00 06 be 2007dd4 <sched_rr_get_interval+0x34>
2007dc0: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
2007dc4: 40 00 21 59 call 2010328 <__errno>
2007dc8: 01 00 00 00 nop
2007dcc: 10 80 00 07 b 2007de8 <sched_rr_get_interval+0x48>
2007dd0: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3>
if ( !interval )
2007dd4: 12 80 00 08 bne 2007df4 <sched_rr_get_interval+0x54>
2007dd8: 03 00 80 88 sethi %hi(0x2022000), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
2007ddc: 40 00 21 53 call 2010328 <__errno>
2007de0: 01 00 00 00 nop
2007de4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007de8: c2 22 00 00 st %g1, [ %o0 ]
2007dec: 81 c7 e0 08 ret
2007df0: 91 e8 3f ff restore %g0, -1, %o0
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
2007df4: d0 00 63 60 ld [ %g1 + 0x360 ], %o0
2007df8: 92 10 00 19 mov %i1, %o1
2007dfc: 40 00 0e c2 call 200b904 <_Timespec_From_ticks>
2007e00: b0 10 20 00 clr %i0
return 0;
}
2007e04: 81 c7 e0 08 ret
2007e08: 81 e8 00 00 restore
020084bc <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
20084bc: 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;
20084c0: 03 00 80 88 sethi %hi(0x2022000), %g1
20084c4: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2022090 <_Thread_Dispatch_disable_level>
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
20084c8: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
++level;
20084cc: 84 00 a0 01 inc %g2
20084d0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
20084d4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
20084d8: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
_Thread_Dispatch_disable_level = level;
20084dc: c4 20 60 90 st %g2, [ %g1 + 0x90 ]
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
20084e0: b4 8e 62 00 andcc %i1, 0x200, %i2
20084e4: 02 80 00 05 be 20084f8 <sem_open+0x3c>
20084e8: b8 10 20 00 clr %i4
va_start(arg, oflag);
mode = va_arg( arg, mode_t );
value = va_arg( arg, unsigned int );
20084ec: f8 07 a0 50 ld [ %fp + 0x50 ], %i4
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
20084f0: 82 07 a0 4c add %fp, 0x4c, %g1
20084f4: c2 27 bf ec st %g1, [ %fp + -20 ]
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len );
20084f8: 37 00 80 88 sethi %hi(0x2022000), %i3
20084fc: 92 10 00 18 mov %i0, %o1
2008500: 90 16 e3 64 or %i3, 0x364, %o0
2008504: 94 07 bf f0 add %fp, -16, %o2
2008508: 7f ff fe 7e call 2007f00 <_POSIX_Name_to_id>
200850c: 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 ) {
2008510: ba 92 20 00 orcc %o0, 0, %i5
2008514: 22 80 00 0e be,a 200854c <sem_open+0x90>
2008518: 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) ) ) {
200851c: 80 a7 60 02 cmp %i5, 2
2008520: 12 80 00 04 bne 2008530 <sem_open+0x74>
2008524: 80 a6 a0 00 cmp %i2, 0
2008528: 12 80 00 20 bne 20085a8 <sem_open+0xec>
200852c: d2 07 bf fc ld [ %fp + -4 ], %o1
_Thread_Enable_dispatch();
2008530: 40 00 0d ee call 200bce8 <_Thread_Enable_dispatch>
2008534: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
2008538: 40 00 24 16 call 2011590 <__errno>
200853c: 01 00 00 00 nop
2008540: fa 22 00 00 st %i5, [ %o0 ]
2008544: 81 c7 e0 08 ret
2008548: 81 e8 00 00 restore
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
200854c: 80 a6 6a 00 cmp %i1, 0xa00
2008550: 12 80 00 0a bne 2008578 <sem_open+0xbc>
2008554: d2 07 bf f0 ld [ %fp + -16 ], %o1
_Thread_Enable_dispatch();
2008558: 40 00 0d e4 call 200bce8 <_Thread_Enable_dispatch>
200855c: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
2008560: 40 00 24 0c call 2011590 <__errno>
2008564: 01 00 00 00 nop
2008568: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
200856c: c2 22 00 00 st %g1, [ %o0 ]
2008570: 81 c7 e0 08 ret
2008574: 81 e8 00 00 restore
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
2008578: 94 07 bf f8 add %fp, -8, %o2
200857c: 40 00 09 ea call 200ad24 <_Objects_Get>
2008580: 90 16 e3 64 or %i3, 0x364, %o0
}
the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
the_semaphore->open_count += 1;
2008584: 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 );
2008588: d0 27 bf f4 st %o0, [ %fp + -12 ]
the_semaphore->open_count += 1;
200858c: 82 00 60 01 inc %g1
_Thread_Enable_dispatch();
2008590: 40 00 0d d6 call 200bce8 <_Thread_Enable_dispatch>
2008594: c2 22 20 18 st %g1, [ %o0 + 0x18 ]
_Thread_Enable_dispatch();
2008598: 40 00 0d d4 call 200bce8 <_Thread_Enable_dispatch>
200859c: 01 00 00 00 nop
goto return_id;
20085a0: 10 80 00 0d b 20085d4 <sem_open+0x118>
20085a4: f0 07 bf f4 ld [ %fp + -12 ], %i0
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
20085a8: 94 10 20 00 clr %o2
20085ac: 96 10 00 1c mov %i4, %o3
20085b0: 98 07 bf f4 add %fp, -12, %o4
20085b4: 40 00 19 b1 call 200ec78 <_POSIX_Semaphore_Create_support>
20085b8: 90 10 00 18 mov %i0, %o0
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
20085bc: 40 00 0d cb call 200bce8 <_Thread_Enable_dispatch>
20085c0: ba 10 00 08 mov %o0, %i5
if ( status == -1 )
20085c4: 80 a7 7f ff cmp %i5, -1
20085c8: 22 80 00 04 be,a 20085d8 <sem_open+0x11c> <== NEVER TAKEN
20085cc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
return &the_semaphore->Semaphore_id;
#else
return (sem_t *)&the_semaphore->Object.id;
20085d0: f0 07 bf f4 ld [ %fp + -12 ], %i0
20085d4: b0 06 20 08 add %i0, 8, %i0
#endif
}
20085d8: 81 c7 e0 08 ret
20085dc: 81 e8 00 00 restore
02007d1c <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
2007d1c: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
if ( oact )
2007d20: 80 a6 a0 00 cmp %i2, 0
2007d24: 02 80 00 0a be 2007d4c <sigaction+0x30>
2007d28: 83 2e 20 02 sll %i0, 2, %g1
*oact = _POSIX_signals_Vectors[ sig ];
2007d2c: 85 2e 20 04 sll %i0, 4, %g2
2007d30: 82 20 80 01 sub %g2, %g1, %g1
2007d34: 13 00 80 84 sethi %hi(0x2021000), %o1
2007d38: 90 10 00 1a mov %i2, %o0
2007d3c: 92 12 60 c0 or %o1, 0xc0, %o1
2007d40: 94 10 20 0c mov 0xc, %o2
2007d44: 40 00 24 db call 20110b0 <memcpy>
2007d48: 92 02 40 01 add %o1, %g1, %o1
if ( !sig )
2007d4c: 80 a6 20 00 cmp %i0, 0
2007d50: 32 80 00 03 bne,a 2007d5c <sigaction+0x40>
2007d54: 82 06 3f ff add %i0, -1, %g1
2007d58: 30 80 00 06 b,a 2007d70 <sigaction+0x54>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
2007d5c: 80 a0 60 1f cmp %g1, 0x1f
2007d60: 18 80 00 04 bgu 2007d70 <sigaction+0x54>
2007d64: 80 a6 20 09 cmp %i0, 9
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
2007d68: 12 80 00 08 bne 2007d88 <sigaction+0x6c>
2007d6c: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
2007d70: 40 00 22 7b call 201075c <__errno>
2007d74: 01 00 00 00 nop
2007d78: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007d7c: c2 22 00 00 st %g1, [ %o0 ]
2007d80: 10 80 00 20 b 2007e00 <sigaction+0xe4>
2007d84: 82 10 3f ff mov -1, %g1
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
2007d88: 02 80 00 1e be 2007e00 <sigaction+0xe4> <== NEVER TAKEN
2007d8c: 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 );
2007d90: 7f ff ea f1 call 2002954 <sparc_disable_interrupts>
2007d94: 01 00 00 00 nop
2007d98: b8 10 00 08 mov %o0, %i4
if ( act->sa_handler == SIG_DFL ) {
2007d9c: c2 06 60 08 ld [ %i1 + 8 ], %g1
2007da0: 3b 00 80 84 sethi %hi(0x2021000), %i5
2007da4: 80 a0 60 00 cmp %g1, 0
2007da8: 12 80 00 0a bne 2007dd0 <sigaction+0xb4>
2007dac: ba 17 60 c0 or %i5, 0xc0, %i5
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
2007db0: 83 2e 20 02 sll %i0, 2, %g1
2007db4: 13 00 80 7b sethi %hi(0x201ec00), %o1
2007db8: b1 2e 20 04 sll %i0, 4, %i0
2007dbc: 92 12 60 4c or %o1, 0x4c, %o1
2007dc0: b0 26 00 01 sub %i0, %g1, %i0
2007dc4: 90 07 40 18 add %i5, %i0, %o0
2007dc8: 10 80 00 09 b 2007dec <sigaction+0xd0>
2007dcc: 92 02 40 18 add %o1, %i0, %o1
} else {
_POSIX_signals_Clear_process_signals( sig );
2007dd0: 40 00 17 07 call 200d9ec <_POSIX_signals_Clear_process_signals>
2007dd4: 90 10 00 18 mov %i0, %o0
_POSIX_signals_Vectors[ sig ] = *act;
2007dd8: 83 2e 20 02 sll %i0, 2, %g1
2007ddc: 92 10 00 19 mov %i1, %o1
2007de0: b1 2e 20 04 sll %i0, 4, %i0
2007de4: 90 26 00 01 sub %i0, %g1, %o0
2007de8: 90 07 40 08 add %i5, %o0, %o0
2007dec: 40 00 24 b1 call 20110b0 <memcpy>
2007df0: 94 10 20 0c mov 0xc, %o2
}
_ISR_Enable( level );
2007df4: 7f ff ea dc call 2002964 <sparc_enable_interrupts>
2007df8: 90 10 00 1c mov %i4, %o0
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
2007dfc: 82 10 20 00 clr %g1
}
2007e00: 81 c7 e0 08 ret
2007e04: 91 e8 00 01 restore %g0, %g1, %o0
02008260 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
2008260: 9d e3 bf 90 save %sp, -112, %sp
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
2008264: 80 a6 20 00 cmp %i0, 0
2008268: 02 80 00 0e be 20082a0 <sigtimedwait+0x40>
200826c: 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 ) {
2008270: 02 80 00 10 be 20082b0 <sigtimedwait+0x50>
2008274: b6 10 20 00 clr %i3
if ( !_Timespec_Is_valid( timeout ) )
2008278: 40 00 0f 0b call 200bea4 <_Timespec_Is_valid>
200827c: 90 10 00 1a mov %i2, %o0
2008280: 80 8a 20 ff btst 0xff, %o0
2008284: 02 80 00 07 be 20082a0 <sigtimedwait+0x40>
2008288: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
200828c: 40 00 0f 18 call 200beec <_Timespec_To_ticks>
2008290: 90 10 00 1a mov %i2, %o0
if ( !interval )
2008294: b6 92 20 00 orcc %o0, 0, %i3
2008298: 12 80 00 07 bne 20082b4 <sigtimedwait+0x54> <== ALWAYS TAKEN
200829c: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
20082a0: 40 00 22 fb call 2010e8c <__errno>
20082a4: 01 00 00 00 nop
20082a8: 10 80 00 63 b 2008434 <sigtimedwait+0x1d4>
20082ac: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
20082b0: 80 a6 60 00 cmp %i1, 0
20082b4: 22 80 00 02 be,a 20082bc <sigtimedwait+0x5c>
20082b8: b2 07 bf f4 add %fp, -12, %i1
the_thread = _Thread_Executing;
20082bc: 21 00 80 85 sethi %hi(0x2021400), %l0
20082c0: a0 14 21 40 or %l0, 0x140, %l0 ! 2021540 <_Per_CPU_Information>
20082c4: fa 04 20 10 ld [ %l0 + 0x10 ], %i5
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
20082c8: 7f ff ea 80 call 2002cc8 <sparc_disable_interrupts>
20082cc: f8 07 61 5c ld [ %i5 + 0x15c ], %i4
20082d0: b4 10 00 08 mov %o0, %i2
if ( *set & api->signals_pending ) {
20082d4: c4 06 00 00 ld [ %i0 ], %g2
20082d8: c2 07 20 d4 ld [ %i4 + 0xd4 ], %g1
20082dc: 80 88 80 01 btst %g2, %g1
20082e0: 22 80 00 12 be,a 2008328 <sigtimedwait+0xc8>
20082e4: 03 00 80 85 sethi %hi(0x2021400), %g1
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
20082e8: 7f ff ff c6 call 2008200 <_POSIX_signals_Get_lowest>
20082ec: 90 10 00 01 mov %g1, %o0
_POSIX_signals_Clear_signals(
20082f0: 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 );
20082f4: 92 10 00 08 mov %o0, %o1
20082f8: d0 26 40 00 st %o0, [ %i1 ]
_POSIX_signals_Clear_signals(
20082fc: 96 10 20 00 clr %o3
2008300: 90 10 00 1c mov %i4, %o0
2008304: 40 00 17 d5 call 200e258 <_POSIX_signals_Clear_signals>
2008308: 98 10 20 00 clr %o4
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
200830c: 7f ff ea 73 call 2002cd8 <sparc_enable_interrupts>
2008310: 90 10 00 1a mov %i2, %o0
the_info->si_code = SI_USER;
2008314: 82 10 20 01 mov 1, %g1
the_info->si_value.sival_int = 0;
2008318: c0 26 60 08 clr [ %i1 + 8 ]
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
200831c: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
return the_info->si_signo;
2008320: 10 80 00 47 b 200843c <sigtimedwait+0x1dc>
2008324: fa 06 40 00 ld [ %i1 ], %i5
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
2008328: c2 00 63 94 ld [ %g1 + 0x394 ], %g1
200832c: 80 88 80 01 btst %g2, %g1
2008330: 22 80 00 12 be,a 2008378 <sigtimedwait+0x118>
2008334: 82 10 3f ff mov -1, %g1
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
2008338: 7f ff ff b2 call 2008200 <_POSIX_signals_Get_lowest>
200833c: 90 10 00 01 mov %g1, %o0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
2008340: 94 10 00 19 mov %i1, %o2
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
2008344: ba 10 00 08 mov %o0, %i5
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
2008348: 96 10 20 01 mov 1, %o3
200834c: 90 10 00 1c mov %i4, %o0
2008350: 92 10 00 1d mov %i5, %o1
2008354: 40 00 17 c1 call 200e258 <_POSIX_signals_Clear_signals>
2008358: 98 10 20 00 clr %o4
_ISR_Enable( level );
200835c: 7f ff ea 5f call 2002cd8 <sparc_enable_interrupts>
2008360: 90 10 00 1a mov %i2, %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
2008364: 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;
2008368: fa 26 40 00 st %i5, [ %i1 ]
the_info->si_code = SI_USER;
200836c: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
2008370: 10 80 00 33 b 200843c <sigtimedwait+0x1dc>
2008374: c0 26 60 08 clr [ %i1 + 8 ]
return signo;
}
the_info->si_signo = -1;
2008378: c2 26 40 00 st %g1, [ %i1 ]
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
200837c: 03 00 80 84 sethi %hi(0x2021000), %g1
2008380: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 ! 2021020 <_Thread_Dispatch_disable_level>
++level;
2008384: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
2008388: c4 20 60 20 st %g2, [ %g1 + 0x20 ]
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
200838c: 82 10 20 04 mov 4, %g1
2008390: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
the_thread->Wait.option = *set;
2008394: c2 06 00 00 ld [ %i0 ], %g1
the_thread->Wait.return_argument = the_info;
2008398: f2 27 60 28 st %i1, [ %i5 + 0x28 ]
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
200839c: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
20083a0: a2 10 20 01 mov 1, %l1
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
20083a4: 35 00 80 85 sethi %hi(0x2021400), %i2
20083a8: b4 16 a3 2c or %i2, 0x32c, %i2 ! 202172c <_POSIX_signals_Wait_queue>
20083ac: f4 27 60 44 st %i2, [ %i5 + 0x44 ]
20083b0: e2 26 a0 30 st %l1, [ %i2 + 0x30 ]
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
the_thread->Wait.return_argument = the_info;
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
20083b4: 7f ff ea 49 call 2002cd8 <sparc_enable_interrupts>
20083b8: 01 00 00 00 nop
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
20083bc: 90 10 00 1a mov %i2, %o0
20083c0: 92 10 00 1b mov %i3, %o1
20083c4: 15 00 80 2f sethi %hi(0x200bc00), %o2
20083c8: 40 00 0d 60 call 200b948 <_Thread_queue_Enqueue_with_handler>
20083cc: 94 12 a0 b4 or %o2, 0xb4, %o2 ! 200bcb4 <_Thread_queue_Timeout>
_Thread_Enable_dispatch();
20083d0: 40 00 0c 19 call 200b434 <_Thread_Enable_dispatch>
20083d4: 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 );
20083d8: d2 06 40 00 ld [ %i1 ], %o1
20083dc: 90 10 00 1c mov %i4, %o0
20083e0: 94 10 00 19 mov %i1, %o2
20083e4: 96 10 20 00 clr %o3
20083e8: 40 00 17 9c call 200e258 <_POSIX_signals_Clear_signals>
20083ec: 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)
20083f0: c2 04 20 10 ld [ %l0 + 0x10 ], %g1
20083f4: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
20083f8: 80 a0 60 04 cmp %g1, 4
20083fc: 12 80 00 09 bne 2008420 <sigtimedwait+0x1c0>
2008400: 01 00 00 00 nop
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
2008404: fa 06 40 00 ld [ %i1 ], %i5
2008408: 82 07 7f ff add %i5, -1, %g1
200840c: a3 2c 40 01 sll %l1, %g1, %l1
2008410: c2 06 00 00 ld [ %i0 ], %g1
2008414: 80 8c 40 01 btst %l1, %g1
2008418: 12 80 00 09 bne 200843c <sigtimedwait+0x1dc>
200841c: 01 00 00 00 nop
errno = _Thread_Executing->Wait.return_code;
2008420: 40 00 22 9b call 2010e8c <__errno>
2008424: 01 00 00 00 nop
2008428: 03 00 80 85 sethi %hi(0x2021400), %g1
200842c: c2 00 61 50 ld [ %g1 + 0x150 ], %g1 ! 2021550 <_Per_CPU_Information+0x10>
2008430: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
2008434: c2 22 00 00 st %g1, [ %o0 ]
return -1;
2008438: ba 10 3f ff mov -1, %i5
}
return the_info->si_signo;
}
200843c: 81 c7 e0 08 ret
2008440: 91 e8 00 1d restore %g0, %i5, %o0
0200a178 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
200a178: 9d e3 bf a0 save %sp, -96, %sp
int status;
status = sigtimedwait( set, NULL, NULL );
200a17c: 92 10 20 00 clr %o1
200a180: 90 10 00 18 mov %i0, %o0
200a184: 7f ff ff 80 call 2009f84 <sigtimedwait>
200a188: 94 10 20 00 clr %o2
if ( status != -1 ) {
200a18c: 80 a2 3f ff cmp %o0, -1
200a190: 02 80 00 06 be 200a1a8 <sigwait+0x30>
200a194: 80 a6 60 00 cmp %i1, 0
if ( sig )
200a198: 32 80 00 09 bne,a 200a1bc <sigwait+0x44> <== ALWAYS TAKEN
200a19c: d0 26 40 00 st %o0, [ %i1 ]
*sig = status;
return 0;
200a1a0: 81 c7 e0 08 ret <== NOT EXECUTED
200a1a4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
return errno;
200a1a8: 40 00 21 cb call 20128d4 <__errno>
200a1ac: 01 00 00 00 nop
200a1b0: f0 02 00 00 ld [ %o0 ], %i0
200a1b4: 81 c7 e0 08 ret
200a1b8: 81 e8 00 00 restore
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
200a1bc: b0 10 20 00 clr %i0
}
return errno;
}
200a1c0: 81 c7 e0 08 ret
200a1c4: 81 e8 00 00 restore
0200637c <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
200637c: 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)) {
2006380: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
2006384: 80 88 6e 78 btst 0xe78, %g1
2006388: 02 80 00 0d be 20063bc <siproc+0x40> <== NEVER TAKEN
200638c: 94 10 20 00 clr %o2
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2006390: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
2006394: 40 00 04 cc call 20076c4 <rtems_semaphore_obtain>
2006398: 92 10 20 00 clr %o1
i = iproc (c, tty);
200639c: 90 10 00 18 mov %i0, %o0
20063a0: 7f ff ff 6b call 200614c <iproc>
20063a4: 92 10 00 19 mov %i1, %o1
20063a8: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
20063ac: 40 00 05 0f call 20077e8 <rtems_semaphore_release>
20063b0: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
20063b4: 81 c7 e0 08 ret
20063b8: 81 e8 00 00 restore
}
else {
i = iproc (c, tty);
20063bc: 7f ff ff 64 call 200614c <iproc> <== NOT EXECUTED
20063c0: 81 e8 00 00 restore <== NOT EXECUTED
0200ebc0 <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 )
{
200ebc0: 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 ) {
200ebc4: 03 30 06 10 sethi %hi(0xc0184000), %g1
200ebc8: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
200ebcc: 80 a6 40 01 cmp %i1, %g1
200ebd0: 12 80 00 7f bne 200edcc <sparse_disk_ioctl+0x20c>
200ebd4: fa 06 20 3c ld [ %i0 + 0x3c ], %i5
rtems_blkdev_request *r = argp;
switch ( r->req ) {
200ebd8: e8 06 80 00 ld [ %i2 ], %l4
200ebdc: 80 a5 20 01 cmp %l4, 1
200ebe0: 18 80 00 95 bgu 200ee34 <sparse_disk_ioctl+0x274> <== NEVER TAKEN
200ebe4: 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 );
200ebe8: d0 07 40 00 ld [ %i5 ], %o0
200ebec: 94 10 20 00 clr %o2
200ebf0: 7f ff eb 25 call 2009884 <rtems_semaphore_obtain>
200ebf4: 25 00 80 3a sethi %hi(0x200e800), %l2
static int sparse_disk_read_write(
rtems_sparse_disk *sparse_disk,
rtems_blkdev_request *req,
const bool read )
{
int rv = 0;
200ebf8: b6 10 20 00 clr %i3
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
200ebfc: b0 10 20 00 clr %i0
/* 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(
200ec00: 10 80 00 63 b 200ed8c <sparse_disk_ioctl+0x1cc>
200ec04: a4 14 a3 8c or %l2, 0x38c, %l2
for ( req_buffer = 0;
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
bytes_handled = 0;
200ec08: a6 10 20 00 clr %l3
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];
200ec0c: 84 00 a0 18 add %g2, 0x18, %g2
200ec10: 82 06 80 02 add %i2, %g2, %g1
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
200ec14: f2 06 80 02 ld [ %i2 + %g2 ], %i1
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
200ec18: ea 00 60 08 ld [ %g1 + 8 ], %l5
block = scatter_gather->block;
buff_size = scatter_gather->length;
200ec1c: 10 80 00 54 b 200ed6c <sparse_disk_ioctl+0x1ac>
200ec20: f8 00 60 04 ld [ %g1 + 4 ], %i4
const rtems_blkdev_bnum block,
uint8_t *buffer,
const size_t buffer_size )
{
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
200ec24: c0 27 bf fc clr [ %fp + -4 ]
.block = block,
.data = NULL
};
size_t bytes_to_copy = sparse_disk->media_block_size;
200ec28: c2 07 60 0c ld [ %i5 + 0xc ], %g1
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
if ( read )
200ec2c: 80 a5 20 00 cmp %l4, 0
200ec30: 12 80 00 1a bne 200ec98 <sparse_disk_ioctl+0xd8>
200ec34: a2 05 40 13 add %l5, %l3, %l1
200ec38: 80 a7 00 01 cmp %i4, %g1
200ec3c: 08 80 00 03 bleu 200ec48 <sparse_disk_ioctl+0x88>
200ec40: b6 10 00 1c mov %i4, %i3
200ec44: b6 10 00 01 mov %g1, %i3
size_t bytes_to_copy = sparse_disk->media_block_size;
if ( buffer_size < bytes_to_copy )
bytes_to_copy = buffer_size;
key = bsearch(
200ec48: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
200ec4c: d4 07 60 08 ld [ %i5 + 8 ], %o2
200ec50: 90 07 bf f8 add %fp, -8, %o0
200ec54: 96 10 20 08 mov 8, %o3
200ec58: 40 00 32 33 call 201b524 <bsearch>
200ec5c: 98 10 00 12 mov %l2, %o4
200ec60: 82 10 00 08 mov %o0, %g1
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL != key )
200ec64: 80 a0 60 00 cmp %g1, 0
200ec68: 02 80 00 07 be 200ec84 <sparse_disk_ioctl+0xc4>
200ec6c: 90 10 00 11 mov %l1, %o0
memcpy( buffer, key->data, bytes_to_copy );
200ec70: d2 00 60 04 ld [ %g1 + 4 ], %o1
200ec74: 40 00 35 0d call 201c0a8 <memcpy>
200ec78: 94 10 00 1b mov %i3, %o2
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
200ec7c: 10 80 00 3a b 200ed64 <sparse_disk_ioctl+0x1a4>
200ec80: b2 06 60 01 inc %i1
);
if ( NULL != key )
memcpy( buffer, key->data, bytes_to_copy );
else
memset( buffer, sparse_disk->fill_pattern, buffer_size );
200ec84: d2 0f 60 14 ldub [ %i5 + 0x14 ], %o1
200ec88: 40 00 35 45 call 201c19c <memset>
200ec8c: 94 10 00 1c mov %i4, %o2
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
200ec90: 10 80 00 35 b 200ed64 <sparse_disk_ioctl+0x1a4>
200ec94: b2 06 60 01 inc %i1
200ec98: 80 a7 00 01 cmp %i4, %g1
200ec9c: 08 80 00 03 bleu 200eca8 <sparse_disk_ioctl+0xe8>
200eca0: a0 10 00 1c mov %i4, %l0
200eca4: a0 10 00 01 mov %g1, %l0
/* 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(
200eca8: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
200ecac: d4 07 60 08 ld [ %i5 + 8 ], %o2
200ecb0: 90 07 bf f8 add %fp, -8, %o0
200ecb4: 96 10 20 08 mov 8, %o3
200ecb8: 40 00 32 1b call 201b524 <bsearch>
200ecbc: 98 10 00 12 mov %l2, %o4
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
200ecc0: b6 92 20 00 orcc %o0, 0, %i3
200ecc4: 32 80 00 23 bne,a 200ed50 <sparse_disk_ioctl+0x190>
200ecc8: d0 06 e0 04 ld [ %i3 + 4 ], %o0
200eccc: 10 80 00 08 b 200ecec <sparse_disk_ioctl+0x12c>
200ecd0: 84 10 20 00 clr %g2
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
if ( buffer[i] != sparse_disk->fill_pattern )
200ecd4: c4 0f 60 14 ldub [ %i5 + 0x14 ], %g2
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
200ecd8: 82 00 60 01 inc %g1
if ( buffer[i] != sparse_disk->fill_pattern )
200ecdc: 84 18 c0 02 xor %g3, %g2, %g2
200ece0: 80 a0 00 02 cmp %g0, %g2
200ece4: 10 80 00 03 b 200ecf0 <sparse_disk_ioctl+0x130>
200ece8: 84 40 20 00 addx %g0, 0, %g2
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
200ecec: 82 10 20 00 clr %g1
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
200ecf0: 80 a0 40 10 cmp %g1, %l0
200ecf4: 1a 80 00 05 bcc 200ed08 <sparse_disk_ioctl+0x148>
200ecf8: 86 18 a0 01 xor %g2, 1, %g3
200ecfc: 80 88 e0 ff btst 0xff, %g3
200ed00: 32 bf ff f5 bne,a 200ecd4 <sparse_disk_ioctl+0x114>
200ed04: c6 0c 40 01 ldub [ %l1 + %g1 ], %g3
if ( buffer[i] != sparse_disk->fill_pattern )
block_needs_writing = true;
}
if ( block_needs_writing ) {
200ed08: 80 88 a0 ff btst 0xff, %g2
200ed0c: 22 80 00 15 be,a 200ed60 <sparse_disk_ioctl+0x1a0>
200ed10: b6 10 00 10 mov %l0, %i3
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 ) {
200ed14: d2 07 60 08 ld [ %i5 + 8 ], %o1
200ed18: c2 07 60 04 ld [ %i5 + 4 ], %g1
200ed1c: 80 a2 40 01 cmp %o1, %g1
200ed20: 1a 80 00 10 bcc 200ed60 <sparse_disk_ioctl+0x1a0> <== NEVER TAKEN
200ed24: b6 10 3f ff mov -1, %i3
key = &sparse_disk->key_table[sparse_disk->used_count];
200ed28: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
200ed2c: 83 2a 60 03 sll %o1, 3, %g1
key->block = block;
200ed30: f2 22 00 01 st %i1, [ %o0 + %g1 ]
++sparse_disk->used_count;
200ed34: 92 02 60 01 inc %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];
200ed38: b6 02 00 01 add %o0, %g1, %i3
key->block = block;
++sparse_disk->used_count;
200ed3c: d2 27 60 08 st %o1, [ %i5 + 8 ]
qsort( sparse_disk->key_table, sparse_disk->used_count,
200ed40: 94 10 20 08 mov 8, %o2
200ed44: 40 00 35 5c call 201c2b4 <qsort>
200ed48: 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 );
200ed4c: d0 06 e0 04 ld [ %i3 + 4 ], %o0
200ed50: 92 10 00 11 mov %l1, %o1
200ed54: 40 00 34 d5 call 201c0a8 <memcpy>
200ed58: 94 10 00 10 mov %l0, %o2
else if ( block_needs_writing )
return -1;
return bytes_to_copy;
200ed5c: b6 10 00 10 mov %l0, %i3
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
200ed60: b2 06 60 01 inc %i1
bytes_handled += rv;
200ed64: a6 04 c0 1b add %l3, %i3, %l3
buff_size -= rv;
200ed68: b8 27 00 1b sub %i4, %i3, %i4
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
200ed6c: 80 a7 20 00 cmp %i4, 0
200ed70: 02 80 00 04 be 200ed80 <sparse_disk_ioctl+0x1c0>
200ed74: 80 a6 e0 00 cmp %i3, 0
200ed78: 36 bf ff ab bge,a 200ec24 <sparse_disk_ioctl+0x64> <== ALWAYS TAKEN
200ed7c: f2 27 bf f8 st %i1, [ %fp + -8 ]
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
200ed80: 80 a6 e0 00 cmp %i3, 0
200ed84: 06 80 00 06 bl 200ed9c <sparse_disk_ioctl+0x1dc> <== NEVER TAKEN
200ed88: b0 06 20 01 inc %i0
( 0 <= rv ) && ( req_buffer < req->bufnum );
200ed8c: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
200ed90: 80 a6 00 01 cmp %i0, %g1
200ed94: 0a bf ff 9d bcs 200ec08 <sparse_disk_ioctl+0x48>
200ed98: 85 2e 20 04 sll %i0, 4, %g2
bytes_handled += rv;
buff_size -= rv;
}
}
rtems_semaphore_release( sparse_disk->mutex );
200ed9c: 7f ff eb 03 call 20099a8 <rtems_semaphore_release>
200eda0: d0 07 40 00 ld [ %i5 ], %o0
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
200eda4: 90 10 00 1a mov %i2, %o0
200eda8: 92 10 20 1b mov 0x1b, %o1
if ( 0 > rv )
200edac: 80 a6 e0 00 cmp %i3, 0
200edb0: 06 80 00 03 bl 200edbc <sparse_disk_ioctl+0x1fc> <== NEVER TAKEN
200edb4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
200edb8: 92 10 20 00 clr %o1
200edbc: 9f c0 40 00 call %g1
200edc0: b0 10 20 00 clr %i0
200edc4: 81 c7 e0 08 ret
200edc8: 81 e8 00 00 restore
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 ) {
200edcc: 03 08 00 10 sethi %hi(0x20004000), %g1
200edd0: 82 10 62 07 or %g1, 0x207, %g1 ! 20004207 <RAM_END+0x1dc04207>
200edd4: 80 a6 40 01 cmp %i1, %g1
200edd8: 12 80 00 12 bne 200ee20 <sparse_disk_ioctl+0x260>
200eddc: 90 10 00 18 mov %i0, %o0
sc = rtems_semaphore_delete( sd->mutex );
200ede0: 7f ff ea 7a call 20097c8 <rtems_semaphore_delete>
200ede4: d0 07 40 00 ld [ %i5 ], %o0
if ( RTEMS_SUCCESSFUL != sc )
200ede8: 80 a2 20 00 cmp %o0, 0
200edec: 22 80 00 05 be,a 200ee00 <sparse_disk_ioctl+0x240> <== ALWAYS TAKEN
200edf0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
rtems_fatal_error_occurred( 0xdeadbeef );
200edf4: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
200edf8: 7f ff ec 8e call 200a030 <rtems_fatal_error_occurred> <== NOT EXECUTED
200edfc: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
sd->mutex = RTEMS_ID_NONE;
200ee00: c0 27 40 00 clr [ %i5 ]
if ( NULL != sd->delete_handler )
200ee04: 80 a0 60 00 cmp %g1, 0
200ee08: 02 bf ff ef be 200edc4 <sparse_disk_ioctl+0x204> <== NEVER TAKEN
200ee0c: b0 10 20 00 clr %i0
( *sd->delete_handler )( sd );
200ee10: 9f c0 40 00 call %g1
200ee14: 90 10 00 1d mov %i5, %o0
200ee18: 81 c7 e0 08 ret
200ee1c: 81 e8 00 00 restore
return 0;
} else {
return rtems_blkdev_ioctl( dd, req, argp );
200ee20: 92 10 00 19 mov %i1, %o1
200ee24: 40 00 0b 2f call 2011ae0 <rtems_blkdev_ioctl>
200ee28: 94 10 00 1a mov %i2, %o2
200ee2c: 81 c7 e0 08 ret
200ee30: 91 e8 00 08 restore %g0, %o0, %o0
}
errno = EINVAL;
200ee34: 40 00 31 de call 201b5ac <__errno> <== NOT EXECUTED
200ee38: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200ee3c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200ee40: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
}
200ee44: 81 c7 e0 08 ret <== NOT EXECUTED
200ee48: 81 e8 00 00 restore <== NOT EXECUTED
02005d14 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
2005d14: 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;
2005d18: c4 06 21 54 ld [ %i0 + 0x154 ], %g2
if ( this_reent ) {
2005d1c: 80 a0 a0 00 cmp %g2, 0
2005d20: 02 80 00 0c be 2005d50 <sync_per_thread+0x3c> <== NEVER TAKEN
2005d24: 3b 00 80 7d sethi %hi(0x201f400), %i5
current_reent = _Thread_Executing->libc_reent;
2005d28: ba 17 60 30 or %i5, 0x30, %i5 ! 201f430 <_Per_CPU_Information>
2005d2c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
2005d30: 13 00 80 17 sethi %hi(0x2005c00), %o1
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
if ( this_reent ) {
current_reent = _Thread_Executing->libc_reent;
2005d34: f8 00 61 54 ld [ %g1 + 0x154 ], %i4
_Thread_Executing->libc_reent = this_reent;
2005d38: c4 20 61 54 st %g2, [ %g1 + 0x154 ]
_fwalk (t->libc_reent, sync_wrapper);
2005d3c: d0 06 21 54 ld [ %i0 + 0x154 ], %o0
2005d40: 40 00 2d b1 call 2011404 <_fwalk>
2005d44: 92 12 61 58 or %o1, 0x158, %o1
_Thread_Executing->libc_reent = current_reent;
2005d48: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2005d4c: f8 20 61 54 st %i4, [ %g1 + 0x154 ]
2005d50: 81 c7 e0 08 ret
2005d54: 81 e8 00 00 restore
02006ff4 <sysconf>:
*/
long sysconf(
int name
)
{
2006ff4: 9d e3 bf a0 save %sp, -96, %sp
if ( name == _SC_CLK_TCK )
2006ff8: 80 a6 20 02 cmp %i0, 2
2006ffc: 12 80 00 09 bne 2007020 <sysconf+0x2c>
2007000: 03 00 80 73 sethi %hi(0x201cc00), %g1
return (TOD_MICROSECONDS_PER_SECOND /
2007004: 03 00 80 6a sethi %hi(0x201a800), %g1
2007008: d2 00 63 d4 ld [ %g1 + 0x3d4 ], %o1 ! 201abd4 <Configuration+0xc>
200700c: 11 00 03 d0 sethi %hi(0xf4000), %o0
2007010: 40 00 45 fb call 20187fc <.udiv>
2007014: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
2007018: 81 c7 e0 08 ret
200701c: 91 e8 00 08 restore %g0, %o0, %o0
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
2007020: 80 a6 20 04 cmp %i0, 4
2007024: 02 80 00 13 be 2007070 <sysconf+0x7c>
2007028: d0 00 61 78 ld [ %g1 + 0x178 ], %o0
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
200702c: 80 a6 20 33 cmp %i0, 0x33
2007030: 02 80 00 10 be 2007070 <sysconf+0x7c>
2007034: 90 10 24 00 mov 0x400, %o0
return 1024;
if ( name == _SC_PAGESIZE )
2007038: 80 a6 20 08 cmp %i0, 8
200703c: 02 80 00 0d be 2007070 <sysconf+0x7c>
2007040: 11 00 00 04 sethi %hi(0x1000), %o0
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
2007044: 80 a6 20 4f cmp %i0, 0x4f
2007048: 02 80 00 0a be 2007070 <sysconf+0x7c> <== NEVER TAKEN
200704c: 90 10 20 20 mov 0x20, %o0
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
2007050: 80 a6 22 03 cmp %i0, 0x203
2007054: 02 80 00 07 be 2007070 <sysconf+0x7c> <== NEVER TAKEN
2007058: 90 10 20 00 clr %o0
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
200705c: 40 00 22 49 call 200f980 <__errno>
2007060: 01 00 00 00 nop
2007064: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007068: c2 22 00 00 st %g1, [ %o0 ]
200706c: 90 10 3f ff mov -1, %o0
}
2007070: b0 10 00 08 mov %o0, %i0
2007074: 81 c7 e0 08 ret
2007078: 81 e8 00 00 restore
02012f28 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
2012f28: 9d e3 bf a0 save %sp, -96, %sp
switch (opt) {
2012f2c: 80 a6 60 00 cmp %i1, 0
2012f30: 02 80 00 10 be 2012f70 <tcsetattr+0x48>
2012f34: 80 a6 60 01 cmp %i1, 1
2012f38: 02 80 00 08 be 2012f58 <tcsetattr+0x30>
2012f3c: 90 10 00 18 mov %i0, %o0
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
2012f40: 40 00 10 e3 call 20172cc <__errno>
2012f44: b0 10 3f ff mov -1, %i0
2012f48: 82 10 20 86 mov 0x86, %g1
2012f4c: c2 22 00 00 st %g1, [ %o0 ]
2012f50: 81 c7 e0 08 ret
2012f54: 81 e8 00 00 restore
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
2012f58: 92 10 20 03 mov 3, %o1
2012f5c: 40 00 0d de call 20166d4 <ioctl>
2012f60: 94 10 20 00 clr %o2
2012f64: 80 a2 20 00 cmp %o0, 0
2012f68: 26 80 00 04 bl,a 2012f78 <tcsetattr+0x50> <== NEVER TAKEN
2012f6c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
2012f70: 40 00 0d d9 call 20166d4 <ioctl>
2012f74: 93 e8 20 02 restore %g0, 2, %o1
}
}
2012f78: 81 c7 e0 08 ret <== NOT EXECUTED
2012f7c: 81 e8 00 00 restore <== NOT EXECUTED
020085e0 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
20085e0: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
20085e4: 80 a6 20 01 cmp %i0, 1
20085e8: 12 80 00 13 bne 2008634 <timer_create+0x54>
20085ec: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
20085f0: 02 80 00 11 be 2008634 <timer_create+0x54>
20085f4: 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) {
20085f8: 02 80 00 13 be 2008644 <timer_create+0x64>
20085fc: 03 00 80 88 sethi %hi(0x2022000), %g1
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
2008600: c2 06 40 00 ld [ %i1 ], %g1
2008604: 82 00 7f ff add %g1, -1, %g1
2008608: 80 a0 60 01 cmp %g1, 1
200860c: 28 80 00 03 bleu,a 2008618 <timer_create+0x38> <== ALWAYS TAKEN
2008610: c2 06 60 04 ld [ %i1 + 4 ], %g1
2008614: 30 80 00 08 b,a 2008634 <timer_create+0x54> <== NOT EXECUTED
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
2008618: 80 a0 60 00 cmp %g1, 0
200861c: 32 80 00 03 bne,a 2008628 <timer_create+0x48> <== ALWAYS TAKEN
2008620: 82 00 7f ff add %g1, -1, %g1
2008624: 30 80 00 04 b,a 2008634 <timer_create+0x54> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
2008628: 80 a0 60 1f cmp %g1, 0x1f
200862c: 28 80 00 06 bleu,a 2008644 <timer_create+0x64> <== ALWAYS TAKEN
2008630: 03 00 80 88 sethi %hi(0x2022000), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
2008634: 40 00 23 d7 call 2011590 <__errno>
2008638: 01 00 00 00 nop
200863c: 10 80 00 10 b 200867c <timer_create+0x9c>
2008640: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2008644: c4 00 60 90 ld [ %g1 + 0x90 ], %g2
++level;
2008648: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
200864c: c4 20 60 90 st %g2, [ %g1 + 0x90 ]
* 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 );
2008650: 11 00 80 88 sethi %hi(0x2022000), %o0
2008654: 40 00 08 6e call 200a80c <_Objects_Allocate>
2008658: 90 12 23 a4 or %o0, 0x3a4, %o0 ! 20223a4 <_POSIX_Timer_Information>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
200865c: 80 a2 20 00 cmp %o0, 0
2008660: 12 80 00 0a bne 2008688 <timer_create+0xa8>
2008664: 82 10 20 02 mov 2, %g1
_Thread_Enable_dispatch();
2008668: 40 00 0d a0 call 200bce8 <_Thread_Enable_dispatch>
200866c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EAGAIN );
2008670: 40 00 23 c8 call 2011590 <__errno>
2008674: 01 00 00 00 nop
2008678: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
200867c: c2 22 00 00 st %g1, [ %o0 ]
2008680: 81 c7 e0 08 ret
2008684: 91 e8 3f ff restore %g0, -1, %o0
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
2008688: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ]
ptimer->thread_id = _Thread_Executing->Object.id;
200868c: 03 00 80 89 sethi %hi(0x2022400), %g1
2008690: c2 00 62 00 ld [ %g1 + 0x200 ], %g1 ! 2022600 <_Per_CPU_Information+0x10>
if ( evp != NULL ) {
2008694: 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;
2008698: c2 00 60 08 ld [ %g1 + 8 ], %g1
if ( evp != NULL ) {
200869c: 02 80 00 08 be 20086bc <timer_create+0xdc>
20086a0: c2 22 20 38 st %g1, [ %o0 + 0x38 ]
ptimer->inf.sigev_notify = evp->sigev_notify;
20086a4: c2 06 40 00 ld [ %i1 ], %g1
20086a8: c2 22 20 40 st %g1, [ %o0 + 0x40 ]
ptimer->inf.sigev_signo = evp->sigev_signo;
20086ac: c2 06 60 04 ld [ %i1 + 4 ], %g1
20086b0: c2 22 20 44 st %g1, [ %o0 + 0x44 ]
ptimer->inf.sigev_value = evp->sigev_value;
20086b4: c2 06 60 08 ld [ %i1 + 8 ], %g1
20086b8: c2 22 20 48 st %g1, [ %o0 + 0x48 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20086bc: c4 12 20 0a lduh [ %o0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20086c0: 07 00 80 88 sethi %hi(0x2022000), %g3
20086c4: c6 00 e3 c0 ld [ %g3 + 0x3c0 ], %g3 ! 20223c0 <_POSIX_Timer_Information+0x1c>
}
ptimer->overrun = 0;
20086c8: c0 22 20 68 clr [ %o0 + 0x68 ]
ptimer->timer_data.it_value.tv_sec = 0;
20086cc: c0 22 20 5c clr [ %o0 + 0x5c ]
ptimer->timer_data.it_value.tv_nsec = 0;
20086d0: c0 22 20 60 clr [ %o0 + 0x60 ]
ptimer->timer_data.it_interval.tv_sec = 0;
20086d4: c0 22 20 54 clr [ %o0 + 0x54 ]
ptimer->timer_data.it_interval.tv_nsec = 0;
20086d8: c0 22 20 58 clr [ %o0 + 0x58 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20086dc: c0 22 20 18 clr [ %o0 + 0x18 ]
the_watchdog->routine = routine;
20086e0: c0 22 20 2c clr [ %o0 + 0x2c ]
the_watchdog->id = id;
20086e4: c0 22 20 30 clr [ %o0 + 0x30 ]
the_watchdog->user_data = user_data;
20086e8: c0 22 20 34 clr [ %o0 + 0x34 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20086ec: c2 02 20 08 ld [ %o0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20086f0: 85 28 a0 02 sll %g2, 2, %g2
20086f4: 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;
20086f8: 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;
20086fc: c2 26 80 00 st %g1, [ %i2 ]
_Thread_Enable_dispatch();
2008700: 40 00 0d 7a call 200bce8 <_Thread_Enable_dispatch>
2008704: b0 10 20 00 clr %i0
return 0;
}
2008708: 81 c7 e0 08 ret
200870c: 81 e8 00 00 restore
020071e8 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
20071e8: 9d e3 bf 78 save %sp, -136, %sp
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
20071ec: 80 a6 a0 00 cmp %i2, 0
20071f0: 02 80 00 80 be 20073f0 <timer_settime+0x208> <== NEVER TAKEN
20071f4: 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) ) ) {
20071f8: 40 00 0f 83 call 200b004 <_Timespec_Is_valid>
20071fc: 90 06 a0 08 add %i2, 8, %o0
2007200: 80 8a 20 ff btst 0xff, %o0
2007204: 02 80 00 7b be 20073f0 <timer_settime+0x208>
2007208: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
200720c: 40 00 0f 7e call 200b004 <_Timespec_Is_valid>
2007210: 90 10 00 1a mov %i2, %o0
2007214: 80 8a 20 ff btst 0xff, %o0
2007218: 02 80 00 76 be 20073f0 <timer_settime+0x208> <== NEVER TAKEN
200721c: 80 8e 7f fb btst -5, %i1
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
2007220: 12 80 00 74 bne 20073f0 <timer_settime+0x208>
2007224: 90 07 bf f0 add %fp, -16, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
2007228: 92 10 00 1a mov %i2, %o1
200722c: 40 00 25 91 call 2010870 <memcpy>
2007230: 94 10 20 10 mov 0x10, %o2
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
2007234: 80 a6 60 04 cmp %i1, 4
2007238: 12 80 00 1f bne 20072b4 <timer_settime+0xcc>
200723c: 11 00 80 78 sethi %hi(0x201e000), %o0
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
2007240: 90 07 bf e0 add %fp, -32, %o0
2007244: 13 00 80 77 sethi %hi(0x201dc00), %o1
2007248: 40 00 06 74 call 2008c18 <_TOD_Get_with_nanoseconds>
200724c: 92 12 63 68 or %o1, 0x368, %o1 ! 201df68 <_TOD>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
2007250: 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);
2007254: 94 10 20 00 clr %o2
2007258: 90 10 00 1c mov %i4, %o0
200725c: 92 10 00 1d mov %i5, %o1
2007260: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007264: 40 00 48 ed call 2019618 <__divdi3>
2007268: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
200726c: 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);
2007270: d2 27 bf e8 st %o1, [ %fp + -24 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007274: 90 10 00 1c mov %i4, %o0
2007278: 92 10 00 1d mov %i5, %o1
200727c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007280: 40 00 49 d1 call 20199c4 <__moddi3>
2007284: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
/* 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 ) )
2007288: 90 07 bf f8 add %fp, -8, %o0
200728c: d2 27 bf ec st %o1, [ %fp + -20 ]
2007290: 40 00 0f 6f call 200b04c <_Timespec_Less_than>
2007294: 92 07 bf e8 add %fp, -24, %o1
2007298: 80 8a 20 ff btst 0xff, %o0
200729c: 12 80 00 55 bne 20073f0 <timer_settime+0x208>
20072a0: 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 );
20072a4: 90 07 bf e8 add %fp, -24, %o0
20072a8: 40 00 0f 79 call 200b08c <_Timespec_Subtract>
20072ac: 94 10 00 09 mov %o1, %o2
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
20072b0: 11 00 80 78 sethi %hi(0x201e000), %o0
20072b4: 92 10 00 18 mov %i0, %o1
20072b8: 90 12 22 f4 or %o0, 0x2f4, %o0
20072bc: 40 00 08 fe call 20096b4 <_Objects_Get>
20072c0: 94 07 bf dc add %fp, -36, %o2
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
20072c4: c2 07 bf dc ld [ %fp + -36 ], %g1
20072c8: 80 a0 60 00 cmp %g1, 0
20072cc: 12 80 00 49 bne 20073f0 <timer_settime+0x208>
20072d0: 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 ) {
20072d4: c2 07 bf f8 ld [ %fp + -8 ], %g1
20072d8: 80 a0 60 00 cmp %g1, 0
20072dc: 12 80 00 14 bne 200732c <timer_settime+0x144>
20072e0: c2 07 bf fc ld [ %fp + -4 ], %g1
20072e4: 80 a0 60 00 cmp %g1, 0
20072e8: 12 80 00 11 bne 200732c <timer_settime+0x144>
20072ec: 01 00 00 00 nop
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
20072f0: 40 00 10 75 call 200b4c4 <_Watchdog_Remove>
20072f4: 90 02 20 10 add %o0, 0x10, %o0
/* The old data of the timer are returned */
if ( ovalue )
20072f8: 80 a6 e0 00 cmp %i3, 0
20072fc: 02 80 00 05 be 2007310 <timer_settime+0x128>
2007300: 90 10 00 1b mov %i3, %o0
*ovalue = ptimer->timer_data;
2007304: 92 06 60 54 add %i1, 0x54, %o1
2007308: 40 00 25 5a call 2010870 <memcpy>
200730c: 94 10 20 10 mov 0x10, %o2
/* The new data are set */
ptimer->timer_data = normalize;
2007310: 90 06 60 54 add %i1, 0x54, %o0
2007314: 92 07 bf f0 add %fp, -16, %o1
2007318: 40 00 25 56 call 2010870 <memcpy>
200731c: 94 10 20 10 mov 0x10, %o2
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
2007320: 82 10 20 04 mov 4, %g1
2007324: 10 80 00 2f b 20073e0 <timer_settime+0x1f8>
2007328: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
200732c: 40 00 0f 69 call 200b0d0 <_Timespec_To_ticks>
2007330: 90 10 00 1a mov %i2, %o0
2007334: d0 26 60 64 st %o0, [ %i1 + 0x64 ]
initial_period = _Timespec_To_ticks( &normalize.it_value );
2007338: 40 00 0f 66 call 200b0d0 <_Timespec_To_ticks>
200733c: 90 07 bf f8 add %fp, -8, %o0
activated = _POSIX_Timer_Insert_helper(
2007340: 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 );
2007344: 92 10 00 08 mov %o0, %o1
activated = _POSIX_Timer_Insert_helper(
2007348: 17 00 80 1d sethi %hi(0x2007400), %o3
200734c: 90 06 60 10 add %i1, 0x10, %o0
2007350: 96 12 e0 08 or %o3, 8, %o3
2007354: 40 00 18 79 call 200d538 <_POSIX_Timer_Insert_helper>
2007358: 98 10 00 19 mov %i1, %o4
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
200735c: 80 8a 20 ff btst 0xff, %o0
2007360: 02 80 00 20 be 20073e0 <timer_settime+0x1f8>
2007364: 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 )
2007368: 02 80 00 05 be 200737c <timer_settime+0x194>
200736c: 90 10 00 1b mov %i3, %o0
*ovalue = ptimer->timer_data;
2007370: 92 06 60 54 add %i1, 0x54, %o1
2007374: 40 00 25 3f call 2010870 <memcpy>
2007378: 94 10 20 10 mov 0x10, %o2
ptimer->timer_data = normalize;
200737c: 94 10 20 10 mov 0x10, %o2
2007380: 92 07 bf f0 add %fp, -16, %o1
2007384: 40 00 25 3b call 2010870 <memcpy>
2007388: 90 06 60 54 add %i1, 0x54, %o0
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
200738c: 82 10 20 03 mov 3, %g1
2007390: 90 07 bf e0 add %fp, -32, %o0
2007394: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
2007398: 13 00 80 77 sethi %hi(0x201dc00), %o1
200739c: 40 00 06 1f call 2008c18 <_TOD_Get_with_nanoseconds>
20073a0: 92 12 63 68 or %o1, 0x368, %o1 ! 201df68 <_TOD>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
20073a4: 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);
20073a8: 94 10 20 00 clr %o2
20073ac: 90 10 00 1c mov %i4, %o0
20073b0: 92 10 00 1d mov %i5, %o1
20073b4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20073b8: 40 00 48 98 call 2019618 <__divdi3>
20073bc: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20073c0: 90 10 00 1c mov %i4, %o0
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
20073c4: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20073c8: 94 10 20 00 clr %o2
20073cc: 92 10 00 1d mov %i5, %o1
20073d0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20073d4: 40 00 49 7c call 20199c4 <__moddi3>
20073d8: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
20073dc: 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();
20073e0: 40 00 0c 6d call 200a594 <_Thread_Enable_dispatch>
20073e4: b0 10 20 00 clr %i0
20073e8: 81 c7 e0 08 ret
20073ec: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
20073f0: 40 00 22 cf call 200ff2c <__errno>
20073f4: b0 10 3f ff mov -1, %i0
20073f8: 82 10 20 16 mov 0x16, %g1
20073fc: c2 22 00 00 st %g1, [ %o0 ]
}
2007400: 81 c7 e0 08 ret
2007404: 81 e8 00 00 restore
020073b8 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
20073b8: 9d e3 bf 98 save %sp, -104, %sp
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
20073bc: 3b 00 80 7e sethi %hi(0x201f800), %i5
20073c0: ba 17 62 98 or %i5, 0x298, %i5 ! 201fa98 <_POSIX_signals_Ualarm_timer>
20073c4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
20073c8: 80 a0 60 00 cmp %g1, 0
20073cc: 12 80 00 0a bne 20073f4 <ualarm+0x3c>
20073d0: b8 10 00 18 mov %i0, %i4
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20073d4: 03 00 80 1c sethi %hi(0x2007000), %g1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20073d8: c0 27 60 08 clr [ %i5 + 8 ]
the_watchdog->routine = routine;
20073dc: 82 10 63 8c or %g1, 0x38c, %g1
the_watchdog->id = id;
20073e0: c0 27 60 20 clr [ %i5 + 0x20 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20073e4: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
20073e8: c0 27 60 24 clr [ %i5 + 0x24 ]
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
20073ec: 10 80 00 1b b 2007458 <ualarm+0xa0>
20073f0: b0 10 20 00 clr %i0
if ( !the_timer->routine ) {
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
20073f4: 40 00 0f f1 call 200b3b8 <_Watchdog_Remove>
20073f8: 90 10 00 1d mov %i5, %o0
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
20073fc: 90 02 3f fe add %o0, -2, %o0
2007400: 80 a2 20 01 cmp %o0, 1
2007404: 18 80 00 15 bgu 2007458 <ualarm+0xa0> <== NEVER TAKEN
2007408: 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);
200740c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2007410: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
2007414: 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);
2007418: 90 02 00 01 add %o0, %g1, %o0
200741c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
2007420: 40 00 0e ac call 200aed0 <_Timespec_From_ticks>
2007424: 90 22 00 01 sub %o0, %g1, %o0
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
2007428: c2 07 bf f8 ld [ %fp + -8 ], %g1
remaining += tp.tv_nsec / 1000;
200742c: 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;
2007430: 85 28 60 03 sll %g1, 3, %g2
2007434: 87 28 60 08 sll %g1, 8, %g3
2007438: 84 20 c0 02 sub %g3, %g2, %g2
remaining += tp.tv_nsec / 1000;
200743c: 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;
2007440: b1 28 a0 06 sll %g2, 6, %i0
2007444: b0 26 00 02 sub %i0, %g2, %i0
remaining += tp.tv_nsec / 1000;
2007448: 40 00 4b fa call 201a430 <.div>
200744c: 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;
2007450: b1 2e 20 06 sll %i0, 6, %i0
remaining += tp.tv_nsec / 1000;
2007454: b0 02 00 18 add %o0, %i0, %i0
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
2007458: 80 a7 20 00 cmp %i4, 0
200745c: 02 80 00 19 be 20074c0 <ualarm+0x108>
2007460: 3b 00 03 d0 sethi %hi(0xf4000), %i5
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
2007464: 90 10 00 1c mov %i4, %o0
2007468: 40 00 4b f0 call 201a428 <.udiv>
200746c: 92 17 62 40 or %i5, 0x240, %o1
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
2007470: 92 17 62 40 or %i5, 0x240, %o1
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
2007474: d0 27 bf f8 st %o0, [ %fp + -8 ]
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
2007478: 40 00 4c 98 call 201a6d8 <.urem>
200747c: 90 10 00 1c mov %i4, %o0
2007480: 85 2a 20 07 sll %o0, 7, %g2
2007484: 83 2a 20 02 sll %o0, 2, %g1
2007488: 82 20 80 01 sub %g2, %g1, %g1
200748c: 90 00 40 08 add %g1, %o0, %o0
2007490: 91 2a 20 03 sll %o0, 3, %o0
2007494: d0 27 bf fc st %o0, [ %fp + -4 ]
ticks = _Timespec_To_ticks( &tp );
2007498: 40 00 0e a3 call 200af24 <_Timespec_To_ticks>
200749c: 90 07 bf f8 add %fp, -8, %o0
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
20074a0: 40 00 0e a1 call 200af24 <_Timespec_To_ticks>
20074a4: 90 07 bf f8 add %fp, -8, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
20074a8: 13 00 80 7e sethi %hi(0x201f800), %o1
20074ac: 92 12 62 98 or %o1, 0x298, %o1 ! 201fa98 <_POSIX_signals_Ualarm_timer>
20074b0: d0 22 60 0c st %o0, [ %o1 + 0xc ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
20074b4: 11 00 80 7c sethi %hi(0x201f000), %o0
20074b8: 40 00 0f 68 call 200b258 <_Watchdog_Insert>
20074bc: 90 12 22 3c or %o0, 0x23c, %o0 ! 201f23c <_Watchdog_Ticks_chain>
}
return remaining;
}
20074c0: 81 c7 e0 08 ret
20074c4: 81 e8 00 00 restore
02006f80 <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 )
{
2006f80: 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 =
2006f84: 94 10 20 18 mov 0x18, %o2
2006f88: 92 10 00 18 mov %i0, %o1
2006f8c: 7f ff f6 fa call 2004b74 <rtems_filesystem_eval_path_start>
2006f90: 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;
2006f94: 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)(
2006f98: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2006f9c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
2006fa0: 9f c0 40 00 call %g1
2006fa4: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
2006fa8: 80 8a 20 ff btst 0xff, %o0
2006fac: 02 80 00 26 be 2007044 <unmount+0xc4>
2006fb0: 03 00 80 74 sethi %hi(0x201d000), %g1
static bool contains_root_or_current_directory(
const rtems_filesystem_mount_table_entry_t *mt_entry
)
{
const rtems_filesystem_location_info_t *root =
&rtems_filesystem_root->location;
2006fb4: c2 00 60 68 ld [ %g1 + 0x68 ], %g1 ! 201d068 <rtems_current_user_env>
const rtems_filesystem_location_info_t *current =
&rtems_filesystem_current->location;
2006fb8: c4 00 40 00 ld [ %g1 ], %g2
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
2006fbc: c2 00 60 04 ld [ %g1 + 4 ], %g1
2006fc0: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
2006fc4: 80 a7 40 01 cmp %i5, %g1
2006fc8: 22 80 00 06 be,a 2006fe0 <unmount+0x60>
2006fcc: 82 10 20 01 mov 1, %g1
2006fd0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
2006fd4: 82 1f 40 01 xor %i5, %g1, %g1
2006fd8: 80 a0 00 01 cmp %g0, %g1
2006fdc: 82 60 3f ff subx %g0, -1, %g1
const rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
if ( !contains_root_or_current_directory( mt_entry ) ) {
2006fe0: 80 a0 60 00 cmp %g1, 0
2006fe4: 12 80 00 14 bne 2007034 <unmount+0xb4>
2006fe8: 01 00 00 00 nop
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
2006fec: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
2006ff0: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
rv = (*mt_point_ops->unmount_h)( mt_entry );
2006ff4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2006ff8: c2 00 60 38 ld [ %g1 + 0x38 ], %g1
2006ffc: 9f c0 40 00 call %g1
2007000: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
2007004: b0 92 20 00 orcc %o0, 0, %i0
2007008: 12 80 00 14 bne 2007058 <unmount+0xd8>
200700c: 01 00 00 00 nop
rtems_id self_task_id = rtems_task_self();
2007010: 40 00 03 f6 call 2007fe8 <rtems_task_self>
2007014: 01 00 00 00 nop
rtems_filesystem_mt_entry_declare_lock_context( lock_context );
rtems_filesystem_mt_entry_lock( lock_context );
2007018: 7f ff ed 3e call 2002510 <sparc_disable_interrupts>
200701c: b8 10 00 08 mov %o0, %i4
mt_entry->unmount_task = self_task_id;
2007020: f8 27 60 3c st %i4, [ %i5 + 0x3c ]
mt_entry->mounted = false;
2007024: c0 2f 60 28 clrb [ %i5 + 0x28 ]
rtems_filesystem_mt_entry_unlock( lock_context );
2007028: 7f ff ed 3e call 2002520 <sparc_enable_interrupts>
200702c: 01 00 00 00 nop
2007030: 30 80 00 0a b,a 2007058 <unmount+0xd8>
}
} else {
errno = EBUSY;
2007034: 40 00 22 ad call 200fae8 <__errno>
2007038: 01 00 00 00 nop
200703c: 10 80 00 05 b 2007050 <unmount+0xd0>
2007040: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10>
rv = -1;
}
} else {
errno = EACCES;
2007044: 40 00 22 a9 call 200fae8 <__errno>
2007048: 01 00 00 00 nop
200704c: 82 10 20 0d mov 0xd, %g1 ! d <PROM_START+0xd>
2007050: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
2007054: b0 10 3f ff mov -1, %i0
}
rtems_filesystem_eval_path_cleanup( &ctx );
2007058: 7f ff f7 03 call 2004c64 <rtems_filesystem_eval_path_cleanup>
200705c: 90 07 bf c8 add %fp, -56, %o0
if ( rv == 0 ) {
2007060: 80 a6 20 00 cmp %i0, 0
2007064: 12 80 00 0b bne 2007090 <unmount+0x110>
2007068: 11 20 00 00 sethi %hi(0x80000000), %o0
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
200706c: 92 10 20 00 clr %o1
2007070: 94 10 20 00 clr %o2
2007074: 40 00 03 19 call 2007cd8 <rtems_event_system_receive>
2007078: 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 ) {
200707c: 80 a2 20 00 cmp %o0, 0
2007080: 02 80 00 04 be 2007090 <unmount+0x110> <== ALWAYS TAKEN
2007084: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
2007088: 40 00 04 89 call 20082ac <rtems_fatal_error_occurred> <== NOT EXECUTED
200708c: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
}
}
return rv;
}
2007090: 81 c7 e0 08 ret
2007094: 81 e8 00 00 restore
02019ef4 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
2019ef4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2019ef8: 03 00 80 72 sethi %hi(0x201c800), %g1
2019efc: c2 00 61 f4 ld [ %g1 + 0x1f4 ], %g1 ! 201c9f4 <rtems_libio_number_iops>
2019f00: 80 a6 00 01 cmp %i0, %g1
2019f04: 1a 80 00 16 bcc 2019f5c <write+0x68>
2019f08: 83 2e 20 03 sll %i0, 3, %g1
iop = rtems_libio_iop( fd );
2019f0c: b1 2e 20 06 sll %i0, 6, %i0
2019f10: b0 26 00 01 sub %i0, %g1, %i0
2019f14: 03 00 80 75 sethi %hi(0x201d400), %g1
2019f18: d0 00 60 44 ld [ %g1 + 0x44 ], %o0 ! 201d444 <rtems_libio_iops>
2019f1c: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
2019f20: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
2019f24: 80 88 61 00 btst 0x100, %g1
2019f28: 02 80 00 0d be 2019f5c <write+0x68>
2019f2c: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
2019f30: 12 80 00 06 bne 2019f48 <write+0x54> <== ALWAYS TAKEN
2019f34: 80 a6 a0 00 cmp %i2, 0
2019f38: 7f ff d5 cd call 200f66c <__errno> <== NOT EXECUTED
2019f3c: 01 00 00 00 nop <== NOT EXECUTED
2019f40: 10 80 00 0a b 2019f68 <write+0x74> <== NOT EXECUTED
2019f44: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rtems_libio_check_count( count );
2019f48: 02 80 00 10 be 2019f88 <write+0x94>
2019f4c: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
2019f50: 80 88 60 04 btst 4, %g1
2019f54: 32 80 00 08 bne,a 2019f74 <write+0x80>
2019f58: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
2019f5c: 7f ff d5 c4 call 200f66c <__errno>
2019f60: 01 00 00 00 nop
2019f64: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
2019f68: c2 22 00 00 st %g1, [ %o0 ]
2019f6c: 81 c7 e0 08 ret
2019f70: 91 e8 3f ff restore %g0, -1, %o0
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
2019f74: 92 10 00 19 mov %i1, %o1
2019f78: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2019f7c: 9f c0 40 00 call %g1
2019f80: 94 10 00 1a mov %i2, %o2
2019f84: b0 10 00 08 mov %o0, %i0
}
2019f88: 81 c7 e0 08 ret
2019f8c: 81 e8 00 00 restore
02007e84 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
2007e84: 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 );
2007e88: 03 00 80 75 sethi %hi(0x201d400), %g1
2007e8c: c2 00 60 f4 ld [ %g1 + 0xf4 ], %g1 ! 201d4f4 <rtems_libio_number_iops>
2007e90: 80 a6 00 01 cmp %i0, %g1
2007e94: 2a 80 00 03 bcs,a 2007ea0 <writev+0x1c>
2007e98: 83 2e 20 03 sll %i0, 3, %g1
2007e9c: 30 80 00 0c b,a 2007ecc <writev+0x48>
iop = rtems_libio_iop( fd );
2007ea0: b1 2e 20 06 sll %i0, 6, %i0
2007ea4: b0 26 00 01 sub %i0, %g1, %i0
2007ea8: 03 00 80 77 sethi %hi(0x201dc00), %g1
2007eac: f8 00 63 44 ld [ %g1 + 0x344 ], %i4 ! 201df44 <rtems_libio_iops>
2007eb0: b8 07 00 18 add %i4, %i0, %i4
rtems_libio_check_is_open( iop );
2007eb4: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
2007eb8: 80 88 61 00 btst 0x100, %g1
2007ebc: 02 80 00 04 be 2007ecc <writev+0x48>
2007ec0: 80 88 60 04 btst 4, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
2007ec4: 12 80 00 06 bne 2007edc <writev+0x58> <== ALWAYS TAKEN
2007ec8: 80 a6 60 00 cmp %i1, 0
2007ecc: 40 00 21 37 call 20103a8 <__errno>
2007ed0: 01 00 00 00 nop
2007ed4: 10 80 00 20 b 2007f54 <writev+0xd0>
2007ed8: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* Argument validation on IO vector
*/
if ( !iov )
2007edc: 02 80 00 1b be 2007f48 <writev+0xc4>
2007ee0: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
2007ee4: 04 80 00 19 ble 2007f48 <writev+0xc4>
2007ee8: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
2007eec: 24 80 00 03 ble,a 2007ef8 <writev+0x74> <== ALWAYS TAKEN
2007ef0: b5 2e a0 03 sll %i2, 3, %i2
2007ef4: 30 80 00 15 b,a 2007f48 <writev+0xc4> <== NOT EXECUTED
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
2007ef8: 82 10 20 00 clr %g1
2007efc: 86 10 20 01 mov 1, %g3
2007f00: 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 )
2007f04: c8 06 40 01 ld [ %i1 + %g1 ], %g4
2007f08: 80 a1 20 00 cmp %g4, 0
2007f0c: 02 80 00 0f be 2007f48 <writev+0xc4>
2007f10: 88 06 40 01 add %i1, %g1, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
2007f14: c8 01 20 04 ld [ %g4 + 4 ], %g4
all_zeros = false;
2007f18: 80 a0 00 04 cmp %g0, %g4
2007f1c: ba 40 3f ff addx %g0, -1, %i5
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
2007f20: 88 81 00 02 addcc %g4, %g2, %g4
2007f24: 0c 80 00 09 bneg 2007f48 <writev+0xc4>
2007f28: 86 08 c0 1d and %g3, %i5, %g3
2007f2c: 80 a1 00 02 cmp %g4, %g2
2007f30: 06 80 00 03 bl 2007f3c <writev+0xb8>
2007f34: ba 10 20 01 mov 1, %i5
2007f38: ba 10 20 00 clr %i5
2007f3c: 80 8f 60 ff btst 0xff, %i5
2007f40: 02 80 00 07 be 2007f5c <writev+0xd8>
2007f44: 82 00 60 08 add %g1, 8, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
2007f48: 40 00 21 18 call 20103a8 <__errno>
2007f4c: 01 00 00 00 nop
2007f50: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007f54: 10 80 00 21 b 2007fd8 <writev+0x154>
2007f58: c2 22 00 00 st %g1, [ %o0 ]
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
2007f5c: 80 a0 40 1a cmp %g1, %i2
2007f60: 12 bf ff e9 bne 2007f04 <writev+0x80>
2007f64: 84 10 00 04 mov %g4, %g2
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
2007f68: 80 88 e0 ff btst 0xff, %g3
2007f6c: 12 80 00 19 bne 2007fd0 <writev+0x14c>
2007f70: b0 10 20 00 clr %i0
2007f74: ba 10 20 00 clr %i5
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
2007f78: b6 06 40 1d add %i1, %i5, %i3
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
2007f7c: d4 06 e0 04 ld [ %i3 + 4 ], %o2
2007f80: 80 a2 a0 00 cmp %o2, 0
2007f84: 22 80 00 10 be,a 2007fc4 <writev+0x140> <== NEVER TAKEN
2007f88: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
2007f8c: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
2007f90: d2 06 40 1d ld [ %i1 + %i5 ], %o1
2007f94: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2007f98: 9f c0 40 00 call %g1
2007f9c: 90 10 00 1c mov %i4, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
2007fa0: 80 a2 20 00 cmp %o0, 0
2007fa4: 26 80 00 0b bl,a 2007fd0 <writev+0x14c> <== NEVER TAKEN
2007fa8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
2007fac: 32 80 00 02 bne,a 2007fb4 <writev+0x130> <== ALWAYS TAKEN
2007fb0: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
2007fb4: c2 06 e0 04 ld [ %i3 + 4 ], %g1
2007fb8: 80 a2 00 01 cmp %o0, %g1
2007fbc: 12 80 00 05 bne 2007fd0 <writev+0x14c> <== NEVER TAKEN
2007fc0: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
2007fc4: 80 a7 40 1a cmp %i5, %i2
2007fc8: 12 bf ff ed bne 2007f7c <writev+0xf8>
2007fcc: b6 06 40 1d add %i1, %i5, %i3
2007fd0: 81 c7 e0 08 ret
2007fd4: 81 e8 00 00 restore
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
2007fd8: b0 10 3f ff mov -1, %i0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
2007fdc: 81 c7 e0 08 ret
2007fe0: 81 e8 00 00 restore