RTEMS 4.11Annotated Report
Thu Dec 20 19:19:05 2012
4000c680 <IMFS_chown>:
int IMFS_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
4000c680: 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();
4000c684: 40 00 02 9e call 4000d0fc <geteuid>
4000c688: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
4000c68c: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
4000c690: 91 2a 20 10 sll %o0, 0x10, %o0
4000c694: 91 32 20 10 srl %o0, 0x10, %o0
4000c698: 80 a0 40 08 cmp %g1, %o0
4000c69c: 02 80 00 04 be 4000c6ac <IMFS_chown+0x2c>
4000c6a0: 80 a2 20 00 cmp %o0, 0
4000c6a4: 12 80 00 0b bne 4000c6d0 <IMFS_chown+0x50> <== ALWAYS TAKEN
4000c6a8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EPERM );
#endif
jnode->st_uid = owner;
4000c6ac: f2 37 60 3c sth %i1, [ %i5 + 0x3c ]
jnode->st_gid = group;
4000c6b0: f4 37 60 3e sth %i2, [ %i5 + 0x3e ]
IMFS_update_ctime( jnode );
4000c6b4: 90 07 bf f8 add %fp, -8, %o0
4000c6b8: 7f ff de fe call 400042b0 <gettimeofday>
4000c6bc: 92 10 20 00 clr %o1
4000c6c0: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000c6c4: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
4000c6c8: 81 c7 e0 08 ret
4000c6cc: 91 e8 20 00 restore %g0, 0, %o0
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
4000c6d0: 40 00 10 9c call 40010940 <__errno>
4000c6d4: b0 10 3f ff mov -1, %i0
4000c6d8: 82 10 20 01 mov 1, %g1
4000c6dc: c2 22 00 00 st %g1, [ %o0 ]
4000c6e0: 81 c7 e0 08 ret
4000c6e4: 81 e8 00 00 restore
400063d0 <IMFS_dump_directory>:
*/
static void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
400063d0: 9d e3 bf a0 save %sp, -96, %sp
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
400063d4: f4 06 20 50 ld [ %i0 + 0x50 ], %i2
400063d8: 39 10 00 9b sethi %hi(0x40026c00), %i4
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
400063dc: b0 06 20 54 add %i0, 0x54, %i0
IMFS_assert( level >= 0 );
IMFS_assert( IMFS_is_directory( the_directory ) );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
400063e0: 80 a6 80 18 cmp %i2, %i0
400063e4: 02 80 00 30 be 400064a4 <IMFS_dump_directory+0xd4>
400063e8: b8 17 22 b8 or %i4, 0x2b8, %i4
400063ec: 37 10 00 93 sethi %hi(0x40024c00), %i3
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
400063f0: 29 10 00 93 sethi %hi(0x40024c00), %l4
return;
}
puts("");
400063f4: 21 10 00 95 sethi %hi(0x40025400), %l0
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
400063f8: 27 10 00 93 sethi %hi(0x40024c00), %l3
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
400063fc: 25 10 00 93 sethi %hi(0x40024c00), %l2
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
40006400: b6 16 e2 38 or %i3, 0x238, %i3
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
40006404: a8 15 22 a8 or %l4, 0x2a8, %l4
return;
}
puts("");
40006408: a0 14 23 a8 or %l0, 0x3a8, %l0
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
4000640c: a6 14 e2 90 or %l3, 0x290, %l3
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
40006410: a4 14 a2 78 or %l2, 0x278, %l2
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
IMFS_dump_directory( the_jnode, level + 1 );
40006414: a2 06 60 01 add %i1, 1, %l1
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
40006418: 80 a6 60 00 cmp %i1, 0
4000641c: 06 80 00 0c bl 4000644c <IMFS_dump_directory+0x7c> <== NEVER TAKEN
40006420: ba 10 20 00 clr %i5
fprintf(stdout, "...." );
40006424: c2 07 00 00 ld [ %i4 ], %g1
40006428: 90 10 00 1b mov %i3, %o0
4000642c: d6 00 60 08 ld [ %g1 + 8 ], %o3
40006430: 92 10 20 01 mov 1, %o1
40006434: 40 00 3e 14 call 40015c84 <fwrite>
40006438: 94 10 20 04 mov 4, %o2
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
4000643c: ba 07 60 01 inc %i5
40006440: 80 a6 40 1d cmp %i1, %i5
40006444: 36 bf ff f9 bge,a 40006428 <IMFS_dump_directory+0x58>
40006448: c2 07 00 00 ld [ %i4 ], %g1
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
4000644c: c2 07 00 00 ld [ %i4 ], %g1
40006450: 90 06 a0 0c add %i2, 0xc, %o0
40006454: 40 00 3a ee call 4001500c <fputs>
40006458: d2 00 60 08 ld [ %g1 + 8 ], %o1
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
4000645c: c2 06 a0 4c ld [ %i2 + 0x4c ], %g1
40006460: d4 00 40 00 ld [ %g1 ], %o2
switch( IMFS_type( the_jnode ) ) {
40006464: 80 a2 a0 06 cmp %o2, 6
40006468: 28 80 00 11 bleu,a 400064ac <IMFS_dump_directory+0xdc> <== ALWAYS TAKEN
4000646c: 95 2a a0 02 sll %o2, 2, %o2
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
40006470: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
40006474: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
40006478: 40 00 3a 95 call 40014ecc <fprintf> <== NOT EXECUTED
4000647c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
40006480: c2 06 a0 4c ld [ %i2 + 0x4c ], %g1 <== NOT EXECUTED
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
40006484: c2 00 40 00 ld [ %g1 ], %g1
40006488: 80 a0 60 00 cmp %g1, 0
4000648c: 22 80 00 19 be,a 400064f0 <IMFS_dump_directory+0x120>
40006490: 90 10 00 1a mov %i2, %o0
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
40006494: f4 06 80 00 ld [ %i2 ], %i2
IMFS_assert( level >= 0 );
IMFS_assert( IMFS_is_directory( the_directory ) );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
40006498: 80 a6 80 18 cmp %i2, %i0
4000649c: 12 bf ff e0 bne 4000641c <IMFS_dump_directory+0x4c>
400064a0: 80 a6 60 00 cmp %i1, 0
400064a4: 81 c7 e0 08 ret
400064a8: 81 e8 00 00 restore
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( IMFS_type( the_jnode ) ) {
400064ac: 03 10 00 18 sethi %hi(0x40006000), %g1
400064b0: 82 10 63 b4 or %g1, 0x3b4, %g1 ! 400063b4 <bsp_interrupt_handler_default+0x18>
400064b4: c2 00 40 0a ld [ %g1 + %o2 ], %g1
400064b8: 81 c0 40 00 jmp %g1
400064bc: 01 00 00 00 nop
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
400064c0: c2 07 00 00 ld [ %i4 ], %g1
400064c4: 90 10 00 12 mov %l2, %o0
400064c8: d6 00 60 08 ld [ %g1 + 8 ], %o3
400064cc: 92 10 20 01 mov 1, %o1
400064d0: 40 00 3d ed call 40015c84 <fwrite>
400064d4: 94 10 20 13 mov 0x13, %o2
400064d8: c2 06 a0 4c ld [ %i2 + 0x4c ], %g1
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
400064dc: c2 00 40 00 ld [ %g1 ], %g1
400064e0: 80 a0 60 00 cmp %g1, 0
400064e4: 32 bf ff ed bne,a 40006498 <IMFS_dump_directory+0xc8> <== ALWAYS TAKEN
400064e8: f4 06 80 00 ld [ %i2 ], %i2
IMFS_dump_directory( the_jnode, level + 1 );
400064ec: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
400064f0: 7f ff ff b8 call 400063d0 <IMFS_dump_directory>
400064f4: 92 10 00 11 mov %l1, %o1
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
400064f8: 10 bf ff e8 b 40006498 <IMFS_dump_directory+0xc8>
400064fc: f4 06 80 00 ld [ %i2 ], %i2
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
40006500: c2 07 00 00 ld [ %i4 ], %g1
40006504: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2
40006508: d0 00 60 08 ld [ %g1 + 8 ], %o0
4000650c: d6 06 a0 58 ld [ %i2 + 0x58 ], %o3
40006510: 13 10 00 93 sethi %hi(0x40024c00), %o1
40006514: 40 00 3a 6e call 40014ecc <fprintf>
40006518: 92 12 62 58 or %o1, 0x258, %o1 ! 40024e58 <Callbacks.6428+0x158>
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
return;
}
puts("");
4000651c: 40 00 41 db call 40016c88 <puts>
40006520: 90 10 00 10 mov %l0, %o0
40006524: 10 bf ff d8 b 40006484 <IMFS_dump_directory+0xb4>
40006528: c2 06 a0 4c ld [ %i2 + 0x4c ], %g1
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
4000652c: c2 07 00 00 ld [ %i4 ], %g1
40006530: d4 06 a0 50 ld [ %i2 + 0x50 ], %o2
40006534: d0 00 60 08 ld [ %g1 + 8 ], %o0
40006538: d6 06 a0 54 ld [ %i2 + 0x54 ], %o3
4000653c: 13 10 00 93 sethi %hi(0x40024c00), %o1
40006540: 40 00 3a 63 call 40014ecc <fprintf>
40006544: 92 12 62 40 or %o1, 0x240, %o1 ! 40024e40 <Callbacks.6428+0x140>
40006548: 30 bf ff f5 b,a 4000651c <IMFS_dump_directory+0x14c>
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( IMFS_type( the_jnode ) ) {
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
4000654c: c2 07 00 00 ld [ %i4 ], %g1
40006550: 90 10 20 2f mov 0x2f, %o0
40006554: 40 00 3a 7a call 40014f3c <fputc>
40006558: d2 00 60 08 ld [ %g1 + 8 ], %o1
4000655c: 30 bf ff f0 b,a 4000651c <IMFS_dump_directory+0x14c>
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
40006560: c2 07 00 00 ld [ %i4 ], %g1
40006564: 90 10 00 13 mov %l3, %o0
40006568: d6 00 60 08 ld [ %g1 + 8 ], %o3
4000656c: 92 10 20 01 mov 1, %o1
40006570: 40 00 3d c5 call 40015c84 <fwrite>
40006574: 94 10 20 12 mov 0x12, %o2
40006578: 10 bf ff c3 b 40006484 <IMFS_dump_directory+0xb4>
4000657c: c2 06 a0 4c ld [ %i2 + 0x4c ], %g1
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
40006580: c2 07 00 00 ld [ %i4 ], %g1
40006584: d4 06 a0 54 ld [ %i2 + 0x54 ], %o2
40006588: d0 00 60 08 ld [ %g1 + 8 ], %o0
4000658c: 13 10 00 93 sethi %hi(0x40024c00), %o1
40006590: 40 00 3a 4f call 40014ecc <fprintf>
40006594: 92 12 62 68 or %o1, 0x268, %o1 ! 40024e68 <Callbacks.6428+0x168>
40006598: 30 bf ff e1 b,a 4000651c <IMFS_dump_directory+0x14c>
4000c82c <IMFS_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
4000c82c: 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;
4000c830: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
bool access_ok = rtems_filesystem_eval_path_check_access(
4000c834: 90 10 00 18 mov %i0, %o0
4000c838: d4 07 20 30 ld [ %i4 + 0x30 ], %o2
4000c83c: d6 17 20 3c lduh [ %i4 + 0x3c ], %o3
4000c840: d8 17 20 3e lduh [ %i4 + 0x3e ], %o4
4000c844: 40 00 03 54 call 4000d594 <rtems_filesystem_eval_path_check_access>
4000c848: 92 10 20 01 mov 1, %o1
dir->st_mode,
dir->st_uid,
dir->st_gid
);
if ( access_ok ) {
4000c84c: 80 8a 20 ff btst 0xff, %o0
4000c850: 12 80 00 04 bne 4000c860 <IMFS_eval_token+0x34>
4000c854: 80 a6 e0 01 cmp %i3, 1
if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
entry = entry->info.hard_link.link_node;
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
4000c858: 81 c7 e0 08 ret
4000c85c: 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] == '.';
4000c860: 02 80 00 58 be 4000c9c0 <IMFS_eval_token+0x194>
4000c864: 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] == '.';
4000c868: 22 80 00 37 be,a 4000c944 <IMFS_eval_token+0x118>
4000c86c: c2 4e 80 00 ldsb [ %i2 ], %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000c870: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {
return dir->Parent;
} else {
rtems_chain_control *entries = &dir->info.directory.Entries;
rtems_chain_node *current = rtems_chain_first( entries );
rtems_chain_node *tail = rtems_chain_tail( entries );
4000c874: b2 07 20 54 add %i4, 0x54, %i1
while ( current != tail ) {
4000c878: 80 a7 40 19 cmp %i5, %i1
4000c87c: 02 80 00 30 be 4000c93c <IMFS_eval_token+0x110>
4000c880: 90 07 60 0c add %i5, 0xc, %o0
IMFS_jnode_t *entry = (IMFS_jnode_t *) current;
bool match = strncmp( entry->name, token, tokenlen ) == 0
4000c884: 92 10 00 1a mov %i2, %o1
4000c888: 40 00 15 c5 call 40011f9c <strncmp>
4000c88c: 94 10 00 1b mov %i3, %o2
&& entry->name [tokenlen] == '\0';
4000c890: 80 a2 20 00 cmp %o0, 0
4000c894: 12 80 00 26 bne 4000c92c <IMFS_eval_token+0x100>
4000c898: 82 07 40 1b add %i5, %i3, %g1
4000c89c: c2 48 60 0c ldsb [ %g1 + 0xc ], %g1
4000c8a0: 80 a0 60 00 cmp %g1, 0
4000c8a4: 32 80 00 23 bne,a 4000c930 <IMFS_eval_token+0x104>
4000c8a8: fa 07 40 00 ld [ %i5 ], %i5
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
4000c8ac: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
if ( access_ok ) {
IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
if ( entry != NULL ) {
bool terminal = !rtems_filesystem_eval_path_has_path( ctx );
4000c8b0: c4 06 20 04 ld [ %i0 + 4 ], %g2
4000c8b4: c2 00 40 00 ld [ %g1 ], %g1
4000c8b8: 80 a0 00 02 cmp %g0, %g2
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
4000c8bc: c0 26 20 0c clr [ %i0 + 0xc ]
4000c8c0: 84 60 3f ff subx %g0, -1, %g2
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
4000c8c4: c8 06 20 10 ld [ %i0 + 0x10 ], %g4
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
IMFS_jnode_types_t type = IMFS_type( entry );
rtems_filesystem_eval_path_clear_token( ctx );
if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
4000c8c8: 80 a0 60 02 cmp %g1, 2
4000c8cc: 02 80 00 43 be 4000c9d8 <IMFS_eval_token+0x1ac>
4000c8d0: 86 10 00 02 mov %g2, %g3
entry = entry->info.hard_link.link_node;
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
4000c8d4: 80 a0 60 03 cmp %g1, 3
4000c8d8: 02 80 00 28 be 4000c978 <IMFS_eval_token+0x14c>
4000c8dc: 80 a0 60 00 cmp %g1, 0
IMFS_jnode_types_t type
)
{
rtems_filesystem_global_location_t **fs_root_ptr = NULL;
if ( type == IMFS_DIRECTORY ) {
4000c8e0: 32 80 00 2c bne,a 4000c990 <IMFS_eval_token+0x164>
4000c8e4: c4 17 20 34 lduh [ %i4 + 0x34 ], %g2
if ( node->info.directory.mt_fs != NULL ) {
4000c8e8: f6 07 60 5c ld [ %i5 + 0x5c ], %i3
4000c8ec: 80 a6 e0 00 cmp %i3, 0
4000c8f0: 02 80 00 27 be 4000c98c <IMFS_eval_token+0x160>
4000c8f4: 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(
4000c8f8: d4 07 60 30 ld [ %i5 + 0x30 ], %o2
4000c8fc: d6 17 60 3c lduh [ %i5 + 0x3c ], %o3
4000c900: d8 17 60 3e lduh [ %i5 + 0x3e ], %o4
4000c904: 40 00 03 24 call 4000d594 <rtems_filesystem_eval_path_check_access>
4000c908: 92 10 20 01 mov 1, %o1
RTEMS_FS_PERMS_EXEC,
entry->st_mode,
entry->st_uid,
entry->st_gid
);
if ( access_ok ) {
4000c90c: 80 8a 20 ff btst 0xff, %o0
4000c910: 02 bf ff d2 be 4000c858 <IMFS_eval_token+0x2c> <== NEVER TAKEN
4000c914: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
4000c918: 92 06 e0 24 add %i3, 0x24, %o1
4000c91c: 7f ff e3 23 call 400055a8 <rtems_filesystem_eval_path_restart>
4000c920: b0 10 20 01 mov 1, %i0
4000c924: 81 c7 e0 08 ret
4000c928: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000c92c: 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 ) {
4000c930: 80 a6 40 1d cmp %i1, %i5
4000c934: 12 bf ff d4 bne 4000c884 <IMFS_eval_token+0x58>
4000c938: 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;
4000c93c: 81 c7 e0 08 ret
4000c940: 91 e8 20 02 restore %g0, 2, %o0
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
4000c944: 80 a0 60 2e cmp %g1, 0x2e
4000c948: 32 bf ff cb bne,a 4000c874 <IMFS_eval_token+0x48>
4000c94c: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
4000c950: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
4000c954: 80 a0 60 2e cmp %g1, 0x2e
4000c958: 32 bf ff c7 bne,a 4000c874 <IMFS_eval_token+0x48> <== NEVER TAKEN
4000c95c: fa 07 20 50 ld [ %i4 + 0x50 ], %i5 <== NOT EXECUTED
{
if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {
return dir;
} else {
if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {
return dir->Parent;
4000c960: fa 07 20 08 ld [ %i4 + 8 ], %i5
);
if ( access_ok ) {
IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
if ( entry != NULL ) {
4000c964: 80 a7 60 00 cmp %i5, 0
4000c968: 02 bf ff f5 be 4000c93c <IMFS_eval_token+0x110>
4000c96c: 01 00 00 00 nop
4000c970: 10 bf ff d0 b 4000c8b0 <IMFS_eval_token+0x84>
4000c974: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
entry = entry->info.hard_link.link_node;
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
4000c978: 80 a0 a0 00 cmp %g2, 0
4000c97c: 02 80 00 20 be 4000c9fc <IMFS_eval_token+0x1d0>
4000c980: 80 89 20 10 btst 0x10, %g4
4000c984: 32 80 00 1f bne,a 4000ca00 <IMFS_eval_token+0x1d4>
4000c988: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
} else {
rtems_filesystem_global_location_t **fs_root_ptr =
IMFS_is_mount_point( entry, type );
if ( fs_root_ptr == NULL ) {
--dir->reference_count;
4000c98c: c4 17 20 34 lduh [ %i4 + 0x34 ], %g2
static inline void IMFS_Set_handlers( rtems_filesystem_location_info_t *loc )
{
IMFS_jnode_t *node = (IMFS_jnode_t *) loc->node_access;
loc->handlers = node->control->handlers;
4000c990: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
4000c994: 84 00 bf ff add %g2, -1, %g2
4000c998: c4 37 20 34 sth %g2, [ %i4 + 0x34 ]
++entry->reference_count;
4000c99c: c4 17 60 34 lduh [ %i5 + 0x34 ], %g2
4000c9a0: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000c9a4: 84 00 a0 01 inc %g2
4000c9a8: c4 37 60 34 sth %g2, [ %i5 + 0x34 ]
currentloc->node_access = entry;
4000c9ac: fa 26 20 20 st %i5, [ %i0 + 0x20 ]
4000c9b0: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
4000c9b4: b0 08 e0 ff and %g3, 0xff, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
}
}
return status;
}
4000c9b8: 81 c7 e0 08 ret
4000c9bc: 81 e8 00 00 restore
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
4000c9c0: c2 4e 80 00 ldsb [ %i2 ], %g1
4000c9c4: 80 a0 60 2e cmp %g1, 0x2e
4000c9c8: 32 bf ff ab bne,a 4000c874 <IMFS_eval_token+0x48>
4000c9cc: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
4000c9d0: 10 bf ff b7 b 4000c8ac <IMFS_eval_token+0x80>
4000c9d4: ba 10 00 1c mov %i4, %i5
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
IMFS_jnode_types_t type = IMFS_type( entry );
rtems_filesystem_eval_path_clear_token( ctx );
if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
4000c9d8: 80 a0 a0 00 cmp %g2, 0
4000c9dc: 12 80 00 04 bne 4000c9ec <IMFS_eval_token+0x1c0>
4000c9e0: 80 89 20 08 btst 8, %g4
entry = entry->info.hard_link.link_node;
4000c9e4: 10 bf ff ea b 4000c98c <IMFS_eval_token+0x160>
4000c9e8: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
IMFS_jnode_types_t type = IMFS_type( entry );
rtems_filesystem_eval_path_clear_token( ctx );
if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
4000c9ec: 22 bf ff e9 be,a 4000c990 <IMFS_eval_token+0x164>
4000c9f0: c4 17 20 34 lduh [ %i4 + 0x34 ], %g2
4000c9f4: 10 bf ff e6 b 4000c98c <IMFS_eval_token+0x160>
4000c9f8: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
entry = entry->info.hard_link.link_node;
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
const char *target = entry->info.sym_link.name;
4000c9fc: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
rtems_filesystem_eval_path_recursive( ctx, target, strlen( target ) );
4000ca00: 40 00 15 35 call 40011ed4 <strlen>
4000ca04: 90 10 00 1d mov %i5, %o0
4000ca08: 92 10 00 1d mov %i5, %o1
4000ca0c: 94 10 00 08 mov %o0, %o2
4000ca10: 7f ff e2 ff call 4000560c <rtems_filesystem_eval_path_recursive>
4000ca14: 90 10 00 18 mov %i0, %o0
4000ca18: 30 bf ff 90 b,a 4000c858 <IMFS_eval_token+0x2c>
4000ca34 <IMFS_fchmod>:
int IMFS_fchmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
4000ca34: 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();
4000ca38: 40 00 01 b1 call 4000d0fc <geteuid>
4000ca3c: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
4000ca40: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
4000ca44: 91 2a 20 10 sll %o0, 0x10, %o0
4000ca48: 91 32 20 10 srl %o0, 0x10, %o0
4000ca4c: 80 a0 40 08 cmp %g1, %o0
4000ca50: 02 80 00 04 be 4000ca60 <IMFS_fchmod+0x2c>
4000ca54: 80 a2 20 00 cmp %o0, 0
4000ca58: 12 80 00 0e bne 4000ca90 <IMFS_fchmod+0x5c> <== ALWAYS TAKEN
4000ca5c: 01 00 00 00 nop
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4000ca60: 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 );
4000ca64: 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);
4000ca68: 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 );
4000ca6c: 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);
4000ca70: b2 0e 6f ff and %i1, 0xfff, %i1
4000ca74: b2 16 40 01 or %i1, %g1, %i1
IMFS_update_ctime( jnode );
4000ca78: 7f ff de 0e call 400042b0 <gettimeofday>
4000ca7c: f2 27 60 30 st %i1, [ %i5 + 0x30 ]
4000ca80: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000ca84: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
4000ca88: 81 c7 e0 08 ret
4000ca8c: 91 e8 20 00 restore %g0, 0, %o0
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
4000ca90: 40 00 0f ac call 40010940 <__errno>
4000ca94: b0 10 3f ff mov -1, %i0
4000ca98: 82 10 20 01 mov 1, %g1
4000ca9c: c2 22 00 00 st %g1, [ %o0 ]
4000caa0: 81 c7 e0 08 ret
4000caa4: 81 e8 00 00 restore
4000445c <IMFS_fifo_write>:
static ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
4000445c: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
40004460: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
40004464: 96 10 00 18 mov %i0, %o3
40004468: d0 07 60 50 ld [ %i5 + 0x50 ], %o0
4000446c: 92 10 00 19 mov %i1, %o1
40004470: 40 00 2b be call 4000f368 <pipe_write>
40004474: 94 10 00 1a mov %i2, %o2
if (err > 0) {
40004478: b0 92 20 00 orcc %o0, 0, %i0
4000447c: 04 80 00 09 ble 400044a0 <IMFS_fifo_write+0x44>
40004480: 90 07 bf f8 add %fp, -8, %o0
IMFS_mtime_ctime_update(jnode);
40004484: 40 00 03 c5 call 40005398 <gettimeofday>
40004488: 92 10 20 00 clr %o1
4000448c: c2 07 bf f8 ld [ %fp + -8 ], %g1
40004490: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
40004494: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
40004498: 81 c7 e0 08 ret
4000449c: 81 e8 00 00 restore
}
IMFS_FIFO_RETURN(err);
400044a0: 80 a6 20 00 cmp %i0, 0
400044a4: 12 80 00 04 bne 400044b4 <IMFS_fifo_write+0x58> <== ALWAYS TAKEN
400044a8: 01 00 00 00 nop
}
400044ac: 81 c7 e0 08 ret <== NOT EXECUTED
400044b0: 81 e8 00 00 restore <== NOT EXECUTED
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
if (err > 0) {
IMFS_mtime_ctime_update(jnode);
}
IMFS_FIFO_RETURN(err);
400044b4: 40 00 38 89 call 400126d8 <__errno>
400044b8: 01 00 00 00 nop
400044bc: 82 20 00 18 neg %i0, %g1
400044c0: c2 22 00 00 st %g1, [ %o0 ]
}
400044c4: 81 c7 e0 08 ret
400044c8: 91 e8 3f ff restore %g0, -1, %o0
4000caa8 <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
)
{
4000caa8: 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;
4000caac: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
4000cab0: c6 00 a0 08 ld [ %g2 + 8 ], %g3
4000cab4: f2 00 80 00 ld [ %g2 ], %i1
4000cab8: f4 00 a0 04 ld [ %g2 + 4 ], %i2
4000cabc: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
4000cac0: f8 00 a0 10 ld [ %g2 + 0x10 ], %i4
4000cac4: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
4000cac8: c2 00 e0 4c ld [ %g3 + 0x4c ], %g1
4000cacc: f2 27 bf e8 st %i1, [ %fp + -24 ]
4000cad0: f4 27 bf ec st %i2, [ %fp + -20 ]
4000cad4: c6 27 bf f0 st %g3, [ %fp + -16 ]
4000cad8: f6 27 bf f4 st %i3, [ %fp + -12 ]
4000cadc: f8 27 bf f8 st %i4, [ %fp + -8 ]
4000cae0: c8 27 bf fc st %g4, [ %fp + -4 ]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
4000cae4: c0 20 a0 08 clr [ %g2 + 8 ]
4000cae8: c4 00 40 00 ld [ %g1 ], %g2
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
loc = temp_mt_entry->mt_fs_root->location;
jnode = (IMFS_jnode_t *)loc.node_access;
4000caec: ba 10 00 03 mov %g3, %i5
4000caf0: c2 00 60 04 ld [ %g1 + 4 ], %g1
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
do {
next = jnode->Parent;
4000caf4: f8 07 60 08 ld [ %i5 + 8 ], %i4
loc.node_access = (void *)jnode;
4000caf8: fa 27 bf f0 st %i5, [ %fp + -16 ]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000cafc: 80 a0 a0 00 cmp %g2, 0
4000cb00: 12 80 00 13 bne 4000cb4c <IMFS_fsunmount+0xa4> <== NEVER TAKEN
4000cb04: c2 27 bf f8 st %g1, [ %fp + -8 ]
4000cb08: 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 );
4000cb0c: 84 07 60 54 add %i5, 0x54, %g2
4000cb10: 80 a0 40 02 cmp %g1, %g2
4000cb14: 02 80 00 0f be 4000cb50 <IMFS_fsunmount+0xa8>
4000cb18: 90 10 20 00 clr %o0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000cb1c: ba 10 00 01 mov %g1, %i5
if ( IMFS_is_directory( jnode ) ) {
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
4000cb20: 80 a7 60 00 cmp %i5, 0
4000cb24: 02 80 00 21 be 4000cba8 <IMFS_fsunmount+0x100> <== NEVER TAKEN
4000cb28: 01 00 00 00 nop
4000cb2c: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
do {
next = jnode->Parent;
4000cb30: f8 07 60 08 ld [ %i5 + 8 ], %i4
4000cb34: c4 00 40 00 ld [ %g1 ], %g2
4000cb38: c2 00 60 04 ld [ %g1 + 4 ], %g1
loc.node_access = (void *)jnode;
4000cb3c: fa 27 bf f0 st %i5, [ %fp + -16 ]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000cb40: 80 a0 a0 00 cmp %g2, 0
4000cb44: 02 bf ff f1 be 4000cb08 <IMFS_fsunmount+0x60>
4000cb48: c2 27 bf f8 st %g1, [ %fp + -8 ]
result = IMFS_rmnod( NULL, &loc );
4000cb4c: 90 10 20 00 clr %o0
4000cb50: 7f ff dc 4b call 40003c7c <IMFS_rmnod>
4000cb54: 92 07 bf e8 add %fp, -24, %o1
if ( result != 0 )
4000cb58: 80 a2 20 00 cmp %o0, 0
4000cb5c: 12 80 00 15 bne 4000cbb0 <IMFS_fsunmount+0x108> <== NEVER TAKEN
4000cb60: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
IMFS_node_destroy( jnode );
4000cb64: 7f ff db 64 call 400038f4 <IMFS_node_destroy>
4000cb68: 90 10 00 1d mov %i5, %o0
jnode = next;
}
if ( jnode != NULL ) {
4000cb6c: 80 a7 20 00 cmp %i4, 0
4000cb70: 02 80 00 0e be 4000cba8 <IMFS_fsunmount+0x100>
4000cb74: 01 00 00 00 nop
4000cb78: c2 07 20 4c ld [ %i4 + 0x4c ], %g1
4000cb7c: c4 00 40 00 ld [ %g1 ], %g2
if ( IMFS_is_directory( jnode ) ) {
4000cb80: 80 a0 a0 00 cmp %g2, 0
4000cb84: 12 bf ff db bne 4000caf0 <IMFS_fsunmount+0x48> <== NEVER TAKEN
4000cb88: ba 10 00 1c mov %i4, %i5
4000cb8c: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4000cb90: 86 07 20 54 add %i4, 0x54, %g3
if ( jnode_has_children( jnode ) )
4000cb94: 80 a7 40 03 cmp %i5, %g3
4000cb98: 12 bf ff e3 bne 4000cb24 <IMFS_fsunmount+0x7c>
4000cb9c: 80 a7 60 00 cmp %i5, 0
4000cba0: 10 bf ff d4 b 4000caf0 <IMFS_fsunmount+0x48>
4000cba4: ba 10 00 1c mov %i4, %i5
4000cba8: 81 c7 e0 08 ret
4000cbac: 81 e8 00 00 restore
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
result = IMFS_rmnod( NULL, &loc );
if ( result != 0 )
rtems_fatal_error_occurred( 0xdeadbeef );
4000cbb0: 7f ff f0 5c call 40008d20 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000cbb4: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
400037e0 <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]
)
{
400037e0: 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 ) );
400037e4: 90 10 20 01 mov 1, %o0
400037e8: 40 00 01 d9 call 40003f4c <calloc>
400037ec: 92 10 20 24 mov 0x24, %o1
if ( fs_info != NULL ) {
400037f0: ba 92 20 00 orcc %o0, 0, %i5
400037f4: 02 80 00 34 be 400038c4 <IMFS_initialize_support+0xe4>
400037f8: 03 10 00 7f sethi %hi(0x4001fc00), %g1
IMFS_jnode_t *root_node;
fs_info->instance = imfs_instance++;
400037fc: c4 00 61 2c ld [ %g1 + 0x12c ], %g2 ! 4001fd2c <imfs_instance.6621>
memcpy(
40003800: 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++;
40003804: 86 00 a0 01 add %g2, 1, %g3
memcpy(
40003808: 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++;
4000380c: c4 27 40 00 st %g2, [ %i5 ]
40003810: c6 20 61 2c st %g3, [ %g1 + 0x12c ]
memcpy(
40003814: 40 00 36 9c call 40011284 <memcpy>
40003818: 90 07 60 08 add %i5, 8, %o0
fs_info->node_controls,
node_controls,
sizeof( fs_info->node_controls )
);
root_node = IMFS_allocate_node(
4000381c: d2 07 60 08 ld [ %i5 + 8 ], %o1
40003820: 90 10 00 1d mov %i5, %o0
40003824: 96 10 20 00 clr %o3
40003828: 15 10 00 78 sethi %hi(0x4001e000), %o2
4000382c: 9a 10 20 00 clr %o5
40003830: 94 12 a1 48 or %o2, 0x148, %o2
40003834: 19 00 00 10 sethi %hi(0x4000), %o4
40003838: 40 00 23 ac call 4000c6e8 <IMFS_allocate_node>
4000383c: 98 13 21 ed or %o4, 0x1ed, %o4 ! 41ed <PROM_START+0x41ed>
"",
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
40003840: 80 a2 20 00 cmp %o0, 0
40003844: 02 80 00 20 be 400038c4 <IMFS_initialize_support+0xe4> <== NEVER TAKEN
40003848: 09 10 00 78 sethi %hi(0x4001e000), %g4
static inline void IMFS_Set_handlers( rtems_filesystem_location_info_t *loc )
{
IMFS_jnode_t *node = (IMFS_jnode_t *) loc->node_access;
loc->handlers = node->control->handlers;
4000384c: c4 02 20 4c ld [ %o0 + 0x4c ], %g2
mt_entry->fs_info = fs_info;
mt_entry->ops = op_table;
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
mt_entry->mt_fs_root->location.node_access = root_node;
40003850: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40003854: c6 00 a0 04 ld [ %g2 + 4 ], %g3
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
mt_entry->fs_info = fs_info;
40003858: fa 26 20 08 st %i5, [ %i0 + 8 ]
mt_entry->ops = op_table;
4000385c: f2 26 20 0c st %i1, [ %i0 + 0xc ]
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
40003860: 05 10 00 7d sethi %hi(0x4001f400), %g2
NULL
);
if ( root_node != NULL ) {
mt_entry->fs_info = fs_info;
mt_entry->ops = op_table;
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40003864: 88 11 23 b4 or %g4, 0x3b4, %g4
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
40003868: c4 00 a1 a0 ld [ %g2 + 0x1a0 ], %g2
NULL
);
if ( root_node != NULL ) {
mt_entry->fs_info = fs_info;
mt_entry->ops = op_table;
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
4000386c: c8 26 20 2c st %g4, [ %i0 + 0x2c ]
mt_entry->mt_fs_root->location.node_access = root_node;
40003870: d0 20 60 08 st %o0, [ %g1 + 8 ]
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
40003874: 80 a0 a0 10 cmp %g2, 0x10
40003878: 02 80 00 0f be 400038b4 <IMFS_initialize_support+0xd4>
4000387c: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
40003880: 80 a0 a0 0f cmp %g2, 0xf
40003884: 04 80 00 0b ble 400038b0 <IMFS_initialize_support+0xd0>
40003888: 82 10 20 20 mov 0x20, %g1
4000388c: 86 10 20 05 mov 5, %g3
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
40003890: 80 a0 80 01 cmp %g2, %g1
40003894: 22 80 00 09 be,a 400038b8 <IMFS_initialize_support+0xd8>
40003898: 03 10 00 7f sethi %hi(0x4001fc00), %g1
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
4000389c: 26 80 00 06 bl,a 400038b4 <IMFS_initialize_support+0xd4> <== NEVER TAKEN
400038a0: 84 10 20 80 mov 0x80, %g2 <== NOT EXECUTED
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
400038a4: 86 80 ff ff addcc %g3, -1, %g3
400038a8: 12 bf ff fa bne 40003890 <IMFS_initialize_support+0xb0> <== ALWAYS TAKEN
400038ac: 83 28 60 01 sll %g1, 1, %g1
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
400038b0: 84 10 20 80 mov 0x80, %g2
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
400038b4: 03 10 00 7f sethi %hi(0x4001fc00), %g1
400038b8: c4 20 61 28 st %g2, [ %g1 + 0x128 ] ! 4001fd28 <imfs_memfile_bytes_per_block>
const IMFS_node_control *const node_controls [IMFS_TYPE_COUNT]
)
{
static int imfs_instance;
int rv = 0;
400038bc: 81 c7 e0 08 ret
400038c0: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = ENOMEM;
rv = -1;
}
} else {
errno = ENOMEM;
400038c4: 40 00 34 1f call 40010940 <__errno>
400038c8: b0 10 3f ff mov -1, %i0
400038cc: 82 10 20 0c mov 0xc, %g1
400038d0: c2 22 00 00 st %g1, [ %o0 ]
IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK
);
}
return rv;
}
400038d4: 81 c7 e0 08 ret
400038d8: 81 e8 00 00 restore
400055f8 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
400055f8: 9d e3 bf 48 save %sp, -184, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
400055fc: 03 10 00 70 sethi %hi(0x4001c000), %g1
40005600: c2 00 63 dc ld [ %g1 + 0x3dc ], %g1 ! 4001c3dc <rtems_current_user_env>
switch (mode & S_IFMT) {
40005604: 05 00 00 08 sethi %hi(0x2000), %g2
void *context
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
40005608: c2 00 60 08 ld [ %g1 + 8 ], %g1
4000560c: b2 2e 40 01 andn %i1, %g1, %i1
switch (mode & S_IFMT) {
40005610: 03 00 00 3c sethi %hi(0xf000), %g1
40005614: 82 0e 40 01 and %i1, %g1, %g1
40005618: 80 a0 40 02 cmp %g1, %g2
4000561c: 22 80 00 0c be,a 4000564c <IMFS_make_generic_node+0x54>
40005620: c2 06 80 00 ld [ %i2 ], %g1
40005624: 08 80 00 1d bleu 40005698 <IMFS_make_generic_node+0xa0> <== NEVER TAKEN
40005628: 05 00 00 04 sethi %hi(0x1000), %g2
4000562c: 05 00 00 18 sethi %hi(0x6000), %g2
40005630: 80 a0 40 02 cmp %g1, %g2
40005634: 02 80 00 05 be 40005648 <IMFS_make_generic_node+0x50>
40005638: 05 00 00 20 sethi %hi(0x8000), %g2
4000563c: 80 a0 40 02 cmp %g1, %g2
40005640: 12 80 00 19 bne 400056a4 <IMFS_make_generic_node+0xac> <== ALWAYS TAKEN
40005644: 01 00 00 00 nop
rv = -1;
break;
}
if ( rv == 0 ) {
if ( node_control->imfs_type == IMFS_GENERIC ) {
40005648: c2 06 80 00 ld [ %i2 ], %g1
4000564c: 80 a0 60 07 cmp %g1, 7
40005650: 12 80 00 15 bne 400056a4 <IMFS_make_generic_node+0xac>
40005654: 92 10 00 18 mov %i0, %o1
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK
| RTEMS_FS_MAKE
| RTEMS_FS_EXCLUSIVE;
const rtems_filesystem_location_info_t *currentloc =
40005658: 94 10 20 78 mov 0x78, %o2
4000565c: 40 00 07 ac call 4000750c <rtems_filesystem_eval_path_start>
40005660: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
40005664: 7f ff ff d2 call 400055ac <IMFS_is_imfs_instance>
40005668: ba 10 00 08 mov %o0, %i5
4000566c: 80 8a 20 ff btst 0xff, %o0
40005670: 12 80 00 13 bne 400056bc <IMFS_make_generic_node+0xc4>
40005674: d4 1f bf d0 ldd [ %fp + -48 ], %o2
IMFS_update_mtime( parent );
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
40005678: 90 07 bf c8 add %fp, -56, %o0
4000567c: 92 10 20 86 mov 0x86, %o1
40005680: 40 00 06 e7 call 4000721c <rtems_filesystem_eval_path_error>
40005684: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40005688: 40 00 07 e1 call 4000760c <rtems_filesystem_eval_path_cleanup>
4000568c: 90 07 bf c8 add %fp, -56, %o0
40005690: 81 c7 e0 08 ret
40005694: 81 e8 00 00 restore
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
switch (mode & S_IFMT) {
40005698: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4000569c: 22 bf ff ec be,a 4000564c <IMFS_make_generic_node+0x54> <== NOT EXECUTED
400056a0: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
} else {
errno = EINVAL;
400056a4: 40 00 40 b0 call 40015964 <__errno>
400056a8: b0 10 3f ff mov -1, %i0
400056ac: 82 10 20 16 mov 0x16, %g1
400056b0: c2 22 00 00 st %g1, [ %o0 ]
400056b4: 81 c7 e0 08 ret
400056b8: 81 e8 00 00 restore
if ( IMFS_is_imfs_instance( currentloc ) ) {
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
400056bc: f6 27 bf b0 st %i3, [ %fp + -80 ]
new_node = IMFS_create_node_with_control(
400056c0: 90 10 00 1d mov %i5, %o0
400056c4: 92 10 00 1a mov %i2, %o1
400056c8: 98 10 00 19 mov %i1, %o4
400056cc: 9a 07 bf b0 add %fp, -80, %o5
400056d0: 40 00 2f fb call 400116bc <IMFS_create_node_with_control>
400056d4: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
&info
);
if ( new_node != NULL ) {
400056d8: 80 a2 20 00 cmp %o0, 0
400056dc: 02 bf ff eb be 40005688 <IMFS_make_generic_node+0x90>
400056e0: 92 10 20 00 clr %o1
IMFS_jnode_t *parent = currentloc->node_access;
400056e4: fa 07 60 08 ld [ %i5 + 8 ], %i5
IMFS_update_ctime( parent );
400056e8: 40 00 02 0f call 40005f24 <gettimeofday>
400056ec: 90 07 bf a8 add %fp, -88, %o0
400056f0: c2 07 bf a8 ld [ %fp + -88 ], %g1
IMFS_update_mtime( parent );
400056f4: 90 07 bf a8 add %fp, -88, %o0
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
400056f8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
400056fc: 40 00 02 0a call 40005f24 <gettimeofday>
40005700: 92 10 20 00 clr %o1
40005704: c2 07 bf a8 ld [ %fp + -88 ], %g1
40005708: b0 10 20 00 clr %i0
4000570c: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40005710: 40 00 07 bf call 4000760c <rtems_filesystem_eval_path_cleanup>
40005714: 90 07 bf c8 add %fp, -56, %o0
40005718: 81 c7 e0 08 ret
4000571c: 81 e8 00 00 restore
4000f3d0 <IMFS_memfile_addblock>:
*/
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
4000f3d0: 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 );
4000f3d4: 94 10 20 01 mov 1, %o2
4000f3d8: 90 10 00 18 mov %i0, %o0
4000f3dc: 7f ff fe c9 call 4000ef00 <IMFS_memfile_get_block_pointer>
4000f3e0: 92 10 00 19 mov %i1, %o1
if ( *block_entry_ptr )
4000f3e4: 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 );
4000f3e8: ba 10 00 08 mov %o0, %i5
if ( *block_entry_ptr )
4000f3ec: 80 a0 60 00 cmp %g1, 0
4000f3f0: 12 80 00 08 bne 4000f410 <IMFS_memfile_addblock+0x40>
4000f3f4: b0 10 20 00 clr %i0
return 0;
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
4000f3f8: 7f ff fe b5 call 4000eecc <memfile_alloc_block>
4000f3fc: 01 00 00 00 nop
if ( !memory )
4000f400: 80 a2 20 00 cmp %o0, 0
4000f404: 02 80 00 05 be 4000f418 <IMFS_memfile_addblock+0x48> <== NEVER TAKEN
4000f408: 01 00 00 00 nop
return 1;
*block_entry_ptr = memory;
4000f40c: d0 27 40 00 st %o0, [ %i5 ]
return 0;
4000f410: 81 c7 e0 08 ret
4000f414: 81 e8 00 00 restore
}
4000f418: 81 c7 e0 08 ret <== NOT EXECUTED
4000f41c: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
4000f644 <IMFS_memfile_extend>:
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
bool zero_fill,
off_t new_length
)
{
4000f644: 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 )
4000f648: 25 10 00 7f sethi %hi(0x4001fc00), %l2
4000f64c: fa 04 a1 28 ld [ %l2 + 0x128 ], %i5 ! 4001fd28 <imfs_memfile_bytes_per_block>
4000f650: b9 37 60 02 srl %i5, 2, %i4
4000f654: 92 10 00 1c mov %i4, %o1
4000f658: 40 00 28 cd call 4001998c <.umul>
4000f65c: 90 07 20 01 add %i4, 1, %o0
4000f660: 92 10 00 1c mov %i4, %o1
4000f664: 40 00 28 ca call 4001998c <.umul>
4000f668: 90 02 20 01 inc %o0
4000f66c: 92 10 00 1d mov %i5, %o1
4000f670: 40 00 28 c7 call 4001998c <.umul>
4000f674: 90 02 3f ff add %o0, -1, %o0
4000f678: 82 10 20 00 clr %g1
4000f67c: 80 a0 40 1a cmp %g1, %i2
4000f680: 04 80 00 58 ble 4000f7e0 <IMFS_memfile_extend+0x19c> <== ALWAYS TAKEN
4000f684: b8 10 00 18 mov %i0, %i4
rtems_set_errno_and_return_minus_one( EFBIG );
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
4000f688: e2 07 20 50 ld [ %i4 + 0x50 ], %l1 <== NOT EXECUTED
4000f68c: 80 a6 80 11 cmp %i2, %l1
4000f690: 04 80 00 3f ble 4000f78c <IMFS_memfile_extend+0x148> <== ALWAYS TAKEN
4000f694: e0 07 20 54 ld [ %i4 + 0x54 ], %l0
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f698: a7 3f 60 1f sra %i5, 0x1f, %l3 <== NOT EXECUTED
4000f69c: 96 10 00 1d mov %i5, %o3
4000f6a0: 94 10 00 13 mov %l3, %o2
4000f6a4: 90 10 00 1a mov %i2, %o0
4000f6a8: 40 00 2a 4b call 40019fd4 <__divdi3>
4000f6ac: 92 10 00 1b mov %i3, %o1
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f6b0: 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;
4000f6b4: b0 10 00 09 mov %o1, %i0
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f6b8: 90 10 00 11 mov %l1, %o0
4000f6bc: 92 10 00 10 mov %l0, %o1
4000f6c0: 40 00 2a 45 call 40019fd4 <__divdi3>
4000f6c4: 94 10 00 13 mov %l3, %o2
4000f6c8: a2 10 00 09 mov %o1, %l1
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f6cc: 90 10 00 09 mov %o1, %o0
4000f6d0: 40 00 28 af call 4001998c <.umul>
4000f6d4: 92 10 00 1d mov %i5, %o1
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
4000f6d8: ba 10 00 11 mov %l1, %i5
4000f6dc: 80 a6 00 11 cmp %i0, %l1
4000f6e0: 1a 80 00 07 bcc 4000f6fc <IMFS_memfile_extend+0xb8> <== ALWAYS TAKEN
4000f6e4: a0 24 00 08 sub %l0, %o0, %l0
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
4000f6e8: 10 80 00 1d b 4000f75c <IMFS_memfile_extend+0x118> <== NOT EXECUTED
4000f6ec: 92 10 20 00 clr %o1 <== NOT EXECUTED
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
4000f6f0: 80 a6 00 1d cmp %i0, %i5
4000f6f4: 0a 80 00 1a bcs 4000f75c <IMFS_memfile_extend+0x118>
4000f6f8: 92 10 20 00 clr %o1
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
4000f6fc: 92 10 00 1d mov %i5, %o1
4000f700: 7f ff ff 34 call 4000f3d0 <IMFS_memfile_addblock>
4000f704: 90 10 00 1c mov %i4, %o0
4000f708: 80 a2 20 00 cmp %o0, 0
4000f70c: 12 80 00 26 bne 4000f7a4 <IMFS_memfile_extend+0x160> <== NEVER TAKEN
4000f710: 80 a6 60 00 cmp %i1, 0
if ( zero_fill ) {
4000f714: 22 bf ff f7 be,a 4000f6f0 <IMFS_memfile_extend+0xac>
4000f718: ba 07 60 01 inc %i5
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
block_p *block_ptr =
4000f71c: 92 10 00 1d mov %i5, %o1
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
if ( zero_fill ) {
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
4000f720: e6 04 a1 28 ld [ %l2 + 0x128 ], %l3
block_p *block_ptr =
4000f724: 94 10 20 00 clr %o2
4000f728: 7f ff fd f6 call 4000ef00 <IMFS_memfile_get_block_pointer>
4000f72c: 90 10 00 1c mov %i4, %o0
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
4000f730: 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;
4000f734: a6 24 c0 10 sub %l3, %l0, %l3
block_p *block_ptr =
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
4000f738: 90 02 00 10 add %o0, %l0, %o0
4000f73c: 92 10 20 00 clr %o1
4000f740: 40 00 07 0e call 40011378 <memset>
4000f744: 94 10 00 13 mov %l3, %o2
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
4000f748: ba 07 60 01 inc %i5
4000f74c: 80 a6 00 1d cmp %i0, %i5
4000f750: 1a bf ff eb bcc 4000f6fc <IMFS_memfile_extend+0xb8>
4000f754: a0 10 20 00 clr %l0
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
4000f758: 92 10 20 00 clr %o1
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
4000f75c: f4 3f 20 50 std %i2, [ %i4 + 0x50 ]
IMFS_update_ctime(the_jnode);
4000f760: 7f ff d2 d4 call 400042b0 <gettimeofday>
4000f764: 90 07 bf f8 add %fp, -8, %o0
4000f768: c2 07 bf f8 ld [ %fp + -8 ], %g1
IMFS_update_mtime(the_jnode);
4000f76c: 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);
4000f770: c2 27 20 48 st %g1, [ %i4 + 0x48 ]
IMFS_update_mtime(the_jnode);
4000f774: 7f ff d2 cf call 400042b0 <gettimeofday>
4000f778: 92 10 20 00 clr %o1
4000f77c: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000f780: c2 27 20 44 st %g1, [ %i4 + 0x44 ]
return 0;
4000f784: 81 c7 e0 08 ret
4000f788: 91 e8 20 00 restore %g0, 0, %o0
rtems_set_errno_and_return_minus_one( EFBIG );
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
4000f78c: 12 80 00 04 bne 4000f79c <IMFS_memfile_extend+0x158> <== NEVER TAKEN
4000f790: 80 a6 c0 10 cmp %i3, %l0
4000f794: 18 bf ff c2 bgu 4000f69c <IMFS_memfile_extend+0x58> <== ALWAYS TAKEN
4000f798: a7 3f 60 1f sra %i5, 0x1f, %l3
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
IMFS_update_mtime(the_jnode);
return 0;
}
4000f79c: 81 c7 e0 08 ret <== NOT EXECUTED
4000f7a0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
memset( &(*block_ptr) [offset], 0, count);
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
4000f7a4: 80 a7 40 11 cmp %i5, %l1 <== NOT EXECUTED
4000f7a8: 0a 80 00 08 bcs 4000f7c8 <IMFS_memfile_extend+0x184> <== NOT EXECUTED
4000f7ac: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
4000f7b0: 7f ff ff 99 call 4000f614 <IMFS_memfile_remove_block> <== NOT EXECUTED
4000f7b4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
memset( &(*block_ptr) [offset], 0, count);
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
4000f7b8: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
4000f7bc: 80 a4 40 1d cmp %l1, %i5 <== NOT EXECUTED
4000f7c0: 08 bf ff fc bleu 4000f7b0 <IMFS_memfile_extend+0x16c> <== NOT EXECUTED
4000f7c4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
4000f7c8: 40 00 04 5e call 40010940 <__errno> <== NOT EXECUTED
4000f7cc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000f7d0: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
4000f7d4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000f7d8: 81 c7 e0 08 ret <== NOT EXECUTED
4000f7dc: 81 e8 00 00 restore <== NOT EXECUTED
IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
4000f7e0: 12 80 00 04 bne 4000f7f0 <IMFS_memfile_extend+0x1ac> <== NEVER TAKEN
4000f7e4: 80 a2 00 1b cmp %o0, %i3
4000f7e8: 38 bf ff a9 bgu,a 4000f68c <IMFS_memfile_extend+0x48>
4000f7ec: e2 07 20 50 ld [ %i4 + 0x50 ], %l1
rtems_set_errno_and_return_minus_one( EFBIG );
4000f7f0: 40 00 04 54 call 40010940 <__errno>
4000f7f4: b0 10 3f ff mov -1, %i0
4000f7f8: 82 10 20 1b mov 0x1b, %g1
4000f7fc: c2 22 00 00 st %g1, [ %o0 ]
4000f800: 81 c7 e0 08 ret
4000f804: 81 e8 00 00 restore
4000ef00 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
4000ef00: 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 ) {
4000ef04: 03 10 00 7f sethi %hi(0x4001fc00), %g1
4000ef08: fa 00 61 28 ld [ %g1 + 0x128 ], %i5 ! 4001fd28 <imfs_memfile_bytes_per_block>
4000ef0c: bb 37 60 02 srl %i5, 2, %i5
4000ef10: 82 07 7f ff add %i5, -1, %g1
4000ef14: 80 a6 40 01 cmp %i1, %g1
4000ef18: 38 80 00 0b bgu,a 4000ef44 <IMFS_memfile_get_block_pointer+0x44>
4000ef1c: 90 07 60 01 add %i5, 1, %o0
p = info->indirect;
if ( malloc_it ) {
4000ef20: 80 a6 a0 00 cmp %i2, 0
4000ef24: 12 80 00 4e bne 4000f05c <IMFS_memfile_get_block_pointer+0x15c>
4000ef28: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
4000ef2c: 80 a2 20 00 cmp %o0, 0
4000ef30: 02 80 00 6d be 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000ef34: 01 00 00 00 nop
return 0;
return &info->indirect[ my_block ];
4000ef38: b3 2e 60 02 sll %i1, 2, %i1
4000ef3c: 81 c7 e0 08 ret
4000ef40: 91 ea 00 19 restore %o0, %i1, %o0
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
4000ef44: 40 00 2a 92 call 4001998c <.umul>
4000ef48: 92 10 00 1d mov %i5, %o1
4000ef4c: 82 02 3f ff add %o0, -1, %g1
4000ef50: 80 a6 40 01 cmp %i1, %g1
4000ef54: 08 80 00 2b bleu 4000f000 <IMFS_memfile_get_block_pointer+0x100>
4000ef58: b8 10 00 08 mov %o0, %i4
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
4000ef5c: 90 02 20 01 inc %o0
4000ef60: 40 00 2a 8b call 4001998c <.umul>
4000ef64: 92 10 00 1d mov %i5, %o1
4000ef68: 90 02 3f ff add %o0, -1, %o0
4000ef6c: 80 a6 40 08 cmp %i1, %o0
4000ef70: 18 80 00 5d bgu 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000ef74: b2 26 40 1c sub %i1, %i4, %i1
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4000ef78: 92 10 00 1d mov %i5, %o1
4000ef7c: 40 00 2b 6a call 40019d24 <.urem>
4000ef80: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000ef84: 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;
4000ef88: a0 10 00 08 mov %o0, %l0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000ef8c: 40 00 2a ba call 40019a74 <.udiv>
4000ef90: 90 10 00 19 mov %i1, %o0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
4000ef94: 92 10 00 1d mov %i5, %o1
4000ef98: 40 00 2a b7 call 40019a74 <.udiv>
4000ef9c: b8 10 00 08 mov %o0, %i4
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
4000efa0: 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;
4000efa4: b6 10 00 08 mov %o0, %i3
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
4000efa8: 40 00 2b 5f call 40019d24 <.urem>
4000efac: 90 10 00 1c mov %i4, %o0
p = info->triply_indirect;
if ( malloc_it ) {
4000efb0: 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;
4000efb4: ba 10 00 08 mov %o0, %i5
p = info->triply_indirect;
if ( malloc_it ) {
4000efb8: 02 80 00 3d be 4000f0ac <IMFS_memfile_get_block_pointer+0x1ac>
4000efbc: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
if ( !p ) {
4000efc0: 80 a2 20 00 cmp %o0, 0
4000efc4: 02 80 00 66 be 4000f15c <IMFS_memfile_get_block_pointer+0x25c>
4000efc8: 01 00 00 00 nop
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
4000efcc: b7 2e e0 02 sll %i3, 2, %i3
4000efd0: c4 02 00 1b ld [ %o0 + %i3 ], %g2
if ( !p1 ) {
4000efd4: 80 a0 a0 00 cmp %g2, 0
4000efd8: 02 80 00 5a be 4000f140 <IMFS_memfile_get_block_pointer+0x240>
4000efdc: b6 02 00 1b add %o0, %i3, %i3
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
4000efe0: bb 2f 60 02 sll %i5, 2, %i5
4000efe4: d0 00 80 1d ld [ %g2 + %i5 ], %o0
if ( !p2 ) {
4000efe8: 80 a2 20 00 cmp %o0, 0
4000efec: 02 80 00 47 be 4000f108 <IMFS_memfile_get_block_pointer+0x208>
4000eff0: ba 00 80 1d add %g2, %i5, %i5
p2 = memfile_alloc_block();
if ( !p2 )
return 0;
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
4000eff4: b1 2c 20 02 sll %l0, 2, %i0
4000eff8: 81 c7 e0 08 ret
4000effc: 91 ea 00 18 restore %o0, %i0, %o0
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
4000f000: b2 26 40 1d sub %i1, %i5, %i1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
4000f004: 92 10 00 1d mov %i5, %o1
4000f008: 40 00 2b 47 call 40019d24 <.urem>
4000f00c: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000f010: 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;
4000f014: b8 10 00 08 mov %o0, %i4
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
4000f018: 40 00 2a 97 call 40019a74 <.udiv>
4000f01c: 90 10 00 19 mov %i1, %o0
p = info->doubly_indirect;
4000f020: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
if ( malloc_it ) {
4000f024: 80 a6 a0 00 cmp %i2, 0
4000f028: 02 80 00 17 be 4000f084 <IMFS_memfile_get_block_pointer+0x184>
4000f02c: ba 10 00 08 mov %o0, %i5
if ( !p ) {
4000f030: 80 a0 60 00 cmp %g1, 0
4000f034: 02 80 00 3c be 4000f124 <IMFS_memfile_get_block_pointer+0x224>
4000f038: 01 00 00 00 nop
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
4000f03c: bb 2f 60 02 sll %i5, 2, %i5
4000f040: d0 00 40 1d ld [ %g1 + %i5 ], %o0
if ( !p1 ) {
4000f044: 80 a2 20 00 cmp %o0, 0
4000f048: 02 80 00 29 be 4000f0ec <IMFS_memfile_get_block_pointer+0x1ec>
4000f04c: ba 00 40 1d add %g1, %i5, %i5
if ( !p1 )
return 0;
p[ doubly ] = (block_p) p1;
}
return (block_p *)&p1[ singly ];
4000f050: b1 2f 20 02 sll %i4, 2, %i0
4000f054: 81 c7 e0 08 ret
4000f058: 91 ea 00 18 restore %o0, %i0, %o0
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
4000f05c: 80 a2 20 00 cmp %o0, 0
4000f060: 32 bf ff b7 bne,a 4000ef3c <IMFS_memfile_get_block_pointer+0x3c>
4000f064: b3 2e 60 02 sll %i1, 2, %i1
p = memfile_alloc_block();
4000f068: 7f ff ff 99 call 4000eecc <memfile_alloc_block>
4000f06c: 01 00 00 00 nop
if ( !p )
4000f070: 80 a2 20 00 cmp %o0, 0
4000f074: 02 80 00 1c be 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f078: 01 00 00 00 nop
return 0;
info->indirect = p;
4000f07c: 10 bf ff af b 4000ef38 <IMFS_memfile_get_block_pointer+0x38>
4000f080: d0 26 20 58 st %o0, [ %i0 + 0x58 ]
}
return (block_p *)&p1[ singly ];
}
if ( !p )
4000f084: 80 a0 60 00 cmp %g1, 0
4000f088: 02 80 00 17 be 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f08c: bb 2a 20 02 sll %o0, 2, %i5
return 0;
p = (block_p *)p[ doubly ];
4000f090: c2 00 40 1d ld [ %g1 + %i5 ], %g1
if ( !p )
4000f094: 80 a0 60 00 cmp %g1, 0
4000f098: 02 80 00 13 be 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f09c: 01 00 00 00 nop
return 0;
return (block_p *)&p[ singly ];
4000f0a0: b1 2f 20 02 sll %i4, 2, %i0
4000f0a4: 81 c7 e0 08 ret
4000f0a8: 91 e8 40 18 restore %g1, %i0, %o0
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
4000f0ac: 80 a2 20 00 cmp %o0, 0
4000f0b0: 02 80 00 0d be 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f0b4: b7 2e e0 02 sll %i3, 2, %i3
return 0;
p1 = (block_p *) p[ triply ];
4000f0b8: c2 02 00 1b ld [ %o0 + %i3 ], %g1
if ( !p1 )
4000f0bc: 80 a0 60 00 cmp %g1, 0
4000f0c0: 02 80 00 09 be 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f0c4: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p2 = (block_p *)p1[ doubly ];
4000f0c8: c2 00 40 1d ld [ %g1 + %i5 ], %g1
if ( !p2 )
4000f0cc: 80 a0 60 00 cmp %g1, 0
4000f0d0: 02 80 00 05 be 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f0d4: 01 00 00 00 nop
return 0;
return (block_p *)&p2[ singly ];
4000f0d8: b1 2c 20 02 sll %l0, 2, %i0
/*
* This means the requested block number is out of range.
*/
return 0;
}
4000f0dc: 81 c7 e0 08 ret
4000f0e0: 91 e8 40 18 restore %g1, %i0, %o0
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
return 0;
4000f0e4: 81 c7 e0 08 ret <== NOT EXECUTED
4000f0e8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
4000f0ec: 7f ff ff 78 call 4000eecc <memfile_alloc_block>
4000f0f0: 01 00 00 00 nop
if ( !p1 )
4000f0f4: 80 a2 20 00 cmp %o0, 0
4000f0f8: 02 bf ff fb be 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f0fc: 01 00 00 00 nop
return 0;
p[ doubly ] = (block_p) p1;
4000f100: 10 bf ff d4 b 4000f050 <IMFS_memfile_get_block_pointer+0x150>
4000f104: d0 27 40 00 st %o0, [ %i5 ]
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
4000f108: 7f ff ff 71 call 4000eecc <memfile_alloc_block>
4000f10c: 01 00 00 00 nop
if ( !p2 )
4000f110: 80 a2 20 00 cmp %o0, 0
4000f114: 02 bf ff f4 be 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f118: 01 00 00 00 nop
return 0;
p1[ doubly ] = (block_p) p2;
4000f11c: 10 bf ff b6 b 4000eff4 <IMFS_memfile_get_block_pointer+0xf4>
4000f120: d0 27 40 00 st %o0, [ %i5 ]
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
4000f124: 7f ff ff 6a call 4000eecc <memfile_alloc_block>
4000f128: 01 00 00 00 nop
if ( !p )
4000f12c: 82 92 20 00 orcc %o0, 0, %g1
4000f130: 02 bf ff ed be 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f134: 01 00 00 00 nop
return 0;
info->doubly_indirect = p;
4000f138: 10 bf ff c1 b 4000f03c <IMFS_memfile_get_block_pointer+0x13c>
4000f13c: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
4000f140: 7f ff ff 63 call 4000eecc <memfile_alloc_block>
4000f144: 01 00 00 00 nop
if ( !p1 )
4000f148: 84 92 20 00 orcc %o0, 0, %g2
4000f14c: 02 bf ff e6 be 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f150: 01 00 00 00 nop
return 0;
p[ triply ] = (block_p) p1;
4000f154: 10 bf ff a3 b 4000efe0 <IMFS_memfile_get_block_pointer+0xe0>
4000f158: c4 26 c0 00 st %g2, [ %i3 ]
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
4000f15c: 7f ff ff 5c call 4000eecc <memfile_alloc_block>
4000f160: 01 00 00 00 nop
if ( !p )
4000f164: 80 a2 20 00 cmp %o0, 0
4000f168: 02 bf ff df be 4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f16c: 01 00 00 00 nop
return 0;
info->triply_indirect = p;
4000f170: 10 bf ff 97 b 4000efcc <IMFS_memfile_get_block_pointer+0xcc>
4000f174: d0 26 20 60 st %o0, [ %i0 + 0x60 ]
4000f178 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4000f178: 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;
4000f17c: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
4000f180: a4 10 00 18 mov %i0, %l2
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
4000f184: c2 00 40 00 ld [ %g1 ], %g1
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
4000f188: a0 10 00 19 mov %i1, %l0
4000f18c: 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 ) {
4000f190: 80 a0 60 05 cmp %g1, 5
4000f194: 02 80 00 68 be 4000f334 <IMFS_memfile_read+0x1bc>
4000f198: a6 10 00 1b mov %i3, %l3
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
4000f19c: c4 06 20 50 ld [ %i0 + 0x50 ], %g2
4000f1a0: 86 10 20 00 clr %g3
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
4000f1a4: 82 10 00 1a mov %i2, %g1
if ( last_byte > the_jnode->info.file.size )
4000f1a8: c8 06 20 54 ld [ %i0 + 0x54 ], %g4
4000f1ac: 80 a0 c0 02 cmp %g3, %g2
4000f1b0: 04 80 00 42 ble 4000f2b8 <IMFS_memfile_read+0x140> <== ALWAYS TAKEN
4000f1b4: ba 07 00 1a add %i4, %i2, %i5
my_length = the_jnode->info.file.size - start;
4000f1b8: b8 21 00 01 sub %g4, %g1, %i4 <== NOT EXECUTED
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f1bc: 33 10 00 7f sethi %hi(0x4001fc00), %i1 <== NOT EXECUTED
4000f1c0: fa 06 61 28 ld [ %i1 + 0x128 ], %i5 ! 4001fd28 <imfs_memfile_bytes_per_block>
4000f1c4: 90 10 00 10 mov %l0, %o0
4000f1c8: b7 3f 60 1f sra %i5, 0x1f, %i3
4000f1cc: 96 10 00 1d mov %i5, %o3
4000f1d0: 94 10 00 1b mov %i3, %o2
4000f1d4: 40 00 2c 6b call 4001a380 <__moddi3>
4000f1d8: 92 10 00 11 mov %l1, %o1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f1dc: 90 10 00 10 mov %l0, %o0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f1e0: a8 10 00 09 mov %o1, %l4
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f1e4: 94 10 00 1b mov %i3, %o2
4000f1e8: 92 10 00 11 mov %l1, %o1
4000f1ec: 40 00 2b 7a call 40019fd4 <__divdi3>
4000f1f0: 96 10 00 1d mov %i5, %o3
if ( start_offset ) {
4000f1f4: 80 a5 20 00 cmp %l4, 0
4000f1f8: 02 80 00 37 be 4000f2d4 <IMFS_memfile_read+0x15c>
4000f1fc: b4 10 00 09 mov %o1, %i2
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
4000f200: ba 27 40 14 sub %i5, %l4, %i5
4000f204: 80 a7 00 1d cmp %i4, %i5
4000f208: 18 80 00 59 bgu 4000f36c <IMFS_memfile_read+0x1f4>
4000f20c: a0 10 00 1c mov %i4, %l0
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000f210: 90 10 00 12 mov %l2, %o0
4000f214: 92 10 00 1a mov %i2, %o1
4000f218: 94 10 20 00 clr %o2
4000f21c: 7f ff ff 39 call 4000ef00 <IMFS_memfile_get_block_pointer>
4000f220: b0 10 20 00 clr %i0
if ( !block_ptr )
4000f224: 80 a2 20 00 cmp %o0, 0
4000f228: 02 80 00 22 be 4000f2b0 <IMFS_memfile_read+0x138> <== NEVER TAKEN
4000f22c: 94 10 00 10 mov %l0, %o2
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
4000f230: d2 02 00 00 ld [ %o0 ], %o1
4000f234: 90 10 00 13 mov %l3, %o0
4000f238: 40 00 08 13 call 40011284 <memcpy>
4000f23c: 92 02 40 14 add %o1, %l4, %o1
4000f240: fa 06 61 28 ld [ %i1 + 0x128 ], %i5
dest += to_copy;
4000f244: b6 04 c0 10 add %l3, %l0, %i3
block++;
4000f248: b4 06 a0 01 inc %i2
my_length -= to_copy;
4000f24c: b8 27 00 10 sub %i4, %l0, %i4
copied += to_copy;
4000f250: b0 10 00 10 mov %l0, %i0
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000f254: 80 a7 00 1d cmp %i4, %i5
4000f258: 1a 80 00 0e bcc 4000f290 <IMFS_memfile_read+0x118>
4000f25c: 94 10 20 00 clr %o2
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
4000f260: 10 80 00 21 b 4000f2e4 <IMFS_memfile_read+0x16c>
4000f264: 80 a7 20 00 cmp %i4, 0
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4000f268: d2 00 40 00 ld [ %g1 ], %o1
4000f26c: 40 00 08 06 call 40011284 <memcpy>
4000f270: b8 27 00 1d sub %i4, %i5, %i4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000f274: c2 06 61 28 ld [ %i1 + 0x128 ], %g1
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
dest += to_copy;
4000f278: b6 06 c0 1d add %i3, %i5, %i3
block++;
4000f27c: b4 06 a0 01 inc %i2
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000f280: 80 a0 40 1c cmp %g1, %i4
4000f284: 18 80 00 17 bgu 4000f2e0 <IMFS_memfile_read+0x168>
4000f288: b0 06 00 1d add %i0, %i5, %i0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000f28c: 94 10 20 00 clr %o2
4000f290: 92 10 00 1a mov %i2, %o1
4000f294: 7f ff ff 1b call 4000ef00 <IMFS_memfile_get_block_pointer>
4000f298: 90 10 00 12 mov %l2, %o0
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
4000f29c: 94 10 00 1d mov %i5, %o2
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000f2a0: 82 10 00 08 mov %o0, %g1
if ( !block_ptr )
4000f2a4: 80 a0 60 00 cmp %g1, 0
4000f2a8: 12 bf ff f0 bne 4000f268 <IMFS_memfile_read+0xf0> <== ALWAYS TAKEN
4000f2ac: 90 10 00 1b mov %i3, %o0
}
IMFS_update_atime( the_jnode );
return copied;
}
4000f2b0: 81 c7 e0 08 ret <== NOT EXECUTED
4000f2b4: 81 e8 00 00 restore <== NOT EXECUTED
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
4000f2b8: 12 bf ff c2 bne 4000f1c0 <IMFS_memfile_read+0x48> <== NEVER TAKEN
4000f2bc: 33 10 00 7f sethi %hi(0x4001fc00), %i1
4000f2c0: 80 a7 40 04 cmp %i5, %g4
4000f2c4: 08 bf ff c0 bleu 4000f1c4 <IMFS_memfile_read+0x4c>
4000f2c8: fa 06 61 28 ld [ %i1 + 0x128 ], %i5
my_length = the_jnode->info.file.size - start;
4000f2cc: 10 bf ff bd b 4000f1c0 <IMFS_memfile_read+0x48>
4000f2d0: b8 21 00 01 sub %g4, %g1, %i4
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
4000f2d4: b6 10 00 13 mov %l3, %i3
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
4000f2d8: 10 bf ff df b 4000f254 <IMFS_memfile_read+0xdc>
4000f2dc: b0 10 20 00 clr %i0
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
4000f2e0: 80 a7 20 00 cmp %i4, 0
4000f2e4: 02 80 00 0e be 4000f31c <IMFS_memfile_read+0x1a4>
4000f2e8: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000f2ec: 90 10 00 12 mov %l2, %o0
4000f2f0: 92 10 00 1a mov %i2, %o1
4000f2f4: 7f ff ff 03 call 4000ef00 <IMFS_memfile_get_block_pointer>
4000f2f8: 94 10 20 00 clr %o2
if ( !block_ptr )
4000f2fc: 80 a2 20 00 cmp %o0, 0
4000f300: 02 bf ff ec be 4000f2b0 <IMFS_memfile_read+0x138> <== NEVER TAKEN
4000f304: 94 10 00 1c mov %i4, %o2
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
4000f308: d2 02 00 00 ld [ %o0 ], %o1
4000f30c: 90 10 00 1b mov %i3, %o0
4000f310: 40 00 07 dd call 40011284 <memcpy>
4000f314: b0 06 00 1c add %i0, %i4, %i0
copied += my_length;
}
IMFS_update_atime( the_jnode );
4000f318: 90 07 bf f8 add %fp, -8, %o0
4000f31c: 7f ff d3 e5 call 400042b0 <gettimeofday>
4000f320: 92 10 20 00 clr %o1
4000f324: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000f328: c2 24 a0 40 st %g1, [ %l2 + 0x40 ]
return copied;
}
4000f32c: 81 c7 e0 08 ret
4000f330: 81 e8 00 00 restore
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
4000f334: f4 1e 20 50 ldd [ %i0 + 0x50 ], %i2
4000f338: 82 10 20 00 clr %g1
4000f33c: 86 a6 c0 11 subcc %i3, %l1, %g3
4000f340: 84 66 80 19 subx %i2, %i1, %g2
4000f344: 80 a0 40 02 cmp %g1, %g2
4000f348: 04 80 00 0b ble 4000f374 <IMFS_memfile_read+0x1fc> <== ALWAYS TAKEN
4000f34c: d2 06 20 58 ld [ %i0 + 0x58 ], %o1
my_length = the_jnode->info.linearfile.size - start;
4000f350: b0 26 c0 11 sub %i3, %l1, %i0 <== NOT EXECUTED
memcpy(dest, &file_ptr[start], my_length);
4000f354: 92 02 40 11 add %o1, %l1, %o1
4000f358: 94 10 00 18 mov %i0, %o2
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
4000f35c: 40 00 07 ca call 40011284 <memcpy>
4000f360: 90 10 00 13 mov %l3, %o0
copied += my_length;
}
IMFS_update_atime( the_jnode );
4000f364: 10 bf ff ee b 4000f31c <IMFS_memfile_read+0x1a4>
4000f368: 90 07 bf f8 add %fp, -8, %o0
4000f36c: 10 bf ff a9 b 4000f210 <IMFS_memfile_read+0x98>
4000f370: a0 10 00 1d mov %i5, %l0
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
4000f374: 12 80 00 04 bne 4000f384 <IMFS_memfile_read+0x20c> <== NEVER TAKEN
4000f378: 80 a7 00 03 cmp %i4, %g3
4000f37c: 38 bf ff f6 bgu,a 4000f354 <IMFS_memfile_read+0x1dc> <== ALWAYS TAKEN
4000f380: 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;
4000f384: 10 bf ff f4 b 4000f354 <IMFS_memfile_read+0x1dc> <== NOT EXECUTED
4000f388: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
4000f49c <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
4000f49c: 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;
4000f4a0: 39 10 00 7f sethi %hi(0x4001fc00), %i4
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
4000f4a4: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
4000f4a8: f4 07 21 28 ld [ %i4 + 0x128 ], %i2
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
4000f4ac: 80 a0 60 00 cmp %g1, 0
4000f4b0: 02 80 00 05 be 4000f4c4 <IMFS_memfile_remove+0x28>
4000f4b4: b5 36 a0 02 srl %i2, 2, %i2
memfile_free_blocks_in_table( &info->indirect, to_free );
4000f4b8: 90 06 20 58 add %i0, 0x58, %o0
4000f4bc: 7f ff ff e2 call 4000f444 <memfile_free_blocks_in_table>
4000f4c0: 92 10 00 1a mov %i2, %o1
}
if ( info->doubly_indirect ) {
4000f4c4: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
4000f4c8: 80 a0 60 00 cmp %g1, 0
4000f4cc: 02 80 00 1b be 4000f538 <IMFS_memfile_remove+0x9c>
4000f4d0: c4 07 21 28 ld [ %i4 + 0x128 ], %g2
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4000f4d4: 85 30 a0 02 srl %g2, 2, %g2
4000f4d8: 80 a0 a0 00 cmp %g2, 0
4000f4dc: 02 80 00 14 be 4000f52c <IMFS_memfile_remove+0x90> <== NEVER TAKEN
4000f4e0: 90 10 20 00 clr %o0
4000f4e4: 37 10 00 7f sethi %hi(0x4001fc00), %i3
4000f4e8: ba 10 20 00 clr %i5
4000f4ec: 10 80 00 03 b 4000f4f8 <IMFS_memfile_remove+0x5c>
4000f4f0: b6 16 e1 28 or %i3, 0x128, %i3
4000f4f4: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
if ( info->doubly_indirect[i] ) {
4000f4f8: 91 2a 20 02 sll %o0, 2, %o0
4000f4fc: c4 00 40 08 ld [ %g1 + %o0 ], %g2
4000f500: 80 a0 a0 00 cmp %g2, 0
4000f504: 02 80 00 04 be 4000f514 <IMFS_memfile_remove+0x78> <== NEVER TAKEN
4000f508: 90 00 40 08 add %g1, %o0, %o0
memfile_free_blocks_in_table(
4000f50c: 7f ff ff ce call 4000f444 <memfile_free_blocks_in_table>
4000f510: 92 10 00 1a mov %i2, %o1
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4000f514: c2 06 c0 00 ld [ %i3 ], %g1
4000f518: ba 07 60 01 inc %i5
4000f51c: 83 30 60 02 srl %g1, 2, %g1
4000f520: 80 a7 40 01 cmp %i5, %g1
4000f524: 0a bf ff f4 bcs 4000f4f4 <IMFS_memfile_remove+0x58>
4000f528: 90 10 00 1d mov %i5, %o0
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
(block_p **)&info->doubly_indirect[i], to_free );
}
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
4000f52c: 90 06 20 5c add %i0, 0x5c, %o0
4000f530: 7f ff ff c5 call 4000f444 <memfile_free_blocks_in_table>
4000f534: 92 10 00 1a mov %i2, %o1
}
if ( info->triply_indirect ) {
4000f538: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
4000f53c: 80 a2 20 00 cmp %o0, 0
4000f540: 02 80 00 33 be 4000f60c <IMFS_memfile_remove+0x170>
4000f544: c4 07 21 28 ld [ %i4 + 0x128 ], %g2
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4000f548: 85 30 a0 02 srl %g2, 2, %g2
4000f54c: 80 a0 a0 00 cmp %g2, 0
4000f550: 22 80 00 2d be,a 4000f604 <IMFS_memfile_remove+0x168> <== NEVER TAKEN
4000f554: 90 06 20 60 add %i0, 0x60, %o0 <== NOT EXECUTED
p = (block_p *) info->triply_indirect[i];
4000f558: f8 02 00 00 ld [ %o0 ], %i4
if ( !p ) /* ensure we have a valid pointer */
4000f55c: 80 a7 20 00 cmp %i4, 0
4000f560: 22 80 00 29 be,a 4000f604 <IMFS_memfile_remove+0x168> <== NEVER TAKEN
4000f564: 90 06 20 60 add %i0, 0x60, %o0 <== NOT EXECUTED
4000f568: 37 10 00 7f sethi %hi(0x4001fc00), %i3
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
4000f56c: a0 10 20 00 clr %l0
if ( !p ) /* ensure we have a valid pointer */
4000f570: b2 10 20 00 clr %i1
4000f574: b6 16 e1 28 or %i3, 0x128, %i3
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
4000f578: 80 a0 a0 00 cmp %g2, 0
4000f57c: 22 80 00 13 be,a 4000f5c8 <IMFS_memfile_remove+0x12c> <== NEVER TAKEN
4000f580: 90 02 00 10 add %o0, %l0, %o0 <== NOT EXECUTED
4000f584: 90 10 20 00 clr %o0
4000f588: ba 10 20 00 clr %i5
if ( p[j] ) {
4000f58c: 91 2a 20 02 sll %o0, 2, %o0
4000f590: c2 07 00 08 ld [ %i4 + %o0 ], %g1
4000f594: 80 a0 60 00 cmp %g1, 0
4000f598: 02 80 00 04 be 4000f5a8 <IMFS_memfile_remove+0x10c> <== NEVER TAKEN
4000f59c: 90 07 00 08 add %i4, %o0, %o0
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
4000f5a0: 7f ff ff a9 call 4000f444 <memfile_free_blocks_in_table>
4000f5a4: 92 10 00 1a mov %i2, %o1
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
4000f5a8: c2 06 c0 00 ld [ %i3 ], %g1
4000f5ac: ba 07 60 01 inc %i5
4000f5b0: 83 30 60 02 srl %g1, 2, %g1
4000f5b4: 80 a7 40 01 cmp %i5, %g1
4000f5b8: 0a bf ff f5 bcs 4000f58c <IMFS_memfile_remove+0xf0>
4000f5bc: 90 10 00 1d mov %i5, %o0
4000f5c0: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
4000f5c4: 90 02 00 10 add %o0, %l0, %o0
4000f5c8: 7f ff ff 9f call 4000f444 <memfile_free_blocks_in_table>
4000f5cc: 92 10 00 1a mov %i2, %o1
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
4000f5d0: c4 06 c0 00 ld [ %i3 ], %g2
4000f5d4: b2 06 60 01 inc %i1
4000f5d8: 85 30 a0 02 srl %g2, 2, %g2
4000f5dc: 80 a6 40 02 cmp %i1, %g2
4000f5e0: 1a 80 00 09 bcc 4000f604 <IMFS_memfile_remove+0x168>
4000f5e4: 90 06 20 60 add %i0, 0x60, %o0
p = (block_p *) info->triply_indirect[i];
4000f5e8: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
* a significant difference in the performance of this routine.
*
* Regardless until the IMFS implementation is proven, it
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
4000f5ec: a1 2e 60 02 sll %i1, 2, %l0
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
4000f5f0: f8 02 00 10 ld [ %o0 + %l0 ], %i4
if ( !p ) /* ensure we have a valid pointer */
4000f5f4: 80 a7 20 00 cmp %i4, 0
4000f5f8: 12 bf ff e1 bne 4000f57c <IMFS_memfile_remove+0xe0> <== ALWAYS TAKEN
4000f5fc: 80 a0 a0 00 cmp %g2, 0
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
4000f600: 90 06 20 60 add %i0, 0x60, %o0 <== NOT EXECUTED
4000f604: 7f ff ff 90 call 4000f444 <memfile_free_blocks_in_table>
4000f608: 92 10 00 1a mov %i2, %o1
(block_p **)&info->triply_indirect, to_free );
}
return the_jnode;
}
4000f60c: 81 c7 e0 08 ret
4000f610: 81 e8 00 00 restore
4000f614 <IMFS_memfile_remove_block>:
*/
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
4000f614: 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 );
4000f618: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000f61c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000f620: 7f ff fe 38 call 4000ef00 <IMFS_memfile_get_block_pointer><== NOT EXECUTED
4000f624: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000f628: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
4000f62c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
*block_ptr = 0;
memfile_free_block( ptr );
return 1;
}
4000f630: 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 );
4000f634: 7f ff ff 7b call 4000f420 <memfile_free_block> <== NOT EXECUTED
4000f638: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
return 1;
}
4000f63c: 81 c7 e0 08 ret <== NOT EXECUTED
4000f640: 81 e8 00 00 restore <== NOT EXECUTED
4000f808 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
4000f808: 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 ) {
4000f80c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
4000f810: 84 10 20 00 clr %g2
/*
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
4000f814: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > the_jnode->info.file.size ) {
4000f818: 80 a0 80 01 cmp %g2, %g1
4000f81c: 14 80 00 5e bg 4000f994 <IMFS_memfile_write+0x18c> <== NEVER TAKEN
4000f820: c6 06 20 54 ld [ %i0 + 0x54 ], %g3
4000f824: 80 a0 80 01 cmp %g2, %g1
4000f828: 02 80 00 59 be 4000f98c <IMFS_memfile_write+0x184> <== ALWAYS TAKEN
4000f82c: 80 a2 c0 03 cmp %o3, %g3
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f830: 21 10 00 7f sethi %hi(0x4001fc00), %l0 <== NOT EXECUTED
4000f834: fa 04 21 28 ld [ %l0 + 0x128 ], %i5 ! 4001fd28 <imfs_memfile_bytes_per_block>
4000f838: 90 10 00 19 mov %i1, %o0
4000f83c: a3 3f 60 1f sra %i5, 0x1f, %l1
4000f840: 92 10 00 1a mov %i2, %o1
4000f844: 94 10 00 11 mov %l1, %o2
4000f848: 40 00 2a ce call 4001a380 <__moddi3>
4000f84c: 96 10 00 1d mov %i5, %o3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f850: 90 10 00 19 mov %i1, %o0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f854: a4 10 00 09 mov %o1, %l2
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f858: 94 10 00 11 mov %l1, %o2
4000f85c: 92 10 00 1a mov %i2, %o1
4000f860: 40 00 29 dd call 40019fd4 <__divdi3>
4000f864: 96 10 00 1d mov %i5, %o3
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
if ( status )
return status;
}
copied = 0;
4000f868: b2 10 20 00 clr %i1
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
4000f86c: 80 a4 a0 00 cmp %l2, 0
4000f870: 02 80 00 16 be 4000f8c8 <IMFS_memfile_write+0xc0>
4000f874: b4 10 00 09 mov %o1, %i2
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
4000f878: b2 27 40 12 sub %i5, %l2, %i1
4000f87c: 80 a6 40 1c cmp %i1, %i4
4000f880: 38 80 00 02 bgu,a 4000f888 <IMFS_memfile_write+0x80>
4000f884: b2 10 00 1c mov %i4, %i1
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000f888: 90 10 00 18 mov %i0, %o0
4000f88c: 92 10 00 1a mov %i2, %o1
4000f890: 7f ff fd 9c call 4000ef00 <IMFS_memfile_get_block_pointer>
4000f894: 94 10 20 00 clr %o2
if ( !block_ptr )
4000f898: 80 a2 20 00 cmp %o0, 0
4000f89c: 02 80 00 22 be 4000f924 <IMFS_memfile_write+0x11c> <== NEVER TAKEN
4000f8a0: 82 10 20 00 clr %g1
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
4000f8a4: d0 02 00 00 ld [ %o0 ], %o0
4000f8a8: 92 10 00 1b mov %i3, %o1
4000f8ac: 90 02 00 12 add %o0, %l2, %o0
4000f8b0: 40 00 06 75 call 40011284 <memcpy>
4000f8b4: 94 10 00 19 mov %i1, %o2
4000f8b8: fa 04 21 28 ld [ %l0 + 0x128 ], %i5
src += to_copy;
4000f8bc: b6 06 c0 19 add %i3, %i1, %i3
block++;
4000f8c0: b4 06 a0 01 inc %i2
my_length -= to_copy;
4000f8c4: b8 27 00 19 sub %i4, %i1, %i4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000f8c8: 80 a7 00 1d cmp %i4, %i5
4000f8cc: 1a 80 00 0e bcc 4000f904 <IMFS_memfile_write+0xfc>
4000f8d0: 92 10 00 1a mov %i2, %o1
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
4000f8d4: 10 80 00 17 b 4000f930 <IMFS_memfile_write+0x128>
4000f8d8: 80 a7 20 00 cmp %i4, 0
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
4000f8dc: d0 02 00 00 ld [ %o0 ], %o0
4000f8e0: 40 00 06 69 call 40011284 <memcpy>
4000f8e4: b8 27 00 1d sub %i4, %i5, %i4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000f8e8: c2 04 21 28 ld [ %l0 + 0x128 ], %g1
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
src += to_copy;
4000f8ec: b6 06 c0 1d add %i3, %i5, %i3
block++;
4000f8f0: b4 06 a0 01 inc %i2
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000f8f4: 80 a0 40 1c cmp %g1, %i4
4000f8f8: 18 80 00 0d bgu 4000f92c <IMFS_memfile_write+0x124>
4000f8fc: b2 06 40 1d add %i1, %i5, %i1
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000f900: 92 10 00 1a mov %i2, %o1
4000f904: 94 10 20 00 clr %o2
4000f908: 7f ff fd 7e call 4000ef00 <IMFS_memfile_get_block_pointer>
4000f90c: 90 10 00 18 mov %i0, %o0
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
4000f910: 92 10 00 1b mov %i3, %o1
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
4000f914: 80 a2 20 00 cmp %o0, 0
4000f918: 12 bf ff f1 bne 4000f8dc <IMFS_memfile_write+0xd4> <== ALWAYS TAKEN
4000f91c: 94 10 00 1d mov %i5, %o2
4000f920: 82 10 00 19 mov %i1, %g1 <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
4000f924: 81 c7 e0 08 ret <== NOT EXECUTED
4000f928: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
4000f92c: 80 a7 20 00 cmp %i4, 0
4000f930: 02 80 00 0f be 4000f96c <IMFS_memfile_write+0x164>
4000f934: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000f938: 90 10 00 18 mov %i0, %o0
4000f93c: 92 10 00 1a mov %i2, %o1
4000f940: 7f ff fd 70 call 4000ef00 <IMFS_memfile_get_block_pointer>
4000f944: 94 10 20 00 clr %o2
if ( !block_ptr )
4000f948: 80 a2 20 00 cmp %o0, 0
4000f94c: 02 bf ff f6 be 4000f924 <IMFS_memfile_write+0x11c> <== NEVER TAKEN
4000f950: 82 10 00 19 mov %i1, %g1
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
4000f954: d0 02 00 00 ld [ %o0 ], %o0
4000f958: 92 10 00 1b mov %i3, %o1
4000f95c: 94 10 00 1c mov %i4, %o2
4000f960: 40 00 06 49 call 40011284 <memcpy>
4000f964: b2 06 40 1c add %i1, %i4, %i1
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
4000f968: 90 07 bf f8 add %fp, -8, %o0
4000f96c: 7f ff d2 51 call 400042b0 <gettimeofday>
4000f970: 92 10 20 00 clr %o1
4000f974: c4 07 bf f8 ld [ %fp + -8 ], %g2
return copied;
4000f978: 82 10 00 19 mov %i1, %g1
memcpy( &(*block_ptr)[ 0 ], src, my_length );
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
4000f97c: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
4000f980: c4 26 20 48 st %g2, [ %i0 + 0x48 ]
return copied;
}
4000f984: 81 c7 e0 08 ret
4000f988: 91 e8 00 01 restore %g0, %g1, %o0
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
4000f98c: 08 bf ff aa bleu 4000f834 <IMFS_memfile_write+0x2c>
4000f990: 21 10 00 7f sethi %hi(0x4001fc00), %l0
bool zero_fill = start > the_jnode->info.file.size;
4000f994: 80 a6 40 01 cmp %i1, %g1
4000f998: 04 80 00 0b ble 4000f9c4 <IMFS_memfile_write+0x1bc> <== ALWAYS TAKEN
4000f99c: 92 10 20 01 mov 1, %o1
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
4000f9a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000f9a4: 92 0a 60 01 and %o1, 1, %o1
4000f9a8: 7f ff ff 27 call 4000f644 <IMFS_memfile_extend>
4000f9ac: 94 10 20 00 clr %o2
if ( status )
4000f9b0: 82 92 20 00 orcc %o0, 0, %g1
4000f9b4: 02 bf ff a0 be 4000f834 <IMFS_memfile_write+0x2c>
4000f9b8: 21 10 00 7f sethi %hi(0x4001fc00), %l0
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
4000f9bc: 81 c7 e0 08 ret
4000f9c0: 91 e8 00 01 restore %g0, %g1, %o0
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
bool zero_fill = start > the_jnode->info.file.size;
4000f9c4: 02 80 00 0b be 4000f9f0 <IMFS_memfile_write+0x1e8> <== ALWAYS TAKEN
4000f9c8: 80 a6 80 03 cmp %i2, %g3
4000f9cc: 92 10 20 00 clr %o1 <== NOT EXECUTED
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
4000f9d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000f9d4: 92 0a 60 01 and %o1, 1, %o1
4000f9d8: 7f ff ff 1b call 4000f644 <IMFS_memfile_extend>
4000f9dc: 94 10 20 00 clr %o2
if ( status )
4000f9e0: 82 92 20 00 orcc %o0, 0, %g1
4000f9e4: 02 bf ff 94 be 4000f834 <IMFS_memfile_write+0x2c>
4000f9e8: 21 10 00 7f sethi %hi(0x4001fc00), %l0
4000f9ec: 30 bf ff f4 b,a 4000f9bc <IMFS_memfile_write+0x1b4>
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
bool zero_fill = start > the_jnode->info.file.size;
4000f9f0: 18 bf ff ed bgu 4000f9a4 <IMFS_memfile_write+0x19c>
4000f9f4: 90 10 00 18 mov %i0, %o0
4000f9f8: 10 bf ff f7 b 4000f9d4 <IMFS_memfile_write+0x1cc>
4000f9fc: 92 10 20 00 clr %o1
400039e4 <IMFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
400039e4: 9d e3 bf 80 save %sp, -128, %sp
dev_t dev,
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
400039e8: 03 00 00 3c sethi %hi(0xf000), %g1
400039ec: 05 00 00 10 sethi %hi(0x4000), %g2
400039f0: 82 0e c0 01 and %i3, %g1, %g1
400039f4: 80 a0 40 02 cmp %g1, %g2
400039f8: 02 80 00 2b be 40003aa4 <IMFS_mknod+0xc0>
400039fc: 05 00 00 20 sethi %hi(0x8000), %g2
*type = IMFS_DIRECTORY;
} else if ( S_ISREG( mode ) ) {
40003a00: 80 a0 40 02 cmp %g1, %g2
40003a04: 02 80 00 2a be 40003aac <IMFS_mknod+0xc8>
40003a08: 09 00 00 2c sethi %hi(0xb000), %g4
*type = IMFS_MEMORY_FILE;
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
40003a0c: 05 00 00 08 sethi %hi(0x2000), %g2
40003a10: 88 0e c0 04 and %i3, %g4, %g4
40003a14: 80 a1 00 02 cmp %g4, %g2
40003a18: 02 80 00 07 be 40003a34 <IMFS_mknod+0x50>
40003a1c: 05 00 00 04 sethi %hi(0x1000), %g2
rtems_filesystem_split_dev_t(
dev,
info->device.major,
info->device.minor
);
} else if (S_ISFIFO( mode )) {
40003a20: 80 a0 40 02 cmp %g1, %g2
40003a24: 22 80 00 06 be,a 40003a3c <IMFS_mknod+0x58> <== ALWAYS TAKEN
40003a28: 86 10 20 06 mov 6, %g3
size_t namelen,
mode_t mode,
const IMFS_types_union *info
)
{
const IMFS_fs_info_t *fs_info =
40003a2c: 10 80 00 05 b 40003a40 <IMFS_mknod+0x5c> <== NOT EXECUTED
40003a30: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
*type = IMFS_DIRECTORY;
} else if ( S_ISREG( mode ) ) {
*type = IMFS_MEMORY_FILE;
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
*type = IMFS_DEVICE;
rtems_filesystem_split_dev_t(
40003a34: 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;
40003a38: 86 10 20 01 mov 1, %g3
40003a3c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
40003a40: 82 00 e0 02 add %g3, 2, %g1
40003a44: c4 00 a0 08 ld [ %g2 + 8 ], %g2
40003a48: 83 28 60 02 sll %g1, 2, %g1
40003a4c: d2 00 80 01 ld [ %g2 + %g1 ], %o1
40003a50: 90 10 00 18 mov %i0, %o0
40003a54: 94 10 00 19 mov %i1, %o2
40003a58: 96 10 00 1a mov %i2, %o3
40003a5c: 98 10 00 1b mov %i3, %o4
40003a60: 40 00 23 57 call 4000c7bc <IMFS_create_node_with_control>
40003a64: 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 ) {
40003a68: 80 a2 20 00 cmp %o0, 0
40003a6c: 02 80 00 12 be 40003ab4 <IMFS_mknod+0xd0>
40003a70: 92 10 20 00 clr %o1
IMFS_jnode_t *parent = parentloc->node_access;
40003a74: fa 06 20 08 ld [ %i0 + 8 ], %i5
IMFS_update_ctime( parent );
40003a78: 40 00 02 0e call 400042b0 <gettimeofday>
40003a7c: 90 07 bf e0 add %fp, -32, %o0
40003a80: c2 07 bf e0 ld [ %fp + -32 ], %g1
IMFS_update_mtime( parent );
40003a84: 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 );
40003a88: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
40003a8c: 40 00 02 09 call 400042b0 <gettimeofday>
40003a90: 92 10 20 00 clr %o1
40003a94: c2 07 bf e0 ld [ %fp + -32 ], %g1
40003a98: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
size_t namelen,
mode_t mode,
dev_t dev
)
{
int rv = 0;
40003a9c: 81 c7 e0 08 ret
40003aa0: 91 e8 20 00 restore %g0, 0, %o0
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
*type = IMFS_DIRECTORY;
40003aa4: 10 bf ff e6 b 40003a3c <IMFS_mknod+0x58>
40003aa8: 86 10 20 00 clr %g3
} else if ( S_ISREG( mode ) ) {
*type = IMFS_MEMORY_FILE;
40003aac: 10 bf ff e4 b 40003a3c <IMFS_mknod+0x58>
40003ab0: 86 10 20 04 mov 4, %g3
} else {
rv = -1;
}
return rv;
}
40003ab4: 81 c7 e0 08 ret
40003ab8: 91 e8 3f ff restore %g0, -1, %o0
40003abc <IMFS_mount>:
#endif
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40003abc: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40003ac0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40003ac4: 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;
40003ac8: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
40003acc: c4 00 80 00 ld [ %g2 ], %g2
40003ad0: 80 a0 a0 00 cmp %g2, 0
40003ad4: 12 80 00 0f bne 40003b10 <IMFS_mount+0x54>
40003ad8: 01 00 00 00 nop
if ( node->info.directory.mt_fs == NULL ) {
40003adc: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
40003ae0: 80 a0 a0 00 cmp %g2, 0
40003ae4: 12 80 00 05 bne 40003af8 <IMFS_mount+0x3c> <== NEVER TAKEN
40003ae8: 01 00 00 00 nop
node->info.directory.mt_fs = mt_entry;
40003aec: 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;
40003af0: 81 c7 e0 08 ret
40003af4: 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;
40003af8: 40 00 33 92 call 40010940 <__errno> <== NOT EXECUTED
40003afc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40003b00: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
40003b04: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40003b08: 81 c7 e0 08 ret <== NOT EXECUTED
40003b0c: 81 e8 00 00 restore <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40003b10: 40 00 33 8c call 40010940 <__errno>
40003b14: b0 10 3f ff mov -1, %i0
40003b18: 82 10 20 14 mov 0x14, %g1
40003b1c: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
40003b20: 81 c7 e0 08 ret
40003b24: 81 e8 00 00 restore
4000cc4c <IMFS_node_remove_directory>:
}
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node
)
{
4000cc4c: 9d e3 bf a0 save %sp, -96, %sp
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
4000cc50: 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 );
4000cc54: 82 06 20 54 add %i0, 0x54, %g1
4000cc58: 80 a0 80 01 cmp %g2, %g1
4000cc5c: 12 80 00 08 bne 4000cc7c <IMFS_node_remove_directory+0x30>
4000cc60: 01 00 00 00 nop
errno = ENOTEMPTY;
node = NULL;
} else if ( IMFS_is_mount_point( node ) ) {
4000cc64: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
4000cc68: 80 a0 60 00 cmp %g1, 0
4000cc6c: 12 80 00 0a bne 4000cc94 <IMFS_node_remove_directory+0x48><== NEVER TAKEN
4000cc70: 01 00 00 00 nop
errno = EBUSY;
node = NULL;
}
return node;
}
4000cc74: 81 c7 e0 08 ret
4000cc78: 81 e8 00 00 restore
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node
)
{
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
errno = ENOTEMPTY;
4000cc7c: 40 00 0f 31 call 40010940 <__errno>
4000cc80: b0 10 20 00 clr %i0
4000cc84: 82 10 20 5a mov 0x5a, %g1
4000cc88: c2 22 00 00 st %g1, [ %o0 ]
4000cc8c: 81 c7 e0 08 ret
4000cc90: 81 e8 00 00 restore
node = NULL;
} else if ( IMFS_is_mount_point( node ) ) {
errno = EBUSY;
4000cc94: 40 00 0f 2b call 40010940 <__errno> <== NOT EXECUTED
4000cc98: b0 10 20 00 clr %i0 <== NOT EXECUTED
4000cc9c: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
4000cca0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
node = NULL;
}
return node;
}
4000cca4: 81 c7 e0 08 ret <== NOT EXECUTED
4000cca8: 81 e8 00 00 restore <== NOT EXECUTED
40003b28 <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;
40003b28: 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;
40003b2c: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
40003b30: 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 ) {
40003b34: 80 a0 60 02 cmp %g1, 2
40003b38: 02 80 00 06 be 40003b50 <IMFS_node_type+0x28>
40003b3c: 80 a0 60 05 cmp %g1, 5
40003b40: 02 80 00 08 be 40003b60 <IMFS_node_type+0x38> <== NEVER TAKEN
40003b44: 90 10 20 04 mov 4, %o0
type = imfs_type;
break;
}
return type;
}
40003b48: 81 c3 e0 08 retl
40003b4c: 90 10 00 01 mov %g1, %o0
40003b50: c2 00 a0 50 ld [ %g2 + 0x50 ], %g1
40003b54: c2 00 60 4c ld [ %g1 + 0x4c ], %g1
rtems_filesystem_node_types_t type;
switch ( imfs_type ) {
case IMFS_HARD_LINK:
type = IMFS_type( node->info.hard_link.link_node );
break;
40003b58: 81 c3 e0 08 retl
40003b5c: d0 00 40 00 ld [ %g1 ], %o0
40003b60: 81 c3 e0 08 retl <== NOT EXECUTED
40003b68 <IMFS_readlink>:
node = loc->node_access;
IMFS_assert( node->control->imfs_type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
40003b68: 80 a2 a0 00 cmp %o2, 0
40003b6c: 02 80 00 16 be 40003bc4 <IMFS_readlink+0x5c> <== NEVER TAKEN
40003b70: c8 02 20 08 ld [ %o0 + 8 ], %g4
40003b74: c2 01 20 50 ld [ %g4 + 0x50 ], %g1
40003b78: c4 48 40 00 ldsb [ %g1 ], %g2
40003b7c: 80 a0 a0 00 cmp %g2, 0
40003b80: 02 80 00 11 be 40003bc4 <IMFS_readlink+0x5c> <== NEVER TAKEN
40003b84: c2 08 40 00 ldub [ %g1 ], %g1
40003b88: 84 10 20 00 clr %g2
40003b8c: 10 80 00 07 b 40003ba8 <IMFS_readlink+0x40>
40003b90: 90 10 20 00 clr %o0
40003b94: c2 01 20 50 ld [ %g4 + 0x50 ], %g1
40003b98: c6 48 40 08 ldsb [ %g1 + %o0 ], %g3
40003b9c: 80 a0 e0 00 cmp %g3, 0
40003ba0: 02 80 00 07 be 40003bbc <IMFS_readlink+0x54>
40003ba4: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
buf[i] = node->info.sym_link.name[i];
40003ba8: c2 2a 40 02 stb %g1, [ %o1 + %g2 ]
node = loc->node_access;
IMFS_assert( node->control->imfs_type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
40003bac: 90 02 20 01 inc %o0
40003bb0: 80 a2 00 0a cmp %o0, %o2
40003bb4: 12 bf ff f8 bne 40003b94 <IMFS_readlink+0x2c>
40003bb8: 84 10 00 08 mov %o0, %g2
buf[i] = node->info.sym_link.name[i];
return i;
}
40003bbc: 81 c3 e0 08 retl
40003bc0: 01 00 00 00 nop
40003bc4: 81 c3 e0 08 retl <== NOT EXECUTED
40003bc8: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
40003bcc <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
40003bcc: 9d e3 bf 98 save %sp, -104, %sp
int rv = 0;
IMFS_jnode_t *node = oldloc->node_access;
40003bd0: 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 ) {
40003bd4: c2 07 60 08 ld [ %i5 + 8 ], %g1
40003bd8: 80 a0 60 00 cmp %g1, 0
40003bdc: 02 80 00 22 be 40003c64 <IMFS_rename+0x98> <== NEVER TAKEN
40003be0: f4 06 a0 08 ld [ %i2 + 8 ], %i2
if ( namelen < IMFS_NAME_MAX ) {
40003be4: 80 a7 20 1f cmp %i4, 0x1f
40003be8: 18 80 00 19 bgu 40003c4c <IMFS_rename+0x80> <== NEVER TAKEN
40003bec: 94 10 00 1c mov %i4, %o2
memcpy( node->name, name, namelen );
40003bf0: 92 10 00 1b mov %i3, %o1
40003bf4: 40 00 35 a4 call 40011284 <memcpy>
40003bf8: 90 07 60 0c add %i5, 0xc, %o0
node->name [namelen] = '\0';
40003bfc: b8 07 40 1c add %i5, %i4, %i4
40003c00: c0 2f 20 0c clrb [ %i4 + 0xc ]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
40003c04: c2 07 60 04 ld [ %i5 + 4 ], %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40003c08: c4 07 40 00 ld [ %i5 ], %g2
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
40003c0c: 86 06 a0 54 add %i2, 0x54, %g3
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
40003c10: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40003c14: 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;
40003c18: c2 06 a0 58 ld [ %i2 + 0x58 ], %g1
static inline void IMFS_add_to_directory(
IMFS_jnode_t *dir,
IMFS_jnode_t *node
)
{
node->Parent = dir;
40003c1c: f4 27 60 08 st %i2, [ %i5 + 8 ]
the_node->next = tail;
40003c20: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
40003c24: fa 26 a0 58 st %i5, [ %i2 + 0x58 ]
old_last->next = the_node;
40003c28: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
40003c2c: c2 27 60 04 st %g1, [ %i5 + 4 ]
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
40003c30: 90 07 bf f8 add %fp, -8, %o0
40003c34: 40 00 01 9f call 400042b0 <gettimeofday>
40003c38: 92 10 20 00 clr %o1
40003c3c: c2 07 bf f8 ld [ %fp + -8 ], %g1
40003c40: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
int rv = 0;
40003c44: 81 c7 e0 08 ret
40003c48: 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;
40003c4c: 40 00 33 3d call 40010940 <__errno> <== NOT EXECUTED
40003c50: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40003c54: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
40003c58: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40003c5c: 81 c7 e0 08 ret <== NOT EXECUTED
40003c60: 81 e8 00 00 restore <== NOT EXECUTED
rv = -1;
}
} else {
errno = EINVAL;
40003c64: 40 00 33 37 call 40010940 <__errno> <== NOT EXECUTED
40003c68: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40003c6c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40003c70: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40003c74: 81 c7 e0 08 ret <== NOT EXECUTED
40003c78: 81 e8 00 00 restore <== NOT EXECUTED
40003d68 <IMFS_unmount>:
#endif
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40003d68: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40003d6c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40003d70: 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;
40003d74: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
40003d78: c4 00 80 00 ld [ %g2 ], %g2
40003d7c: 80 a0 a0 00 cmp %g2, 0
40003d80: 12 80 00 0f bne 40003dbc <IMFS_unmount+0x54> <== NEVER TAKEN
40003d84: 01 00 00 00 nop
if ( node->info.directory.mt_fs == mt_entry ) {
40003d88: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
40003d8c: 80 a0 80 18 cmp %g2, %i0
40003d90: 12 80 00 05 bne 40003da4 <IMFS_unmount+0x3c> <== NEVER TAKEN
40003d94: 01 00 00 00 nop
node->info.directory.mt_fs = NULL;
40003d98: c0 20 60 5c clr [ %g1 + 0x5c ]
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
40003d9c: 81 c7 e0 08 ret
40003da0: 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;
40003da4: 40 00 32 e7 call 40010940 <__errno> <== NOT EXECUTED
40003da8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40003dac: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40003db0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40003db4: 81 c7 e0 08 ret <== NOT EXECUTED
40003db8: 81 e8 00 00 restore <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40003dbc: 40 00 32 e1 call 40010940 <__errno> <== NOT EXECUTED
40003dc0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40003dc4: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
40003dc8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40003dcc: 81 c7 e0 08 ret <== NOT EXECUTED
40003dd0: 81 e8 00 00 restore <== NOT EXECUTED
400044b0 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
400044b0: 9d e3 bf a0 save %sp, -96, %sp
Heap_Control *heap = RTEMS_Malloc_Heap;
if ( !rtems_configuration_get_unified_work_area() ) {
400044b4: 03 10 00 75 sethi %hi(0x4001d400), %g1
400044b8: c2 08 62 49 ldub [ %g1 + 0x249 ], %g1 ! 4001d649 <Configuration+0x31>
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Control *heap = RTEMS_Malloc_Heap;
400044bc: 05 10 00 7d sethi %hi(0x4001f400), %g2
if ( !rtems_configuration_get_unified_work_area() ) {
400044c0: 80 a0 60 00 cmp %g1, 0
400044c4: 12 80 00 17 bne 40004520 <RTEMS_Malloc_Initialize+0x70>
400044c8: f6 00 a1 60 ld [ %g2 + 0x160 ], %i3
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
size_t i;
for (i = 0; i < area_count; ++i) {
400044cc: 80 a6 60 00 cmp %i1, 0
400044d0: 02 80 00 23 be 4000455c <RTEMS_Malloc_Initialize+0xac>
400044d4: 21 10 00 26 sethi %hi(0x40009800), %l0
400044d8: ba 10 20 00 clr %i5
400044dc: a0 14 20 98 or %l0, 0x98, %l0
400044e0: b8 10 00 10 mov %l0, %i4
const Heap_Area *area = &areas [i];
uintptr_t space_available = (*init_or_extend)(
400044e4: d2 06 00 00 ld [ %i0 ], %o1
400044e8: d4 06 20 04 ld [ %i0 + 4 ], %o2
400044ec: 90 10 00 1b mov %i3, %o0
400044f0: 9f c7 00 00 call %i4
400044f4: 96 10 20 08 mov 8, %o3
area->begin,
area->size,
page_size
);
if ( space_available > 0 ) {
400044f8: 80 a2 20 00 cmp %o0, 0
400044fc: 32 80 00 02 bne,a 40004504 <RTEMS_Malloc_Initialize+0x54><== ALWAYS TAKEN
40004500: b8 10 00 1a mov %i2, %i4
if ( !rtems_configuration_get_unified_work_area() ) {
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
size_t i;
for (i = 0; i < area_count; ++i) {
40004504: ba 07 60 01 inc %i5
40004508: 80 a7 40 19 cmp %i5, %i1
4000450c: 12 bf ff f6 bne 400044e4 <RTEMS_Malloc_Initialize+0x34> <== NEVER TAKEN
40004510: b0 06 20 08 add %i0, 8, %i0
if ( space_available > 0 ) {
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
40004514: 80 a7 00 10 cmp %i4, %l0
40004518: 02 80 00 12 be 40004560 <RTEMS_Malloc_Initialize+0xb0> <== NEVER TAKEN
4000451c: 90 10 20 00 clr %o0
}
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
40004520: 03 10 00 7f sethi %hi(0x4001fc00), %g1
40004524: c2 00 60 90 ld [ %g1 + 0x90 ], %g1 ! 4001fc90 <rtems_malloc_statistics_helpers>
40004528: 80 a0 60 00 cmp %g1, 0
4000452c: 02 80 00 05 be 40004540 <RTEMS_Malloc_Initialize+0x90>
40004530: 3b 10 00 80 sethi %hi(0x40020000), %i5
(*rtems_malloc_statistics_helpers->initialize)();
40004534: c2 00 40 00 ld [ %g1 ], %g1
40004538: 9f c0 40 00 call %g1
4000453c: 01 00 00 00 nop
}
MSBUMP( space_available, _Protected_heap_Get_size( heap ) );
40004540: f8 07 61 30 ld [ %i5 + 0x130 ], %i4
40004544: 40 00 17 e3 call 4000a4d0 <_Protected_heap_Get_size>
40004548: 90 10 00 1b mov %i3, %o0
4000454c: 90 02 00 1c add %o0, %i4, %o0
40004550: d0 27 61 30 st %o0, [ %i5 + 0x130 ]
40004554: 81 c7 e0 08 ret
40004558: 81 e8 00 00 restore
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
_Internal_error_Occurred(
4000455c: 90 10 20 00 clr %o0
40004560: 92 10 20 01 mov 1, %o1
40004564: 40 00 15 6a call 40009b0c <_Internal_error_Occurred>
40004568: 94 10 20 17 mov 0x17, %o2
4002621c <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
4002621c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
40026220: 80 a6 3f ff cmp %i0, -1 <== NOT EXECUTED
40026224: 02 80 00 56 be 4002637c <Stack_check_Dump_threads_usage+0x160><== NOT EXECUTED
40026228: ba 06 20 b4 add %i0, 0xb4, %i5 <== NOT EXECUTED
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
4002622c: e2 06 21 38 ld [ %i0 + 0x138 ], %l1 <== NOT EXECUTED
40026230: f8 06 20 b8 ld [ %i0 + 0xb8 ], %i4 <== NOT EXECUTED
}
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
40026234: f4 07 40 00 ld [ %i5 ], %i2 <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
40026238: 82 07 20 20 add %i4, 0x20, %g1 <== NOT EXECUTED
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
4002623c: b4 06 bf f0 add %i2, -16, %i2 <== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
40026240: 86 0e bf fc and %i2, -4, %g3 <== NOT EXECUTED
40026244: 86 00 40 03 add %g1, %g3, %g3 <== NOT EXECUTED
40026248: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
4002624c: 1a 80 00 10 bcc 4002628c <Stack_check_Dump_threads_usage+0x70><== NOT EXECUTED
40026250: 05 29 69 69 sethi %hi(0xa5a5a400), %g2 <== NOT EXECUTED
if (*base != U32_PATTERN)
40026254: c8 07 20 20 ld [ %i4 + 0x20 ], %g4 <== NOT EXECUTED
40026258: 84 10 a1 a5 or %g2, 0x1a5, %g2 <== NOT EXECUTED
4002625c: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED
40026260: 22 80 00 08 be,a 40026280 <Stack_check_Dump_threads_usage+0x64><== NOT EXECUTED
40026264: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
40026268: 10 80 00 37 b 40026344 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
4002626c: a0 07 20 10 add %i4, 0x10, %l0 <== NOT EXECUTED
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
40026270: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED
40026274: 12 80 00 34 bne 40026344 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
40026278: a0 07 20 10 add %i4, 0x10, %l0 <== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
4002627c: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED
40026280: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
40026284: 38 bf ff fb bgu,a 40026270 <Stack_check_Dump_threads_usage+0x54><== NOT EXECUTED
40026288: c4 00 40 00 ld [ %g1 ], %g2 <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
4002628c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
40026290: 02 80 00 31 be 40026354 <Stack_check_Dump_threads_usage+0x138><== NOT EXECUTED
40026294: a0 10 20 00 clr %l0 <== NOT EXECUTED
#endif
{
(*print_handler)(
40026298: f2 06 20 08 ld [ %i0 + 8 ], %i1 <== NOT EXECUTED
4002629c: 39 10 01 a3 sethi %hi(0x40068c00), %i4 <== NOT EXECUTED
400262a0: 37 10 01 a3 sethi %hi(0x40068c00), %i3 <== NOT EXECUTED
400262a4: e4 07 23 84 ld [ %i4 + 0x384 ], %l2 <== NOT EXECUTED
400262a8: f0 06 e3 88 ld [ %i3 + 0x388 ], %i0 <== NOT EXECUTED
400262ac: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
400262b0: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
400262b4: 7f ff a8 86 call 400104cc <rtems_object_get_name> <== NOT EXECUTED
400262b8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
400262bc: 13 10 01 7f sethi %hi(0x4005fc00), %o1 <== NOT EXECUTED
400262c0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400262c4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
400262c8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
400262cc: 9f c6 00 00 call %i0 <== NOT EXECUTED
400262d0: 92 12 60 e8 or %o1, 0xe8, %o1 <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
400262d4: d4 07 60 04 ld [ %i5 + 4 ], %o2 <== NOT EXECUTED
400262d8: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
400262dc: c4 06 e3 88 ld [ %i3 + 0x388 ], %g2 <== NOT EXECUTED
400262e0: d0 07 23 84 ld [ %i4 + 0x384 ], %o0 <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
400262e4: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
400262e8: 13 10 01 7f sethi %hi(0x4005fc00), %o1 <== NOT EXECUTED
400262ec: 96 02 80 0b add %o2, %o3, %o3 <== NOT EXECUTED
400262f0: 92 12 61 08 or %o1, 0x108, %o1 <== NOT EXECUTED
400262f4: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
400262f8: 9f c0 80 00 call %g2 <== NOT EXECUTED
400262fc: 9a 10 00 1a mov %i2, %o5 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
40026300: 05 10 01 a3 sethi %hi(0x40068c00), %g2 <== NOT EXECUTED
40026304: c4 00 a3 80 ld [ %g2 + 0x380 ], %g2 ! 40068f80 <Stack_check_Initialized><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
40026308: c2 06 e3 88 ld [ %i3 + 0x388 ], %g1 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
4002630c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40026310: 12 80 00 07 bne 4002632c <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
40026314: d0 07 23 84 ld [ %i4 + 0x384 ], %o0 <== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
40026318: 13 10 01 7f sethi %hi(0x4005fc00), %o1 <== NOT EXECUTED
4002631c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40026320: 92 12 61 28 or %o1, 0x128, %o1 ! 4005fd28 <RTEMS_BDPART_MBR_MASTER_TYPE+0x300><== NOT EXECUTED
40026324: 81 c7 e0 08 ret <== NOT EXECUTED
40026328: 81 e8 00 00 restore <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
4002632c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40026330: 13 10 01 7f sethi %hi(0x4005fc00), %o1 <== NOT EXECUTED
40026334: 9f c0 40 00 call %g1 <== NOT EXECUTED
40026338: 92 12 61 38 or %o1, 0x138, %o1 ! 4005fd38 <RTEMS_BDPART_MBR_MASTER_TYPE+0x310><== NOT EXECUTED
4002633c: 81 c7 e0 08 ret <== NOT EXECUTED
40026340: 81 e8 00 00 restore <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
40026344: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
40026348: a0 04 00 1a add %l0, %i2, %l0 <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
4002634c: 12 bf ff d3 bne 40026298 <Stack_check_Dump_threads_usage+0x7c><== NOT EXECUTED
40026350: a0 24 00 01 sub %l0, %g1, %l0 <== NOT EXECUTED
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 );
40026354: 37 10 01 a3 sethi %hi(0x40068c00), %i3 <== NOT EXECUTED
40026358: 39 10 01 a3 sethi %hi(0x40068c00), %i4 <== NOT EXECUTED
4002635c: c2 06 e3 88 ld [ %i3 + 0x388 ], %g1 <== NOT EXECUTED
40026360: d0 07 23 84 ld [ %i4 + 0x384 ], %o0 <== NOT EXECUTED
40026364: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED
40026368: 13 10 01 7f sethi %hi(0x4005fc00), %o1 <== NOT EXECUTED
4002636c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40026370: 92 12 60 f8 or %o1, 0xf8, %o1 ! 4005fcf8 <RTEMS_BDPART_MBR_MASTER_TYPE+0x2d0><== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
40026374: 10 bf ff d9 b 400262d8 <Stack_check_Dump_threads_usage+0xbc><== NOT EXECUTED
40026378: d4 07 60 04 ld [ %i5 + 4 ], %o2 <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
if (!Stack_check_Interrupt_stack.area)
4002637c: 3b 10 01 a8 sethi %hi(0x4006a000), %i5 <== NOT EXECUTED
40026380: ba 17 62 dc or %i5, 0x2dc, %i5 ! 4006a2dc <Stack_check_Interrupt_stack><== NOT EXECUTED
40026384: f8 07 60 04 ld [ %i5 + 4 ], %i4 <== NOT EXECUTED
40026388: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4002638c: 02 bf ff e6 be 40026324 <Stack_check_Dump_threads_usage+0x108><== NOT EXECUTED
40026390: a2 10 20 00 clr %l1 <== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
40026394: 10 bf ff a8 b 40026234 <Stack_check_Dump_threads_usage+0x18><== NOT EXECUTED
40026398: b0 10 20 00 clr %i0 <== NOT EXECUTED
40026490 <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)
{
40026490: 9d e3 bf 80 save %sp, -128, %sp <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
char name[32];
printk("BLOWN STACK!!!\n");
40026494: 11 10 01 7f sethi %hi(0x4005fc00), %o0 <== NOT EXECUTED
) 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);
40026498: fa 06 20 b8 ld [ %i0 + 0xb8 ], %i5 <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
4002649c: 7f ff 79 b5 call 40004b70 <printk> <== NOT EXECUTED
400264a0: 90 12 21 40 or %o0, 0x140, %o0 <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
400264a4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
400264a8: 11 10 01 7f sethi %hi(0x4005fc00), %o0 <== NOT EXECUTED
400264ac: 7f ff 79 b1 call 40004b70 <printk> <== NOT EXECUTED
400264b0: 90 12 21 50 or %o0, 0x150, %o0 ! 4005fd50 <RTEMS_BDPART_MBR_MASTER_TYPE+0x328><== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
400264b4: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
400264b8: 11 10 01 7f sethi %hi(0x4005fc00), %o0 <== NOT EXECUTED
400264bc: 7f ff 79 ad call 40004b70 <printk> <== NOT EXECUTED
400264c0: 90 12 21 70 or %o0, 0x170, %o0 ! 4005fd70 <RTEMS_BDPART_MBR_MASTER_TYPE+0x348><== NOT EXECUTED
printk(
400264c4: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
400264c8: 11 10 01 7f sethi %hi(0x4005fc00), %o0 <== NOT EXECUTED
400264cc: 7f ff 79 a9 call 40004b70 <printk> <== NOT EXECUTED
400264d0: 90 12 21 88 or %o0, 0x188, %o0 ! 4005fd88 <RTEMS_BDPART_MBR_MASTER_TYPE+0x360><== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
400264d4: d0 06 20 08 ld [ %i0 + 8 ], %o0 <== NOT EXECUTED
400264d8: 94 07 bf e0 add %fp, -32, %o2 <== NOT EXECUTED
400264dc: 7f ff a7 fc call 400104cc <rtems_object_get_name> <== NOT EXECUTED
400264e0: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
400264e4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400264e8: 11 10 01 7f sethi %hi(0x4005fc00), %o0 <== NOT EXECUTED
400264ec: 7f ff 79 a1 call 40004b70 <printk> <== NOT EXECUTED
400264f0: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 4005fda0 <RTEMS_BDPART_MBR_MASTER_TYPE+0x378><== NOT EXECUTED
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
400264f4: d4 06 20 b8 ld [ %i0 + 0xb8 ], %o2 <== NOT EXECUTED
400264f8: d2 06 20 b4 ld [ %i0 + 0xb4 ], %o1 <== NOT EXECUTED
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
400264fc: 11 10 01 7f sethi %hi(0x4005fc00), %o0 <== NOT EXECUTED
40026500: 96 02 80 09 add %o2, %o1, %o3 <== NOT EXECUTED
40026504: 7f ff 79 9b call 40004b70 <printk> <== NOT EXECUTED
40026508: 90 12 21 b8 or %o0, 0x1b8, %o0 <== NOT EXECUTED
"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) {
4002650c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40026510: 02 80 00 05 be 40026524 <Stack_check_report_blown_task+0x94><== NOT EXECUTED
40026514: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal(
40026518: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
4002651c: 7f ff 88 88 call 4000873c <rtems_fatal> <== NOT EXECUTED
40026520: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
40026524: 11 10 01 7f sethi %hi(0x4005fc00), %o0 <== NOT EXECUTED
40026528: 94 07 60 08 add %i5, 8, %o2 <== NOT EXECUTED
4002652c: 90 12 21 e8 or %o0, 0x1e8, %o0 <== NOT EXECUTED
40026530: 7f ff 79 90 call 40004b70 <printk> <== NOT EXECUTED
40026534: 96 07 60 18 add %i5, 0x18, %o3 <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal(
40026538: 10 bf ff f9 b 4002651c <Stack_check_report_blown_task+0x8c><== NOT EXECUTED
4002653c: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED
40008f78 <_API_extensions_Add_post_switch>:
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
40008f78: c2 02 00 00 ld [ %o0 ], %g1
40008f7c: 80 a0 60 00 cmp %g1, 0
40008f80: 22 80 00 04 be,a 40008f90 <_API_extensions_Add_post_switch+0x18>
40008f84: c2 02 20 04 ld [ %o0 + 4 ], %g1
40008f88: 81 c3 e0 08 retl
40008f8c: 01 00 00 00 nop
40008f90: 80 a0 60 00 cmp %g1, 0
40008f94: 12 bf ff fd bne 40008f88 <_API_extensions_Add_post_switch+0x10><== NEVER TAKEN
40008f98: 03 10 00 80 sethi %hi(0x40020000), %g1
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
40008f9c: 82 10 63 20 or %g1, 0x320, %g1 ! 40020320 <_API_extensions_Post_switch_list>
40008fa0: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
40008fa4: 86 00 60 04 add %g1, 4, %g3
tail->previous = the_node;
40008fa8: d0 20 60 08 st %o0, [ %g1 + 8 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
40008fac: c6 22 00 00 st %g3, [ %o0 ]
tail->previous = the_node;
old_last->next = the_node;
40008fb0: d0 20 80 00 st %o0, [ %g2 ]
the_node->previous = old_last;
40008fb4: 81 c3 e0 08 retl
40008fb8: c4 22 20 04 st %g2, [ %o0 + 4 ]
40008fbc <_API_extensions_Run_postdriver>:
}
}
#endif
void _API_extensions_Run_postdriver( void )
{
40008fbc: 9d e3 bf a0 save %sp, -96, %sp
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
40008fc0: 39 10 00 81 sethi %hi(0x40020400), %i4
40008fc4: fa 07 20 68 ld [ %i4 + 0x68 ], %i5 ! 40020468 <_API_extensions_List>
40008fc8: b8 17 20 68 or %i4, 0x68, %i4
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
40008fcc: b8 07 20 04 add %i4, 4, %i4
40008fd0: 80 a7 40 1c cmp %i5, %i4
40008fd4: 02 80 00 09 be 40008ff8 <_API_extensions_Run_postdriver+0x3c><== NEVER TAKEN
40008fd8: 01 00 00 00 nop
* Currently all APIs configure this hook so it is always non-NULL.
*/
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
40008fdc: c2 07 60 08 ld [ %i5 + 8 ], %g1
40008fe0: 9f c0 40 00 call %g1
40008fe4: 01 00 00 00 nop
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
40008fe8: fa 07 40 00 ld [ %i5 ], %i5
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
40008fec: 80 a7 40 1c cmp %i5, %i4
40008ff0: 32 bf ff fc bne,a 40008fe0 <_API_extensions_Run_postdriver+0x24>
40008ff4: c2 07 60 08 ld [ %i5 + 8 ], %g1
40008ff8: 81 c7 e0 08 ret
40008ffc: 81 e8 00 00 restore
4000b32c <_CORE_RWLock_Release>:
#include <rtems/score/watchdog.h>
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
4000b32c: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
4000b330: 03 10 00 70 sethi %hi(0x4001c000), %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 );
4000b334: 7f ff e1 51 call 40003878 <sparc_disable_interrupts>
4000b338: fa 00 60 f0 ld [ %g1 + 0xf0 ], %i5 ! 4001c0f0 <_Per_CPU_Information+0x10>
4000b33c: 84 10 00 08 mov %o0, %g2
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
4000b340: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
4000b344: 80 a0 60 00 cmp %g1, 0
4000b348: 02 80 00 2b be 4000b3f4 <_CORE_RWLock_Release+0xc8>
4000b34c: 80 a0 60 01 cmp %g1, 1
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
4000b350: 22 80 00 22 be,a 4000b3d8 <_CORE_RWLock_Release+0xac>
4000b354: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
return CORE_RWLOCK_SUCCESSFUL;
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
4000b358: 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;
4000b35c: c0 26 20 44 clr [ %i0 + 0x44 ]
_ISR_Enable( level );
4000b360: 7f ff e1 4a call 40003888 <sparc_enable_interrupts>
4000b364: 90 10 00 02 mov %g2, %o0
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
4000b368: 40 00 07 e0 call 4000d2e8 <_Thread_queue_Dequeue>
4000b36c: 90 10 00 18 mov %i0, %o0
if ( next ) {
4000b370: 80 a2 20 00 cmp %o0, 0
4000b374: 22 80 00 24 be,a 4000b404 <_CORE_RWLock_Release+0xd8>
4000b378: b0 10 20 00 clr %i0
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
4000b37c: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
4000b380: 80 a0 60 01 cmp %g1, 1
4000b384: 02 80 00 22 be 4000b40c <_CORE_RWLock_Release+0xe0>
4000b388: 84 10 20 01 mov 1, %g2
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
4000b38c: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
4000b390: 82 00 60 01 inc %g1
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
4000b394: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
4000b398: 10 80 00 09 b 4000b3bc <_CORE_RWLock_Release+0x90>
4000b39c: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
4000b3a0: 80 a0 60 01 cmp %g1, 1
4000b3a4: 02 80 00 0b be 4000b3d0 <_CORE_RWLock_Release+0xa4> <== NEVER TAKEN
4000b3a8: 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;
4000b3ac: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
4000b3b0: 82 00 60 01 inc %g1
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
4000b3b4: 40 00 08 dd call 4000d728 <_Thread_queue_Extract>
4000b3b8: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
4000b3bc: 40 00 09 2c call 4000d86c <_Thread_queue_First>
4000b3c0: 90 10 00 18 mov %i0, %o0
if ( !next ||
4000b3c4: 92 92 20 00 orcc %o0, 0, %o1
4000b3c8: 32 bf ff f6 bne,a 4000b3a0 <_CORE_RWLock_Release+0x74>
4000b3cc: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
4000b3d0: 81 c7 e0 08 ret
4000b3d4: 91 e8 20 00 restore %g0, 0, %o0
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
the_rwlock->number_of_readers -= 1;
4000b3d8: 82 00 7f ff add %g1, -1, %g1
if ( the_rwlock->number_of_readers != 0 ) {
4000b3dc: 80 a0 60 00 cmp %g1, 0
4000b3e0: 02 bf ff de be 4000b358 <_CORE_RWLock_Release+0x2c>
4000b3e4: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/* must be unlocked again */
_ISR_Enable( level );
4000b3e8: 7f ff e1 28 call 40003888 <sparc_enable_interrupts>
4000b3ec: b0 10 20 00 clr %i0
return CORE_RWLOCK_SUCCESSFUL;
4000b3f0: 30 80 00 05 b,a 4000b404 <_CORE_RWLock_Release+0xd8>
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
_ISR_Enable( level );
4000b3f4: 7f ff e1 25 call 40003888 <sparc_enable_interrupts>
4000b3f8: b0 10 20 00 clr %i0
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
4000b3fc: 82 10 20 02 mov 2, %g1
4000b400: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
4000b404: 81 c7 e0 08 ret
4000b408: 81 e8 00 00 restore
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
if ( next ) {
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
4000b40c: 82 10 20 02 mov 2, %g1
4000b410: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
4000b414: 81 c7 e0 08 ret
4000b418: 91 e8 20 00 restore %g0, 0, %o0
4000b41c <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
4000b41c: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
4000b420: 90 10 00 18 mov %i0, %o0
4000b424: 40 00 06 e4 call 4000cfb4 <_Thread_Get>
4000b428: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000b42c: c2 07 bf fc ld [ %fp + -4 ], %g1
4000b430: 80 a0 60 00 cmp %g1, 0
4000b434: 12 80 00 08 bne 4000b454 <_CORE_RWLock_Timeout+0x38> <== NEVER TAKEN
4000b438: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
4000b43c: 40 00 09 4d call 4000d970 <_Thread_queue_Process_timeout>
4000b440: 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;
4000b444: 03 10 00 6e sethi %hi(0x4001b800), %g1
4000b448: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 4001bbd0 <_Thread_Dispatch_disable_level>
--level;
4000b44c: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000b450: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ]
4000b454: 81 c7 e0 08 ret
4000b458: 81 e8 00 00 restore
4000931c <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
4000931c: 9d e3 bf a0 save %sp, -96, %sp
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
40009320: 3b 10 00 80 sethi %hi(0x40020000), %i5
40009324: c2 07 62 b0 ld [ %i5 + 0x2b0 ], %g1 ! 400202b0 <_Thread_Dispatch_disable_level>
40009328: 80 a0 60 00 cmp %g1, 0
4000932c: 02 80 00 1f be 400093a8 <_CORE_mutex_Seize+0x8c>
40009330: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
40009334: 80 a6 a0 00 cmp %i2, 0
40009338: 02 80 00 2c be 400093e8 <_CORE_mutex_Seize+0xcc>
4000933c: 90 10 00 18 mov %i0, %o0
40009340: 03 10 00 81 sethi %hi(0x40020400), %g1
40009344: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 400207b8 <_System_state_Current>
40009348: 80 a0 60 01 cmp %g1, 1
4000934c: 38 80 00 2e bgu,a 40009404 <_CORE_mutex_Seize+0xe8>
40009350: 90 10 20 00 clr %o0
40009354: 40 00 14 9a call 4000e5bc <_CORE_mutex_Seize_interrupt_trylock>
40009358: 92 07 a0 54 add %fp, 0x54, %o1
4000935c: 80 a2 20 00 cmp %o0, 0
40009360: 02 80 00 27 be 400093fc <_CORE_mutex_Seize+0xe0> <== ALWAYS TAKEN
40009364: 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;
40009368: c4 07 62 b0 ld [ %i5 + 0x2b0 ], %g2
4000936c: 03 10 00 81 sethi %hi(0x40020400), %g1
40009370: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 400207d0 <_Per_CPU_Information+0x10>
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
40009374: 86 10 20 01 mov 1, %g3
40009378: c6 26 20 30 st %g3, [ %i0 + 0x30 ]
4000937c: f0 20 60 44 st %i0, [ %g1 + 0x44 ]
40009380: f2 20 60 20 st %i1, [ %g1 + 0x20 ]
++level;
40009384: 82 00 a0 01 add %g2, 1, %g1
_Thread_Dispatch_disable_level = level;
40009388: c2 27 62 b0 st %g1, [ %i5 + 0x2b0 ]
4000938c: 7f ff e4 55 call 400024e0 <sparc_enable_interrupts>
40009390: d0 07 a0 54 ld [ %fp + 0x54 ], %o0
40009394: 90 10 00 18 mov %i0, %o0
40009398: 7f ff ff ba call 40009280 <_CORE_mutex_Seize_interrupt_blocking>
4000939c: 92 10 00 1b mov %i3, %o1
400093a0: 81 c7 e0 08 ret
400093a4: 81 e8 00 00 restore
400093a8: 90 10 00 18 mov %i0, %o0
400093ac: 40 00 14 84 call 4000e5bc <_CORE_mutex_Seize_interrupt_trylock>
400093b0: 92 07 a0 54 add %fp, 0x54, %o1
400093b4: 80 a2 20 00 cmp %o0, 0
400093b8: 02 bf ff fa be 400093a0 <_CORE_mutex_Seize+0x84>
400093bc: 80 a6 a0 00 cmp %i2, 0
400093c0: 12 bf ff ea bne 40009368 <_CORE_mutex_Seize+0x4c>
400093c4: 01 00 00 00 nop
400093c8: 7f ff e4 46 call 400024e0 <sparc_enable_interrupts>
400093cc: d0 07 a0 54 ld [ %fp + 0x54 ], %o0
400093d0: 03 10 00 81 sethi %hi(0x40020400), %g1
400093d4: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 400207d0 <_Per_CPU_Information+0x10>
400093d8: 84 10 20 01 mov 1, %g2
400093dc: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
400093e0: 81 c7 e0 08 ret
400093e4: 81 e8 00 00 restore
400093e8: 40 00 14 75 call 4000e5bc <_CORE_mutex_Seize_interrupt_trylock>
400093ec: 92 07 a0 54 add %fp, 0x54, %o1
400093f0: 80 a2 20 00 cmp %o0, 0
400093f4: 12 bf ff f5 bne 400093c8 <_CORE_mutex_Seize+0xac> <== NEVER TAKEN
400093f8: 01 00 00 00 nop
400093fc: 81 c7 e0 08 ret
40009400: 81 e8 00 00 restore
40009404: 92 10 20 00 clr %o1
40009408: 40 00 01 c1 call 40009b0c <_Internal_error_Occurred>
4000940c: 94 10 20 12 mov 0x12, %o2
4000958c <_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
)
{
4000958c: 9d e3 bf a0 save %sp, -96, %sp
40009590: ba 10 00 18 mov %i0, %i5
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
40009594: b0 10 20 00 clr %i0
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
40009598: 40 00 07 a5 call 4000b42c <_Thread_queue_Dequeue>
4000959c: 90 10 00 1d mov %i5, %o0
400095a0: 80 a2 20 00 cmp %o0, 0
400095a4: 02 80 00 04 be 400095b4 <_CORE_semaphore_Surrender+0x28>
400095a8: 01 00 00 00 nop
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
400095ac: 81 c7 e0 08 ret
400095b0: 81 e8 00 00 restore
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
400095b4: 7f ff e3 c7 call 400024d0 <sparc_disable_interrupts>
400095b8: 01 00 00 00 nop
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
400095bc: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
400095c0: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
400095c4: 80 a0 40 02 cmp %g1, %g2
400095c8: 1a 80 00 05 bcc 400095dc <_CORE_semaphore_Surrender+0x50> <== NEVER TAKEN
400095cc: b0 10 20 04 mov 4, %i0
the_semaphore->count += 1;
400095d0: 82 00 60 01 inc %g1
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
400095d4: b0 10 20 00 clr %i0
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
400095d8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
400095dc: 7f ff e3 c1 call 400024e0 <sparc_enable_interrupts>
400095e0: 01 00 00 00 nop
}
return status;
}
400095e4: 81 c7 e0 08 ret
400095e8: 81 e8 00 00 restore
4000914c <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
4000914c: 9d e3 bf a0 save %sp, -96, %sp
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
40009150: c0 26 20 04 clr [ %i0 + 4 ]
size_t node_size
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
40009154: ba 06 20 04 add %i0, 4, %i5
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
40009158: 80 a6 a0 00 cmp %i2, 0
4000915c: 02 80 00 13 be 400091a8 <_Chain_Initialize+0x5c> <== NEVER TAKEN
40009160: 92 06 bf ff add %i2, -1, %o1
40009164: 86 10 00 09 mov %o1, %g3
40009168: 82 10 00 19 mov %i1, %g1
4000916c: 84 10 00 18 mov %i0, %g2
current->next = next;
40009170: c2 20 80 00 st %g1, [ %g2 ]
next->previous = current;
40009174: c4 20 60 04 st %g2, [ %g1 + 4 ]
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
40009178: 86 00 ff ff add %g3, -1, %g3
4000917c: 84 10 00 01 mov %g1, %g2
40009180: 80 a0 ff ff cmp %g3, -1
40009184: 12 bf ff fb bne 40009170 <_Chain_Initialize+0x24>
40009188: 82 00 40 1b add %g1, %i3, %g1
#include <rtems/system.h>
#include <rtems/score/address.h>
#include <rtems/score/chain.h>
#include <rtems/score/isr.h>
void _Chain_Initialize(
4000918c: 40 00 42 00 call 4001998c <.umul>
40009190: 90 10 00 1b mov %i3, %o0
40009194: 90 06 40 08 add %i1, %o0, %o0
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
40009198: fa 22 00 00 st %i5, [ %o0 ]
tail->previous = current;
4000919c: d0 26 20 08 st %o0, [ %i0 + 8 ]
400091a0: 81 c7 e0 08 ret
400091a4: 81 e8 00 00 restore
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
400091a8: 10 bf ff fc b 40009198 <_Chain_Initialize+0x4c> <== NOT EXECUTED
400091ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400080f8 <_Event_Surrender>:
rtems_event_set event_in,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
400080f8: 9d e3 bf a0 save %sp, -96, %sp
rtems_event_set seized_events;
rtems_option option_set;
option_set = the_thread->Wait.option;
_ISR_Disable( level );
400080fc: 7f ff e8 f5 call 400024d0 <sparc_disable_interrupts>
40008100: fa 06 20 30 ld [ %i0 + 0x30 ], %i5
RTEMS_INLINE_ROUTINE void _Event_sets_Post(
rtems_event_set the_new_events,
rtems_event_set *the_event_set
)
{
*the_event_set |= the_new_events;
40008104: c2 06 80 00 ld [ %i2 ], %g1
40008108: b2 16 40 01 or %i1, %g1, %i1
4000810c: 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;
40008110: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
40008114: 84 8e 40 01 andcc %i1, %g1, %g2
40008118: 02 80 00 35 be 400081ec <_Event_Surrender+0xf4>
4000811c: 07 10 00 81 sethi %hi(0x40020400), %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() &&
40008120: 86 10 e3 c0 or %g3, 0x3c0, %g3 ! 400207c0 <_Per_CPU_Information>
40008124: c8 00 e0 08 ld [ %g3 + 8 ], %g4
40008128: 80 a1 20 00 cmp %g4, 0
4000812c: 32 80 00 1c bne,a 4000819c <_Event_Surrender+0xa4>
40008130: c6 00 e0 10 ld [ %g3 + 0x10 ], %g3
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
40008134: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Are_set( the_thread->current_state, wait_state ) ) {
40008138: 80 8f 00 03 btst %i4, %g3
4000813c: 02 80 00 2c be 400081ec <_Event_Surrender+0xf4>
40008140: 80 a0 40 02 cmp %g1, %g2
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
40008144: 02 80 00 04 be 40008154 <_Event_Surrender+0x5c>
40008148: 80 8f 60 02 btst 2, %i5
4000814c: 02 80 00 28 be 400081ec <_Event_Surrender+0xf4> <== NEVER TAKEN
40008150: 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;
40008154: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
40008158: b2 2e 40 02 andn %i1, %g2, %i1
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Are_set( the_thread->current_state, wait_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
event->pending_events = _Event_sets_Clear(
4000815c: f2 26 80 00 st %i1, [ %i2 ]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
40008160: c0 26 20 24 clr [ %i0 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40008164: c4 20 40 00 st %g2, [ %g1 ]
_ISR_Flash( level );
40008168: 7f ff e8 de call 400024e0 <sparc_enable_interrupts>
4000816c: 01 00 00 00 nop
40008170: 7f ff e8 d8 call 400024d0 <sparc_disable_interrupts>
40008174: 01 00 00 00 nop
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
40008178: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
4000817c: 80 a0 60 02 cmp %g1, 2
40008180: 02 80 00 1d be 400081f4 <_Event_Surrender+0xfc>
40008184: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
40008188: 7f ff e8 d6 call 400024e0 <sparc_enable_interrupts>
4000818c: 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 );
40008190: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1007fff8 <RAM_SIZE+0xfc7fff8>
40008194: 40 00 0a e0 call 4000ad14 <_Thread_Clear_state>
40008198: 81 e8 00 00 restore
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
4000819c: 80 a6 00 03 cmp %i0, %g3
400081a0: 32 bf ff e6 bne,a 40008138 <_Event_Surrender+0x40>
400081a4: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
400081a8: c6 06 c0 00 ld [ %i3 ], %g3
400081ac: 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 ) &&
400081b0: 80 a0 e0 01 cmp %g3, 1
400081b4: 38 bf ff e1 bgu,a 40008138 <_Event_Surrender+0x40>
400081b8: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
400081bc: 80 a0 40 02 cmp %g1, %g2
400081c0: 02 80 00 04 be 400081d0 <_Event_Surrender+0xd8>
400081c4: 80 8f 60 02 btst 2, %i5
400081c8: 02 80 00 09 be 400081ec <_Event_Surrender+0xf4> <== NEVER TAKEN
400081cc: 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;
400081d0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
400081d4: b2 2e 40 02 andn %i1, %g2, %i1
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
event->pending_events = _Event_sets_Clear(
400081d8: f2 26 80 00 st %i1, [ %i2 ]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
400081dc: c0 26 20 24 clr [ %i0 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
400081e0: c4 20 40 00 st %g2, [ %g1 ]
*sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
400081e4: 82 10 20 03 mov 3, %g1
400081e8: c2 26 c0 00 st %g1, [ %i3 ]
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
400081ec: 7f ff e8 bd call 400024e0 <sparc_enable_interrupts>
400081f0: 91 e8 00 08 restore %g0, %o0, %o0
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
400081f4: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
400081f8: 7f ff e8 ba call 400024e0 <sparc_enable_interrupts>
400081fc: 33 04 01 ff sethi %hi(0x1007fc00), %i1
(void) _Watchdog_Remove( &the_thread->Timer );
40008200: 40 00 0f 4d call 4000bf34 <_Watchdog_Remove>
40008204: 90 06 20 48 add %i0, 0x48, %o0
40008208: b2 16 63 f8 or %i1, 0x3f8, %i1
4000820c: 40 00 0a c2 call 4000ad14 <_Thread_Clear_state>
40008210: 81 e8 00 00 restore
40008214 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *arg
)
{
40008214: 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 );
40008218: 90 10 00 18 mov %i0, %o0
4000821c: 40 00 0b b7 call 4000b0f8 <_Thread_Get>
40008220: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40008224: c2 07 bf fc ld [ %fp + -4 ], %g1
40008228: 80 a0 60 00 cmp %g1, 0
4000822c: 12 80 00 15 bne 40008280 <_Event_Timeout+0x6c> <== NEVER TAKEN
40008230: 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 );
40008234: 7f ff e8 a7 call 400024d0 <sparc_disable_interrupts>
40008238: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
4000823c: 03 10 00 81 sethi %hi(0x40020400), %g1
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
40008240: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 400207d0 <_Per_CPU_Information+0x10>
40008244: 80 a7 40 01 cmp %i5, %g1
40008248: 02 80 00 10 be 40008288 <_Event_Timeout+0x74>
4000824c: c0 27 60 24 clr [ %i5 + 0x24 ]
if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
40008250: 82 10 20 06 mov 6, %g1
40008254: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
_ISR_Enable( level );
40008258: 7f ff e8 a2 call 400024e0 <sparc_enable_interrupts>
4000825c: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
40008260: 90 10 00 1d mov %i5, %o0
40008264: 13 04 01 ff sethi %hi(0x1007fc00), %o1
40008268: 40 00 0a ab call 4000ad14 <_Thread_Clear_state>
4000826c: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1007fff8 <RAM_SIZE+0xfc7fff8>
*
* 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;
40008270: 03 10 00 80 sethi %hi(0x40020000), %g1
40008274: c4 00 62 b0 ld [ %g1 + 0x2b0 ], %g2 ! 400202b0 <_Thread_Dispatch_disable_level>
--level;
40008278: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000827c: c4 20 62 b0 st %g2, [ %g1 + 0x2b0 ]
40008280: 81 c7 e0 08 ret
40008284: 81 e8 00 00 restore
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
40008288: c2 06 40 00 ld [ %i1 ], %g1
4000828c: 80 a0 60 01 cmp %g1, 1
40008290: 12 bf ff f1 bne 40008254 <_Event_Timeout+0x40>
40008294: 82 10 20 06 mov 6, %g1
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
40008298: 82 10 20 02 mov 2, %g1
4000829c: 10 bf ff ed b 40008250 <_Event_Timeout+0x3c>
400082a0: c2 26 40 00 st %g1, [ %i1 ]
4000e71c <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
4000e71c: 9d e3 bf 98 save %sp, -104, %sp
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
4000e720: a2 06 60 04 add %i1, 4, %l1
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
4000e724: a0 10 00 18 mov %i0, %l0
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
4000e728: 80 a6 40 11 cmp %i1, %l1
4000e72c: 18 80 00 85 bgu 4000e940 <_Heap_Allocate_aligned_with_boundary+0x224>
4000e730: ea 06 20 10 ld [ %i0 + 0x10 ], %l5
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
4000e734: 80 a6 e0 00 cmp %i3, 0
4000e738: 12 80 00 7c bne 4000e928 <_Heap_Allocate_aligned_with_boundary+0x20c>
4000e73c: 80 a6 40 1b cmp %i1, %i3
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
4000e740: fa 04 20 08 ld [ %l0 + 8 ], %i5
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
4000e744: 80 a4 00 1d cmp %l0, %i5
4000e748: 02 80 00 18 be 4000e7a8 <_Heap_Allocate_aligned_with_boundary+0x8c>
4000e74c: b8 10 20 00 clr %i4
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
4000e750: ac 10 20 04 mov 4, %l6
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
4000e754: ae 05 60 07 add %l5, 7, %l7
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
4000e758: ac 25 80 19 sub %l6, %i1, %l6
4000e75c: 10 80 00 0b b 4000e788 <_Heap_Allocate_aligned_with_boundary+0x6c>
4000e760: ec 27 bf fc st %l6, [ %fp + -4 ]
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
if ( alignment == 0 ) {
4000e764: 12 80 00 18 bne 4000e7c4 <_Heap_Allocate_aligned_with_boundary+0xa8>
4000e768: b0 07 60 08 add %i5, 8, %i0
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
4000e76c: 80 a6 20 00 cmp %i0, 0
4000e770: 12 80 00 4d bne 4000e8a4 <_Heap_Allocate_aligned_with_boundary+0x188><== ALWAYS TAKEN
4000e774: b8 07 20 01 inc %i4
break;
}
block = block->next;
4000e778: fa 07 60 08 ld [ %i5 + 8 ], %i5
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
4000e77c: 80 a4 00 1d cmp %l0, %i5
4000e780: 22 80 00 0b be,a 4000e7ac <_Heap_Allocate_aligned_with_boundary+0x90>
4000e784: c2 04 20 44 ld [ %l0 + 0x44 ], %g1
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
4000e788: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000e78c: 80 a4 40 01 cmp %l1, %g1
4000e790: 0a bf ff f5 bcs 4000e764 <_Heap_Allocate_aligned_with_boundary+0x48>
4000e794: 80 a6 a0 00 cmp %i2, 0
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
4000e798: fa 07 60 08 ld [ %i5 + 8 ], %i5
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
4000e79c: 80 a4 00 1d cmp %l0, %i5
4000e7a0: 12 bf ff fa bne 4000e788 <_Heap_Allocate_aligned_with_boundary+0x6c>
4000e7a4: b8 07 20 01 inc %i4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
4000e7a8: c2 04 20 44 ld [ %l0 + 0x44 ], %g1
4000e7ac: 80 a0 40 1c cmp %g1, %i4
4000e7b0: 1a 80 00 03 bcc 4000e7bc <_Heap_Allocate_aligned_with_boundary+0xa0>
4000e7b4: b0 10 20 00 clr %i0
stats->max_search = search_count;
4000e7b8: f8 24 20 44 st %i4, [ %l0 + 0x44 ]
}
return (void *) alloc_begin;
4000e7bc: 81 c7 e0 08 ret
4000e7c0: 81 e8 00 00 restore
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
4000e7c4: e8 04 20 14 ld [ %l0 + 0x14 ], %l4
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000e7c8: a4 08 7f fe and %g1, -2, %l2
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
4000e7cc: c2 07 bf fc ld [ %fp + -4 ], %g1
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
4000e7d0: 84 25 c0 14 sub %l7, %l4, %g2
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
4000e7d4: a4 07 40 12 add %i5, %l2, %l2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4000e7d8: 92 10 00 1a mov %i2, %o1
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
4000e7dc: b0 00 40 12 add %g1, %l2, %i0
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
4000e7e0: a4 00 80 12 add %g2, %l2, %l2
4000e7e4: 40 00 2d 50 call 40019d24 <.urem>
4000e7e8: 90 10 00 18 mov %i0, %o0
4000e7ec: b0 26 00 08 sub %i0, %o0, %i0
uintptr_t alloc_begin = alloc_end - alloc_size;
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
4000e7f0: 80 a4 80 18 cmp %l2, %i0
4000e7f4: 1a 80 00 06 bcc 4000e80c <_Heap_Allocate_aligned_with_boundary+0xf0>
4000e7f8: a6 07 60 08 add %i5, 8, %l3
4000e7fc: 90 10 00 12 mov %l2, %o0
4000e800: 40 00 2d 49 call 40019d24 <.urem>
4000e804: 92 10 00 1a mov %i2, %o1
4000e808: b0 24 80 08 sub %l2, %o0, %i0
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
4000e80c: 80 a6 e0 00 cmp %i3, 0
4000e810: 02 80 00 37 be 4000e8ec <_Heap_Allocate_aligned_with_boundary+0x1d0>
4000e814: 80 a4 c0 18 cmp %l3, %i0
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment );
}
alloc_end = alloc_begin + alloc_size;
4000e818: 86 06 00 19 add %i0, %i1, %g3
4000e81c: 92 10 00 1b mov %i3, %o1
4000e820: 90 10 00 03 mov %g3, %o0
4000e824: 40 00 2d 40 call 40019d24 <.urem>
4000e828: c6 27 bf f8 st %g3, [ %fp + -8 ]
4000e82c: c6 07 bf f8 ld [ %fp + -8 ], %g3
4000e830: 90 20 c0 08 sub %g3, %o0, %o0
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
4000e834: 80 a6 00 08 cmp %i0, %o0
4000e838: 1a 80 00 2c bcc 4000e8e8 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000e83c: a4 04 c0 19 add %l3, %i1, %l2
4000e840: 80 a2 00 03 cmp %o0, %g3
4000e844: 2a 80 00 12 bcs,a 4000e88c <_Heap_Allocate_aligned_with_boundary+0x170>
4000e848: 80 a4 80 08 cmp %l2, %o0
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
4000e84c: 10 80 00 28 b 4000e8ec <_Heap_Allocate_aligned_with_boundary+0x1d0>
4000e850: 80 a4 c0 18 cmp %l3, %i0
4000e854: 92 10 00 1a mov %i2, %o1
4000e858: 40 00 2d 33 call 40019d24 <.urem>
4000e85c: 90 10 00 18 mov %i0, %o0
4000e860: 92 10 00 1b mov %i3, %o1
4000e864: b0 26 00 08 sub %i0, %o0, %i0
if ( boundary_line < boundary_floor ) {
return 0;
}
alloc_begin = boundary_line - alloc_size;
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
4000e868: ac 06 00 19 add %i0, %i1, %l6
4000e86c: 40 00 2d 2e call 40019d24 <.urem>
4000e870: 90 10 00 16 mov %l6, %o0
4000e874: 90 25 80 08 sub %l6, %o0, %o0
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
4000e878: 80 a2 00 16 cmp %o0, %l6
4000e87c: 1a 80 00 1b bcc 4000e8e8 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000e880: 80 a6 00 08 cmp %i0, %o0
4000e884: 1a 80 00 19 bcc 4000e8e8 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000e888: 80 a4 80 08 cmp %l2, %o0
if ( boundary_line < boundary_floor ) {
4000e88c: 08 bf ff f2 bleu 4000e854 <_Heap_Allocate_aligned_with_boundary+0x138>
4000e890: b0 22 00 19 sub %o0, %i1, %i0
return 0;
4000e894: b0 10 20 00 clr %i0
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
4000e898: 80 a6 20 00 cmp %i0, 0
4000e89c: 02 bf ff b7 be 4000e778 <_Heap_Allocate_aligned_with_boundary+0x5c><== ALWAYS TAKEN
4000e8a0: b8 07 20 01 inc %i4
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
4000e8a4: c6 04 20 48 ld [ %l0 + 0x48 ], %g3
stats->searches += search_count;
4000e8a8: c4 04 20 4c ld [ %l0 + 0x4c ], %g2
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
4000e8ac: 86 00 e0 01 inc %g3
stats->searches += search_count;
4000e8b0: 84 00 80 1c add %g2, %i4, %g2
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
4000e8b4: c6 24 20 48 st %g3, [ %l0 + 0x48 ]
stats->searches += search_count;
4000e8b8: c4 24 20 4c st %g2, [ %l0 + 0x4c ]
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
4000e8bc: 90 10 00 10 mov %l0, %o0
4000e8c0: 92 10 00 1d mov %i5, %o1
4000e8c4: 94 10 00 18 mov %i0, %o2
4000e8c8: 7f ff ec 45 call 400099dc <_Heap_Block_allocate>
4000e8cc: 96 10 00 19 mov %i1, %o3
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
4000e8d0: c2 04 20 44 ld [ %l0 + 0x44 ], %g1
4000e8d4: 80 a0 40 1c cmp %g1, %i4
4000e8d8: 2a bf ff b9 bcs,a 4000e7bc <_Heap_Allocate_aligned_with_boundary+0xa0>
4000e8dc: f8 24 20 44 st %i4, [ %l0 + 0x44 ]
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
4000e8e0: 81 c7 e0 08 ret
4000e8e4: 81 e8 00 00 restore
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
4000e8e8: 80 a4 c0 18 cmp %l3, %i0
4000e8ec: 18 bf ff ea bgu 4000e894 <_Heap_Allocate_aligned_with_boundary+0x178>
4000e8f0: 82 10 3f f8 mov -8, %g1
4000e8f4: 90 10 00 18 mov %i0, %o0
4000e8f8: a4 20 40 1d sub %g1, %i5, %l2
4000e8fc: 92 10 00 15 mov %l5, %o1
4000e900: 40 00 2d 09 call 40019d24 <.urem>
4000e904: a4 04 80 18 add %l2, %i0, %l2
uintptr_t const alloc_block_begin =
(uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
uintptr_t const free_size = alloc_block_begin - block_begin;
if ( free_size >= min_block_size || free_size == 0 ) {
4000e908: 90 a4 80 08 subcc %l2, %o0, %o0
4000e90c: 02 bf ff 99 be 4000e770 <_Heap_Allocate_aligned_with_boundary+0x54>
4000e910: 80 a6 20 00 cmp %i0, 0
4000e914: 80 a2 00 14 cmp %o0, %l4
4000e918: 1a bf ff 96 bcc 4000e770 <_Heap_Allocate_aligned_with_boundary+0x54>
4000e91c: 80 a6 20 00 cmp %i0, 0
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
return 0;
4000e920: 10 bf ff de b 4000e898 <_Heap_Allocate_aligned_with_boundary+0x17c>
4000e924: b0 10 20 00 clr %i0
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
4000e928: 18 80 00 06 bgu 4000e940 <_Heap_Allocate_aligned_with_boundary+0x224>
4000e92c: 80 a6 a0 00 cmp %i2, 0
return NULL;
}
if ( alignment == 0 ) {
4000e930: 22 bf ff 84 be,a 4000e740 <_Heap_Allocate_aligned_with_boundary+0x24>
4000e934: b4 10 00 15 mov %l5, %i2
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
4000e938: 10 bf ff 83 b 4000e744 <_Heap_Allocate_aligned_with_boundary+0x28>
4000e93c: fa 04 20 08 ld [ %l0 + 8 ], %i5
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
/* Integer overflow occured */
return NULL;
4000e940: 81 c7 e0 08 ret
4000e944: 91 e8 20 00 restore %g0, 0, %o0
4000e55c <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
4000e55c: 9d e3 bf 98 save %sp, -104, %sp
Heap_Block *start_block = first_block;
Heap_Block *merge_below_block = NULL;
Heap_Block *merge_above_block = NULL;
Heap_Block *link_below_block = NULL;
Heap_Block *link_above_block = NULL;
Heap_Block *extend_first_block = NULL;
4000e560: c0 27 bf f8 clr [ %fp + -8 ]
Heap_Block *extend_last_block = NULL;
4000e564: c0 27 bf fc clr [ %fp + -4 ]
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
4000e568: b8 10 00 18 mov %i0, %i4
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
4000e56c: e2 06 20 20 ld [ %i0 + 0x20 ], %l1
Heap_Block *extend_first_block = NULL;
Heap_Block *extend_last_block = NULL;
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
4000e570: a0 06 40 1a add %i1, %i2, %l0
Heap_Block *merge_above_block = NULL;
Heap_Block *link_below_block = NULL;
Heap_Block *link_above_block = NULL;
Heap_Block *extend_first_block = NULL;
Heap_Block *extend_last_block = NULL;
uintptr_t const page_size = heap->page_size;
4000e574: e4 06 20 10 ld [ %i0 + 0x10 ], %l2
uintptr_t const min_block_size = heap->min_block_size;
4000e578: d6 06 20 14 ld [ %i0 + 0x14 ], %o3
uintptr_t const free_size = stats->free_size;
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
4000e57c: 80 a6 40 10 cmp %i1, %l0
4000e580: 08 80 00 04 bleu 4000e590 <_Heap_Extend+0x34>
4000e584: f0 06 20 30 ld [ %i0 + 0x30 ], %i0
return 0;
4000e588: 81 c7 e0 08 ret
4000e58c: 91 e8 20 00 restore %g0, 0, %o0
}
extend_area_ok = _Heap_Get_first_and_last_block(
4000e590: 90 10 00 19 mov %i1, %o0
4000e594: 92 10 00 1a mov %i2, %o1
4000e598: 94 10 00 12 mov %l2, %o2
4000e59c: 98 07 bf f8 add %fp, -8, %o4
4000e5a0: 7f ff eb d6 call 400094f8 <_Heap_Get_first_and_last_block>
4000e5a4: 9a 07 bf fc add %fp, -4, %o5
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
4000e5a8: 80 8a 20 ff btst 0xff, %o0
4000e5ac: 02 bf ff f7 be 4000e588 <_Heap_Extend+0x2c>
4000e5b0: ba 10 00 11 mov %l1, %i5
4000e5b4: aa 10 20 00 clr %l5
4000e5b8: ac 10 20 00 clr %l6
4000e5bc: a6 10 20 00 clr %l3
4000e5c0: 10 80 00 10 b 4000e600 <_Heap_Extend+0xa4>
4000e5c4: a8 10 20 00 clr %l4
return 0;
}
if ( extend_area_end == sub_area_begin ) {
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4000e5c8: 2a 80 00 02 bcs,a 4000e5d0 <_Heap_Extend+0x74>
4000e5cc: ac 10 00 1d mov %i5, %l6
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
4000e5d0: 80 a6 c0 19 cmp %i3, %i1
4000e5d4: 22 80 00 1e be,a 4000e64c <_Heap_Extend+0xf0>
4000e5d8: e0 27 40 00 st %l0, [ %i5 ]
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
4000e5dc: 80 a6 40 1b cmp %i1, %i3
4000e5e0: 38 80 00 02 bgu,a 4000e5e8 <_Heap_Extend+0x8c>
4000e5e4: aa 10 00 08 mov %o0, %l5
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000e5e8: fa 02 20 04 ld [ %o0 + 4 ], %i5
4000e5ec: ba 0f 7f fe and %i5, -2, %i5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4000e5f0: ba 02 00 1d add %o0, %i5, %i5
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
4000e5f4: 80 a4 40 1d cmp %l1, %i5
4000e5f8: 22 80 00 1c be,a 4000e668 <_Heap_Extend+0x10c>
4000e5fc: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
return 0;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
4000e600: 80 a7 40 11 cmp %i5, %l1
4000e604: 22 80 00 03 be,a 4000e610 <_Heap_Extend+0xb4>
4000e608: f4 07 20 18 ld [ %i4 + 0x18 ], %i2
4000e60c: b4 10 00 1d mov %i5, %i2
uintptr_t const sub_area_end = start_block->prev_size;
4000e610: f6 07 40 00 ld [ %i5 ], %i3
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4000e614: 92 10 00 12 mov %l2, %o1
4000e618: 40 00 16 eb call 400141c4 <.urem>
4000e61c: 90 10 00 1b mov %i3, %o0
4000e620: 82 06 ff f8 add %i3, -8, %g1
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
4000e624: 80 a6 80 10 cmp %i2, %l0
4000e628: 0a 80 00 64 bcs 4000e7b8 <_Heap_Extend+0x25c>
4000e62c: 90 20 40 08 sub %g1, %o0, %o0
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return 0;
}
if ( extend_area_end == sub_area_begin ) {
4000e630: 80 a6 80 10 cmp %i2, %l0
4000e634: 12 bf ff e5 bne 4000e5c8 <_Heap_Extend+0x6c>
4000e638: 80 a4 00 1b cmp %l0, %i3
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
4000e63c: 80 a6 c0 19 cmp %i3, %i1
4000e640: 12 bf ff e7 bne 4000e5dc <_Heap_Extend+0x80> <== ALWAYS TAKEN
4000e644: a8 10 00 1d mov %i5, %l4
start_block->prev_size = extend_area_end;
4000e648: e0 27 40 00 st %l0, [ %i5 ] <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000e64c: fa 02 20 04 ld [ %o0 + 4 ], %i5
4000e650: ba 0f 7f fe and %i5, -2, %i5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4000e654: ba 02 00 1d add %o0, %i5, %i5
} else if ( sub_area_end < extend_area_begin ) {
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
4000e658: 80 a4 40 1d cmp %l1, %i5
4000e65c: 12 bf ff e9 bne 4000e600 <_Heap_Extend+0xa4> <== NEVER TAKEN
4000e660: a6 10 00 08 mov %o0, %l3
if ( extend_area_begin < heap->area_begin ) {
4000e664: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
4000e668: 80 a6 40 01 cmp %i1, %g1
4000e66c: 3a 80 00 4e bcc,a 4000e7a4 <_Heap_Extend+0x248>
4000e670: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
heap->area_begin = extend_area_begin;
4000e674: f2 27 20 18 st %i1, [ %i4 + 0x18 ]
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
4000e678: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000e67c: c4 07 bf fc ld [ %fp + -4 ], %g2
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4000e680: c8 07 20 20 ld [ %i4 + 0x20 ], %g4
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
4000e684: 86 20 80 01 sub %g2, %g1, %g3
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
4000e688: e0 20 40 00 st %l0, [ %g1 ]
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
4000e68c: ba 10 e0 01 or %g3, 1, %i5
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
4000e690: fa 20 60 04 st %i5, [ %g1 + 4 ]
extend_first_block_size | HEAP_PREV_BLOCK_USED;
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
4000e694: c6 20 80 00 st %g3, [ %g2 ]
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4000e698: 80 a1 00 01 cmp %g4, %g1
4000e69c: 08 80 00 3c bleu 4000e78c <_Heap_Extend+0x230>
4000e6a0: c0 20 a0 04 clr [ %g2 + 4 ]
heap->first_block = extend_first_block;
4000e6a4: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
4000e6a8: 80 a5 20 00 cmp %l4, 0
4000e6ac: 02 80 00 47 be 4000e7c8 <_Heap_Extend+0x26c>
4000e6b0: b2 06 60 08 add %i1, 8, %i1
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
4000e6b4: fa 07 20 10 ld [ %i4 + 0x10 ], %i5
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
4000e6b8: 92 10 00 1d mov %i5, %o1
4000e6bc: 40 00 16 c2 call 400141c4 <.urem>
4000e6c0: 90 10 00 19 mov %i1, %o0
if ( remainder != 0 ) {
4000e6c4: 80 a2 20 00 cmp %o0, 0
4000e6c8: 02 80 00 04 be 4000e6d8 <_Heap_Extend+0x17c>
4000e6cc: c4 05 00 00 ld [ %l4 ], %g2
return value - remainder + alignment;
4000e6d0: b2 06 40 1d add %i1, %i5, %i1
4000e6d4: b2 26 40 08 sub %i1, %o0, %i1
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
4000e6d8: 82 06 7f f8 add %i1, -8, %g1
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
4000e6dc: c4 26 7f f8 st %g2, [ %i1 + -8 ]
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
4000e6e0: 84 25 00 01 sub %l4, %g1, %g2
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
4000e6e4: 84 10 a0 01 or %g2, 1, %g2
_Heap_Free_block( heap, new_first_block );
4000e6e8: 90 10 00 1c mov %i4, %o0
4000e6ec: 92 10 00 01 mov %g1, %o1
4000e6f0: 7f ff ff 85 call 4000e504 <_Heap_Free_block>
4000e6f4: c4 26 7f fc st %g2, [ %i1 + -4 ]
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
4000e6f8: 80 a4 e0 00 cmp %l3, 0
4000e6fc: 02 80 00 3a be 4000e7e4 <_Heap_Extend+0x288>
4000e700: a0 04 3f f8 add %l0, -8, %l0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4000e704: d2 07 20 10 ld [ %i4 + 0x10 ], %o1
uintptr_t extend_area_end
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
4000e708: a0 24 00 13 sub %l0, %l3, %l0
4000e70c: 40 00 16 ae call 400141c4 <.urem>
4000e710: 90 10 00 10 mov %l0, %o0
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
4000e714: c2 04 e0 04 ld [ %l3 + 4 ], %g1
4000e718: a0 24 00 08 sub %l0, %o0, %l0
4000e71c: 82 20 40 10 sub %g1, %l0, %g1
| HEAP_PREV_BLOCK_USED;
4000e720: 82 10 60 01 or %g1, 1, %g1
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
4000e724: 84 04 00 13 add %l0, %l3, %g2
4000e728: c2 20 a0 04 st %g1, [ %g2 + 4 ]
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000e72c: c2 04 e0 04 ld [ %l3 + 4 ], %g1
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
4000e730: 90 10 00 1c mov %i4, %o0
4000e734: 82 08 60 01 and %g1, 1, %g1
4000e738: 92 10 00 13 mov %l3, %o1
block->size_and_flag = size | flag;
4000e73c: a0 14 00 01 or %l0, %g1, %l0
4000e740: 7f ff ff 71 call 4000e504 <_Heap_Free_block>
4000e744: e0 24 e0 04 st %l0, [ %l3 + 4 ]
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
4000e748: 80 a4 e0 00 cmp %l3, 0
4000e74c: 02 80 00 33 be 4000e818 <_Heap_Extend+0x2bc>
4000e750: 80 a5 20 00 cmp %l4, 0
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
heap->last_block,
(uintptr_t) heap->first_block - (uintptr_t) heap->last_block
4000e754: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
4000e758: fa 07 20 20 ld [ %i4 + 0x20 ], %i5
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000e75c: c8 00 60 04 ld [ %g1 + 4 ], %g4
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
4000e760: c4 07 20 2c ld [ %i4 + 0x2c ], %g2
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
4000e764: c6 07 20 30 ld [ %i4 + 0x30 ], %g3
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
4000e768: ba 27 40 01 sub %i5, %g1, %i5
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000e76c: 88 09 20 01 and %g4, 1, %g4
block->size_and_flag = size | flag;
4000e770: 88 17 40 04 or %i5, %g4, %g4
4000e774: c8 20 60 04 st %g4, [ %g1 + 4 ]
4000e778: b0 20 c0 18 sub %g3, %i0, %i0
/* Statistics */
stats->size += extended_size;
4000e77c: 82 00 80 18 add %g2, %i0, %g1
4000e780: c2 27 20 2c st %g1, [ %i4 + 0x2c ]
return extended_size;
}
4000e784: 81 c7 e0 08 ret
4000e788: 81 e8 00 00 restore
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
4000e78c: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
4000e790: 80 a0 40 02 cmp %g1, %g2
4000e794: 2a bf ff c5 bcs,a 4000e6a8 <_Heap_Extend+0x14c>
4000e798: c4 27 20 24 st %g2, [ %i4 + 0x24 ]
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
4000e79c: 10 bf ff c4 b 4000e6ac <_Heap_Extend+0x150>
4000e7a0: 80 a5 20 00 cmp %l4, 0
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
if ( extend_area_begin < heap->area_begin ) {
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
4000e7a4: 80 a4 00 01 cmp %l0, %g1
4000e7a8: 38 bf ff b4 bgu,a 4000e678 <_Heap_Extend+0x11c>
4000e7ac: e0 27 20 1c st %l0, [ %i4 + 0x1c ]
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
4000e7b0: 10 bf ff b3 b 4000e67c <_Heap_Extend+0x120>
4000e7b4: c2 07 bf f8 ld [ %fp + -8 ], %g1
(uintptr_t) start_block : heap->area_begin;
uintptr_t const sub_area_end = start_block->prev_size;
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
4000e7b8: 80 a6 40 1b cmp %i1, %i3
4000e7bc: 1a bf ff 9e bcc 4000e634 <_Heap_Extend+0xd8>
4000e7c0: 80 a6 80 10 cmp %i2, %l0
4000e7c4: 30 bf ff 71 b,a 4000e588 <_Heap_Extend+0x2c>
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
4000e7c8: 80 a5 a0 00 cmp %l6, 0
4000e7cc: 02 bf ff cc be 4000e6fc <_Heap_Extend+0x1a0>
4000e7d0: 80 a4 e0 00 cmp %l3, 0
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
4000e7d4: ac 25 80 02 sub %l6, %g2, %l6
4000e7d8: ac 15 a0 01 or %l6, 1, %l6
)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
4000e7dc: 10 bf ff c8 b 4000e6fc <_Heap_Extend+0x1a0>
4000e7e0: ec 20 a0 04 st %l6, [ %g2 + 4 ]
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
4000e7e4: 80 a5 60 00 cmp %l5, 0
4000e7e8: 02 bf ff d8 be 4000e748 <_Heap_Extend+0x1ec>
4000e7ec: c4 07 bf f8 ld [ %fp + -8 ], %g2
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000e7f0: c6 05 60 04 ld [ %l5 + 4 ], %g3
_Heap_Link_above(
4000e7f4: c2 07 bf fc ld [ %fp + -4 ], %g1
4000e7f8: 86 08 e0 01 and %g3, 1, %g3
)
{
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
4000e7fc: 84 20 80 15 sub %g2, %l5, %g2
block->size_and_flag = size | flag;
4000e800: 84 10 80 03 or %g2, %g3, %g2
4000e804: c4 25 60 04 st %g2, [ %l5 + 4 ]
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
4000e808: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000e80c: 84 10 a0 01 or %g2, 1, %g2
4000e810: 10 bf ff ce b 4000e748 <_Heap_Extend+0x1ec>
4000e814: c4 20 60 04 st %g2, [ %g1 + 4 ]
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
4000e818: 32 bf ff d0 bne,a 4000e758 <_Heap_Extend+0x1fc>
4000e81c: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
_Heap_Free_block( heap, extend_first_block );
4000e820: d2 07 bf f8 ld [ %fp + -8 ], %o1
4000e824: 7f ff ff 38 call 4000e504 <_Heap_Free_block>
4000e828: 90 10 00 1c mov %i4, %o0
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
heap->last_block,
(uintptr_t) heap->first_block - (uintptr_t) heap->last_block
4000e82c: 10 bf ff cb b 4000e758 <_Heap_Extend+0x1fc>
4000e830: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
4000e948 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
4000e948: 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 ) {
4000e94c: 80 a6 60 00 cmp %i1, 0
4000e950: 02 80 00 3c be 4000ea40 <_Heap_Free+0xf8>
4000e954: 82 10 20 01 mov 1, %g1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4000e958: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
4000e95c: 40 00 2c f2 call 40019d24 <.urem>
4000e960: 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
4000e964: c4 06 20 20 ld [ %i0 + 0x20 ], %g2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4000e968: 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);
4000e96c: 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;
4000e970: 80 a2 00 02 cmp %o0, %g2
4000e974: 0a 80 00 30 bcs 4000ea34 <_Heap_Free+0xec>
4000e978: 82 10 20 00 clr %g1
4000e97c: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
4000e980: 80 a2 00 04 cmp %o0, %g4
4000e984: 38 80 00 2d bgu,a 4000ea38 <_Heap_Free+0xf0> <== NEVER TAKEN
4000e988: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000e98c: f6 02 20 04 ld [ %o0 + 4 ], %i3
4000e990: ba 0e ff fe and %i3, -2, %i5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4000e994: 86 02 00 1d add %o0, %i5, %g3
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000e998: 80 a0 80 03 cmp %g2, %g3
4000e99c: 38 80 00 27 bgu,a 4000ea38 <_Heap_Free+0xf0> <== NEVER TAKEN
4000e9a0: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED
4000e9a4: 80 a1 00 03 cmp %g4, %g3
4000e9a8: 2a 80 00 24 bcs,a 4000ea38 <_Heap_Free+0xf0> <== NEVER TAKEN
4000e9ac: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000e9b0: f8 00 e0 04 ld [ %g3 + 4 ], %i4
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
4000e9b4: 80 8f 20 01 btst 1, %i4
4000e9b8: 02 80 00 1f be 4000ea34 <_Heap_Free+0xec> <== NEVER TAKEN
4000e9bc: 80 a1 00 03 cmp %g4, %g3
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4000e9c0: 02 80 00 23 be 4000ea4c <_Heap_Free+0x104>
4000e9c4: b8 0f 3f fe and %i4, -2, %i4
4000e9c8: 82 00 c0 1c add %g3, %i4, %g1
4000e9cc: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000e9d0: 80 88 60 01 btst 1, %g1
4000e9d4: 12 80 00 1f bne 4000ea50 <_Heap_Free+0x108>
4000e9d8: 80 8e e0 01 btst 1, %i3
if ( !_Heap_Is_prev_used( block ) ) {
4000e9dc: 02 80 00 20 be 4000ea5c <_Heap_Free+0x114>
4000e9e0: b2 10 20 01 mov 1, %i1
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
4000e9e4: c4 00 e0 08 ld [ %g3 + 8 ], %g2
Heap_Block *prev = old_block->prev;
4000e9e8: c2 00 e0 0c ld [ %g3 + 0xc ], %g1
new_block->next = next;
4000e9ec: c4 22 20 08 st %g2, [ %o0 + 8 ]
new_block->prev = prev;
4000e9f0: c2 22 20 0c st %g1, [ %o0 + 0xc ]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
4000e9f4: b8 07 00 1d add %i4, %i5, %i4
next->prev = new_block;
4000e9f8: d0 20 a0 0c st %o0, [ %g2 + 0xc ]
prev->next = new_block;
4000e9fc: d0 20 60 08 st %o0, [ %g1 + 8 ]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000ea00: 84 17 20 01 or %i4, 1, %g2
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
4000ea04: f8 22 00 1c st %i4, [ %o0 + %i4 ]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000ea08: c4 22 20 04 st %g2, [ %o0 + 4 ]
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
4000ea0c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
4000ea10: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
++stats->frees;
stats->free_size += block_size;
4000ea14: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
4000ea18: 82 00 60 01 inc %g1
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
4000ea1c: 84 00 bf ff add %g2, -1, %g2
++stats->frees;
stats->free_size += block_size;
4000ea20: ba 00 c0 1d add %g3, %i5, %i5
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
4000ea24: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
4000ea28: c4 26 20 40 st %g2, [ %i0 + 0x40 ]
++stats->frees;
stats->free_size += block_size;
4000ea2c: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
return( true );
4000ea30: 82 10 20 01 mov 1, %g1
4000ea34: b0 08 60 ff and %g1, 0xff, %i0
4000ea38: 81 c7 e0 08 ret
4000ea3c: 81 e8 00 00 restore
4000ea40: b0 08 60 ff and %g1, 0xff, %i0
4000ea44: 81 c7 e0 08 ret
4000ea48: 81 e8 00 00 restore
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
4000ea4c: 80 8e e0 01 btst 1, %i3
4000ea50: 32 80 00 1e bne,a 4000eac8 <_Heap_Free+0x180>
4000ea54: c4 06 20 08 ld [ %i0 + 8 ], %g2
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
4000ea58: b2 10 20 00 clr %i1
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
uintptr_t const prev_size = block->prev_size;
4000ea5c: f4 02 00 00 ld [ %o0 ], %i2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4000ea60: b6 22 00 1a sub %o0, %i2, %i3
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000ea64: 80 a0 80 1b cmp %g2, %i3
4000ea68: 18 bf ff f3 bgu 4000ea34 <_Heap_Free+0xec> <== NEVER TAKEN
4000ea6c: 82 10 20 00 clr %g1
4000ea70: 80 a1 00 1b cmp %g4, %i3
4000ea74: 2a bf ff f1 bcs,a 4000ea38 <_Heap_Free+0xf0> <== NEVER TAKEN
4000ea78: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000ea7c: c4 06 e0 04 ld [ %i3 + 4 ], %g2
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
4000ea80: 80 88 a0 01 btst 1, %g2
4000ea84: 02 bf ff ec be 4000ea34 <_Heap_Free+0xec> <== NEVER TAKEN
4000ea88: 80 8e 60 ff btst 0xff, %i1
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
4000ea8c: 22 80 00 21 be,a 4000eb10 <_Heap_Free+0x1c8>
4000ea90: b4 07 40 1a add %i5, %i2, %i2
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
4000ea94: c2 00 e0 08 ld [ %g3 + 8 ], %g1
Heap_Block *prev = block->prev;
4000ea98: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
4000ea9c: c6 06 20 38 ld [ %i0 + 0x38 ], %g3
prev->next = next;
4000eaa0: c2 20 a0 08 st %g1, [ %g2 + 8 ]
next->prev = prev;
4000eaa4: c4 20 60 0c st %g2, [ %g1 + 0xc ]
4000eaa8: 82 00 ff ff add %g3, -1, %g1
4000eaac: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
4000eab0: b8 07 40 1c add %i5, %i4, %i4
4000eab4: b4 07 00 1a add %i4, %i2, %i2
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000eab8: 82 16 a0 01 or %i2, 1, %g1
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
4000eabc: f4 26 c0 1a st %i2, [ %i3 + %i2 ]
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000eac0: 10 bf ff d3 b 4000ea0c <_Heap_Free+0xc4>
4000eac4: c2 26 e0 04 st %g1, [ %i3 + 4 ]
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
4000eac8: 82 17 60 01 or %i5, 1, %g1
4000eacc: c2 22 20 04 st %g1, [ %o0 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000ead0: c8 00 e0 04 ld [ %g3 + 4 ], %g4
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
4000ead4: f0 22 20 0c st %i0, [ %o0 + 0xc ]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
4000ead8: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
4000eadc: c4 22 20 08 st %g2, [ %o0 + 8 ]
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
4000eae0: d0 20 a0 0c st %o0, [ %g2 + 0xc ]
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000eae4: 84 09 3f fe and %g4, -2, %g2
next_block->prev_size = block_size;
4000eae8: fa 22 00 1d st %i5, [ %o0 + %i5 ]
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000eaec: c4 20 e0 04 st %g2, [ %g3 + 4 ]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
4000eaf0: c4 06 20 3c ld [ %i0 + 0x3c ], %g2
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
4000eaf4: 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;
4000eaf8: d0 26 20 08 st %o0, [ %i0 + 8 ]
if ( stats->max_free_blocks < stats->free_blocks ) {
4000eafc: 80 a0 40 02 cmp %g1, %g2
4000eb00: 08 bf ff c3 bleu 4000ea0c <_Heap_Free+0xc4>
4000eb04: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
stats->max_free_blocks = stats->free_blocks;
4000eb08: 10 bf ff c1 b 4000ea0c <_Heap_Free+0xc4>
4000eb0c: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4000eb10: 82 16 a0 01 or %i2, 1, %g1
4000eb14: c2 26 e0 04 st %g1, [ %i3 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000eb18: c2 00 e0 04 ld [ %g3 + 4 ], %g1
next_block->prev_size = size;
4000eb1c: f4 22 00 1d st %i2, [ %o0 + %i5 ]
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4000eb20: 82 08 7f fe and %g1, -2, %g1
4000eb24: 10 bf ff ba b 4000ea0c <_Heap_Free+0xc4>
4000eb28: c2 20 e0 04 st %g1, [ %g3 + 4 ]
40014614 <_Heap_Get_free_information>:
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
40014614: c2 02 20 08 ld [ %o0 + 8 ], %g1
)
{
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
40014618: c0 22 40 00 clr [ %o1 ]
info->largest = 0;
4001461c: c0 22 60 04 clr [ %o1 + 4 ]
info->total = 0;
40014620: c0 22 60 08 clr [ %o1 + 8 ]
for(the_block = _Heap_Free_list_first(the_heap);
40014624: 88 10 20 01 mov 1, %g4
40014628: 9a 10 20 00 clr %o5
4001462c: 80 a2 00 01 cmp %o0, %g1
40014630: 12 80 00 04 bne 40014640 <_Heap_Get_free_information+0x2c><== ALWAYS TAKEN
40014634: 86 10 20 00 clr %g3
40014638: 30 80 00 10 b,a 40014678 <_Heap_Get_free_information+0x64><== NOT EXECUTED
4001463c: 88 10 00 0c mov %o4, %g4
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
40014640: c4 00 60 04 ld [ %g1 + 4 ], %g2
40014644: 98 01 20 01 add %g4, 1, %o4
40014648: 84 08 bf fe and %g2, -2, %g2
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
info->total += the_size;
if ( info->largest < the_size )
4001464c: 80 a0 80 0d cmp %g2, %o5
40014650: 08 80 00 03 bleu 4001465c <_Heap_Get_free_information+0x48>
40014654: 86 00 c0 02 add %g3, %g2, %g3
info->largest = the_size;
40014658: c4 22 60 04 st %g2, [ %o1 + 4 ]
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
the_block != tail;
the_block = the_block->next)
4001465c: c2 00 60 08 ld [ %g1 + 8 ], %g1
info->number = 0;
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
40014660: 80 a2 00 01 cmp %o0, %g1
40014664: 32 bf ff f6 bne,a 4001463c <_Heap_Get_free_information+0x28>
40014668: da 02 60 04 ld [ %o1 + 4 ], %o5
4001466c: c8 22 40 00 st %g4, [ %o1 ]
40014670: 81 c3 e0 08 retl
40014674: c6 22 60 08 st %g3, [ %o1 + 8 ]
40014678: 81 c3 e0 08 retl <== NOT EXECUTED
4000b818 <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
4000b818: 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) {
4000b81c: 80 a6 a0 00 cmp %i2, 0
4000b820: 02 80 00 35 be 4000b8f4 <_Heap_Greedy_allocate+0xdc>
4000b824: b8 10 00 18 mov %i0, %i4
4000b828: ba 10 20 00 clr %i5
4000b82c: b6 10 20 00 clr %i3
#include "config.h"
#endif
#include <rtems/score/heap.h>
Heap_Block *_Heap_Greedy_allocate(
4000b830: 83 2f 60 02 sll %i5, 2, %g1
* @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
* boundary equals zero.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
4000b834: d2 06 40 01 ld [ %i1 + %g1 ], %o1
4000b838: 94 10 20 00 clr %o2
4000b83c: 96 10 20 00 clr %o3
4000b840: 40 00 1f ca call 40013768 <_Heap_Allocate_aligned_with_boundary>
4000b844: 90 10 00 1c mov %i4, %o0
size_t i;
for (i = 0; i < block_count; ++i) {
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
4000b848: 82 92 20 00 orcc %o0, 0, %g1
4000b84c: 22 80 00 09 be,a 4000b870 <_Heap_Greedy_allocate+0x58> <== NEVER TAKEN
4000b850: ba 07 60 01 inc %i5 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4000b854: d2 07 20 10 ld [ %i4 + 0x10 ], %o1
4000b858: 40 00 37 13 call 400194a4 <.urem>
4000b85c: 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);
4000b860: 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;
4000b864: f6 22 20 08 st %i3, [ %o0 + 8 ]
4000b868: b6 10 00 08 mov %o0, %i3
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
4000b86c: ba 07 60 01 inc %i5
4000b870: 80 a7 40 1a cmp %i5, %i2
4000b874: 12 bf ff f0 bne 4000b834 <_Heap_Greedy_allocate+0x1c>
4000b878: 83 2f 60 02 sll %i5, 2, %g1
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
4000b87c: fa 07 20 08 ld [ %i4 + 8 ], %i5
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
4000b880: 80 a7 00 1d cmp %i4, %i5
4000b884: 02 80 00 17 be 4000b8e0 <_Heap_Greedy_allocate+0xc8> <== NEVER TAKEN
4000b888: b0 10 20 00 clr %i0
4000b88c: 10 80 00 03 b 4000b898 <_Heap_Greedy_allocate+0x80>
4000b890: b4 10 20 00 clr %i2
4000b894: ba 10 00 01 mov %g1, %i5
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000b898: d6 07 60 04 ld [ %i5 + 4 ], %o3
_Heap_Block_allocate(
4000b89c: 92 10 00 1d mov %i5, %o1
4000b8a0: 96 0a ff fe and %o3, -2, %o3
4000b8a4: 94 07 60 08 add %i5, 8, %o2
4000b8a8: 90 10 00 1c mov %i4, %o0
4000b8ac: 40 00 00 e0 call 4000bc2c <_Heap_Block_allocate>
4000b8b0: 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;
4000b8b4: f4 27 60 08 st %i2, [ %i5 + 8 ]
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
4000b8b8: c2 07 20 08 ld [ %i4 + 8 ], %g1
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
4000b8bc: 80 a7 00 01 cmp %i4, %g1
4000b8c0: 12 bf ff f5 bne 4000b894 <_Heap_Greedy_allocate+0x7c>
4000b8c4: b4 10 00 1d mov %i5, %i2
4000b8c8: 10 80 00 06 b 4000b8e0 <_Heap_Greedy_allocate+0xc8>
4000b8cc: b0 10 00 1d mov %i5, %i0
}
while ( allocated_blocks != NULL ) {
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
4000b8d0: 92 06 e0 08 add %i3, 8, %o1
4000b8d4: 90 10 00 1c mov %i4, %o0
4000b8d8: 40 00 20 2f call 40013994 <_Heap_Free>
4000b8dc: b6 10 00 1a mov %i2, %i3
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
4000b8e0: 80 a6 e0 00 cmp %i3, 0
4000b8e4: 32 bf ff fb bne,a 4000b8d0 <_Heap_Greedy_allocate+0xb8>
4000b8e8: f4 06 e0 08 ld [ %i3 + 8 ], %i2
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
return blocks;
}
4000b8ec: 81 c7 e0 08 ret
4000b8f0: 81 e8 00 00 restore
const uintptr_t *block_sizes,
size_t block_count
)
{
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
Heap_Block *allocated_blocks = NULL;
4000b8f4: 10 bf ff e2 b 4000b87c <_Heap_Greedy_allocate+0x64>
4000b8f8: b6 10 20 00 clr %i3
4000b8fc <_Heap_Greedy_free>:
void _Heap_Greedy_free(
Heap_Control *heap,
Heap_Block *blocks
)
{
4000b8fc: 9d e3 bf a0 save %sp, -96, %sp
while ( blocks != NULL ) {
4000b900: 80 a6 60 00 cmp %i1, 0
4000b904: 02 80 00 09 be 4000b928 <_Heap_Greedy_free+0x2c> <== NEVER TAKEN
4000b908: 01 00 00 00 nop
Heap_Block *current = blocks;
blocks = blocks->next;
4000b90c: fa 06 60 08 ld [ %i1 + 8 ], %i5
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
4000b910: 92 06 60 08 add %i1, 8, %o1
4000b914: 40 00 20 20 call 40013994 <_Heap_Free>
4000b918: 90 10 00 18 mov %i0, %o0
void _Heap_Greedy_free(
Heap_Control *heap,
Heap_Block *blocks
)
{
while ( blocks != NULL ) {
4000b91c: b2 97 60 00 orcc %i5, 0, %i1
4000b920: 32 bf ff fc bne,a 4000b910 <_Heap_Greedy_free+0x14>
4000b924: fa 06 60 08 ld [ %i1 + 8 ], %i5
4000b928: 81 c7 e0 08 ret
4000b92c: 81 e8 00 00 restore
400146e0 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
400146e0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
Heap_Block *current = heap->first_block;
400146e4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
Heap_Block *end = heap->last_block;
400146e8: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 <== NOT EXECUTED
bool stop = false;
while ( !stop && current != end ) {
400146ec: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED
400146f0: 32 80 00 08 bne,a 40014710 <_Heap_Iterate+0x30> <== NOT EXECUTED
400146f4: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED
400146f8: 30 80 00 10 b,a 40014738 <_Heap_Iterate+0x58> <== NOT EXECUTED
400146fc: 90 1a 20 01 xor %o0, 1, %o0 <== NOT EXECUTED
40014700: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40014704: 02 80 00 0d be 40014738 <_Heap_Iterate+0x58> <== NOT EXECUTED
40014708: 01 00 00 00 nop <== NOT EXECUTED
4001470c: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED
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 );
40014710: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
40014714: 92 0a 7f fe and %o1, -2, %o1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
40014718: ba 00 40 09 add %g1, %o1, %i5 <== NOT EXECUTED
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4001471c: d4 07 60 04 ld [ %i5 + 4 ], %o2 <== NOT EXECUTED
40014720: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
40014724: 9f c6 40 00 call %i1 <== NOT EXECUTED
40014728: 94 0a a0 01 and %o2, 1, %o2 <== NOT EXECUTED
{
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
4001472c: 80 a7 00 1d cmp %i4, %i5 <== NOT EXECUTED
40014730: 12 bf ff f3 bne 400146fc <_Heap_Iterate+0x1c> <== NOT EXECUTED
40014734: 82 10 00 1d mov %i5, %g1 <== NOT EXECUTED
40014738: 81 c7 e0 08 ret <== NOT EXECUTED
4001473c: 81 e8 00 00 restore <== NOT EXECUTED
4001d30c <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
4001d30c: 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);
4001d310: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
4001d314: 7f ff f2 84 call 40019d24 <.urem>
4001d318: 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
4001d31c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4001d320: 84 06 7f f8 add %i1, -8, %g2
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
4001d324: 90 20 80 08 sub %g2, %o0, %o0
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4001d328: 80 a2 00 01 cmp %o0, %g1
4001d32c: 0a 80 00 16 bcs 4001d384 <_Heap_Size_of_alloc_area+0x78>
4001d330: 84 10 20 00 clr %g2
4001d334: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
4001d338: 80 a2 00 03 cmp %o0, %g3
4001d33c: 18 80 00 13 bgu 4001d388 <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
4001d340: b0 08 a0 ff and %g2, 0xff, %i0
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4001d344: c8 02 20 04 ld [ %o0 + 4 ], %g4
4001d348: 88 09 3f fe and %g4, -2, %g4
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4001d34c: 90 02 00 04 add %o0, %g4, %o0
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4001d350: 80 a0 40 08 cmp %g1, %o0
4001d354: 18 80 00 0d bgu 4001d388 <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
4001d358: 01 00 00 00 nop
4001d35c: 80 a0 c0 08 cmp %g3, %o0
4001d360: 0a 80 00 0a bcs 4001d388 <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
4001d364: 01 00 00 00 nop
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4001d368: c2 02 20 04 ld [ %o0 + 4 ], %g1
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
4001d36c: 80 88 60 01 btst 1, %g1
4001d370: 02 80 00 06 be 4001d388 <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN
4001d374: 90 22 00 19 sub %o0, %i1, %o0
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
4001d378: 84 10 20 01 mov 1, %g2
|| !_Heap_Is_prev_used( next_block )
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
4001d37c: 90 02 20 04 add %o0, 4, %o0
4001d380: d0 26 80 00 st %o0, [ %i2 ]
4001d384: b0 08 a0 ff and %g2, 0xff, %i0
4001d388: 81 c7 e0 08 ret
4001d38c: 81 e8 00 00 restore
4000a474 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
4000a474: 9d e3 bf 80 save %sp, -128, %sp
uintptr_t const page_size = heap->page_size;
4000a478: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
uintptr_t const min_block_size = heap->min_block_size;
4000a47c: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
Heap_Block *const first_block = heap->first_block;
4000a480: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
4000a484: 80 a6 a0 00 cmp %i2, 0
4000a488: 02 80 00 0c be 4000a4b8 <_Heap_Walk+0x44>
4000a48c: e2 06 20 24 ld [ %i0 + 0x24 ], %l1
if ( !_System_state_Is_up( _System_state_Get() ) ) {
4000a490: 03 10 00 6a sethi %hi(0x4001a800), %g1
4000a494: c4 00 60 c8 ld [ %g1 + 0xc8 ], %g2 ! 4001a8c8 <_System_state_Current>
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
4000a498: 07 10 00 29 sethi %hi(0x4000a400), %g3
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
4000a49c: 82 10 20 01 mov 1, %g1
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
4000a4a0: 80 a0 a0 03 cmp %g2, 3
4000a4a4: 02 80 00 0c be 4000a4d4 <_Heap_Walk+0x60> <== ALWAYS TAKEN
4000a4a8: ae 10 e0 10 or %g3, 0x10, %l7
4000a4ac: b0 08 60 ff and %g1, 0xff, %i0
4000a4b0: 81 c7 e0 08 ret
4000a4b4: 81 e8 00 00 restore
4000a4b8: 03 10 00 6a sethi %hi(0x4001a800), %g1
4000a4bc: c4 00 60 c8 ld [ %g1 + 0xc8 ], %g2 ! 4001a8c8 <_System_state_Current>
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
4000a4c0: 07 10 00 29 sethi %hi(0x4000a400), %g3
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
4000a4c4: 82 10 20 01 mov 1, %g1
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
4000a4c8: 80 a0 a0 03 cmp %g2, 3
4000a4cc: 12 bf ff f8 bne 4000a4ac <_Heap_Walk+0x38>
4000a4d0: ae 10 e0 08 or %g3, 8, %l7
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
4000a4d4: da 06 20 18 ld [ %i0 + 0x18 ], %o5
4000a4d8: c8 06 20 1c ld [ %i0 + 0x1c ], %g4
4000a4dc: c4 06 20 08 ld [ %i0 + 8 ], %g2
4000a4e0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000a4e4: 90 10 00 19 mov %i1, %o0
4000a4e8: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
4000a4ec: f8 23 a0 60 st %i4, [ %sp + 0x60 ]
4000a4f0: e2 23 a0 64 st %l1, [ %sp + 0x64 ]
4000a4f4: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
4000a4f8: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
4000a4fc: 92 10 20 00 clr %o1
4000a500: 96 10 00 1b mov %i3, %o3
4000a504: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a508: 98 10 00 10 mov %l0, %o4
4000a50c: 9f c5 c0 00 call %l7
4000a510: 94 12 a0 70 or %o2, 0x70, %o2
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
4000a514: 80 a6 e0 00 cmp %i3, 0
4000a518: 02 80 00 2a be 4000a5c0 <_Heap_Walk+0x14c>
4000a51c: 80 8e e0 07 btst 7, %i3
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
4000a520: 12 80 00 2f bne 4000a5dc <_Heap_Walk+0x168>
4000a524: 90 10 00 10 mov %l0, %o0
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
4000a528: 7f ff dd 92 call 40001b70 <.urem>
4000a52c: 92 10 00 1b mov %i3, %o1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
4000a530: 80 a2 20 00 cmp %o0, 0
4000a534: 12 80 00 32 bne 4000a5fc <_Heap_Walk+0x188>
4000a538: 90 07 20 08 add %i4, 8, %o0
4000a53c: 7f ff dd 8d call 40001b70 <.urem>
4000a540: 92 10 00 1b mov %i3, %o1
);
return false;
}
if (
4000a544: 80 a2 20 00 cmp %o0, 0
4000a548: 32 80 00 35 bne,a 4000a61c <_Heap_Walk+0x1a8>
4000a54c: 90 10 00 19 mov %i1, %o0
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000a550: ec 07 20 04 ld [ %i4 + 4 ], %l6
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
4000a554: b4 8d a0 01 andcc %l6, 1, %i2
4000a558: 22 80 00 38 be,a 4000a638 <_Heap_Walk+0x1c4>
4000a55c: 90 10 00 19 mov %i1, %o0
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000a560: c2 04 60 04 ld [ %l1 + 4 ], %g1
4000a564: 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);
4000a568: 82 04 40 01 add %l1, %g1, %g1
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000a56c: fa 00 60 04 ld [ %g1 + 4 ], %i5
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
4000a570: 80 8f 60 01 btst 1, %i5
4000a574: 02 80 00 0c be 4000a5a4 <_Heap_Walk+0x130>
4000a578: 80 a7 00 01 cmp %i4, %g1
);
return false;
}
if (
4000a57c: 02 80 00 35 be 4000a650 <_Heap_Walk+0x1dc>
4000a580: 90 10 00 19 mov %i1, %o0
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
4000a584: 92 10 20 01 mov 1, %o1
4000a588: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a58c: 9f c5 c0 00 call %l7
4000a590: 94 12 a1 e8 or %o2, 0x1e8, %o2 ! 400179e8 <__log2table+0x2d8>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000a594: 82 10 20 00 clr %g1
4000a598: b0 08 60 ff and %g1, 0xff, %i0
4000a59c: 81 c7 e0 08 ret
4000a5a0: 81 e8 00 00 restore
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
4000a5a4: 90 10 00 19 mov %i1, %o0
4000a5a8: 92 10 20 01 mov 1, %o1
4000a5ac: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a5b0: 9f c5 c0 00 call %l7
4000a5b4: 94 12 a1 d0 or %o2, 0x1d0, %o2 ! 400179d0 <__log2table+0x2c0>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000a5b8: 10 bf ff f8 b 4000a598 <_Heap_Walk+0x124>
4000a5bc: 82 10 20 00 clr %g1
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
4000a5c0: 90 10 00 19 mov %i1, %o0
4000a5c4: 92 10 20 01 mov 1, %o1
4000a5c8: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a5cc: 9f c5 c0 00 call %l7
4000a5d0: 94 12 a1 08 or %o2, 0x108, %o2 ! 40017908 <__log2table+0x1f8>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000a5d4: 10 bf ff f1 b 4000a598 <_Heap_Walk+0x124>
4000a5d8: 82 10 20 00 clr %g1
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
4000a5dc: 90 10 00 19 mov %i1, %o0
4000a5e0: 92 10 20 01 mov 1, %o1
4000a5e4: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a5e8: 96 10 00 1b mov %i3, %o3
4000a5ec: 9f c5 c0 00 call %l7
4000a5f0: 94 12 a1 20 or %o2, 0x120, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000a5f4: 10 bf ff e9 b 4000a598 <_Heap_Walk+0x124>
4000a5f8: 82 10 20 00 clr %g1
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
4000a5fc: 90 10 00 19 mov %i1, %o0
4000a600: 92 10 20 01 mov 1, %o1
4000a604: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a608: 96 10 00 10 mov %l0, %o3
4000a60c: 9f c5 c0 00 call %l7
4000a610: 94 12 a1 40 or %o2, 0x140, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000a614: 10 bf ff e1 b 4000a598 <_Heap_Walk+0x124>
4000a618: 82 10 20 00 clr %g1
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
4000a61c: 92 10 20 01 mov 1, %o1
4000a620: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a624: 96 10 00 1c mov %i4, %o3
4000a628: 9f c5 c0 00 call %l7
4000a62c: 94 12 a1 68 or %o2, 0x168, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000a630: 10 bf ff da b 4000a598 <_Heap_Walk+0x124>
4000a634: 82 10 20 00 clr %g1
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
4000a638: 92 10 20 01 mov 1, %o1
4000a63c: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a640: 9f c5 c0 00 call %l7
4000a644: 94 12 a1 a0 or %o2, 0x1a0, %o2 ! 400179a0 <__log2table+0x290>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000a648: 10 bf ff d4 b 4000a598 <_Heap_Walk+0x124>
4000a64c: 82 10 20 00 clr %g1
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
4000a650: fa 06 20 08 ld [ %i0 + 8 ], %i5
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
4000a654: e8 06 20 10 ld [ %i0 + 0x10 ], %l4
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
4000a658: 80 a6 00 1d cmp %i0, %i5
4000a65c: 02 80 00 0d be 4000a690 <_Heap_Walk+0x21c>
4000a660: da 06 20 20 ld [ %i0 + 0x20 ], %o5
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000a664: 80 a3 40 1d cmp %o5, %i5
4000a668: 28 80 00 bf bleu,a 4000a964 <_Heap_Walk+0x4f0> <== ALWAYS TAKEN
4000a66c: e6 06 20 24 ld [ %i0 + 0x24 ], %l3
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
4000a670: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000a674: 92 10 20 01 mov 1, %o1
4000a678: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a67c: 96 10 00 1d mov %i5, %o3
4000a680: 9f c5 c0 00 call %l7
4000a684: 94 12 a2 18 or %o2, 0x218, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000a688: 10 bf ff c4 b 4000a598 <_Heap_Walk+0x124>
4000a68c: 82 10 20 00 clr %g1
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
4000a690: 27 10 00 5f sethi %hi(0x40017c00), %l3
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
4000a694: 25 10 00 5f sethi %hi(0x40017c00), %l2
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
4000a698: aa 10 00 1c mov %i4, %l5
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
4000a69c: a6 14 e0 48 or %l3, 0x48, %l3
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
4000a6a0: a4 14 a0 30 or %l2, 0x30, %l2
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
4000a6a4: 29 10 00 5e sethi %hi(0x40017800), %l4
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000a6a8: ac 0d bf fe and %l6, -2, %l6
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4000a6ac: ba 05 80 15 add %l6, %l5, %i5
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000a6b0: 80 a3 40 1d cmp %o5, %i5
4000a6b4: 28 80 00 0b bleu,a 4000a6e0 <_Heap_Walk+0x26c> <== ALWAYS TAKEN
4000a6b8: de 06 20 24 ld [ %i0 + 0x24 ], %o7
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
(*printer)(
4000a6bc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000a6c0: 92 10 20 01 mov 1, %o1
4000a6c4: 96 10 00 15 mov %l5, %o3
4000a6c8: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a6cc: 98 10 00 1d mov %i5, %o4
4000a6d0: 9f c5 c0 00 call %l7
4000a6d4: 94 12 a2 c0 or %o2, 0x2c0, %o2
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
4000a6d8: 10 bf ff 75 b 4000a4ac <_Heap_Walk+0x38>
4000a6dc: 82 10 20 00 clr %g1
4000a6e0: 80 a3 c0 1d cmp %o7, %i5
4000a6e4: 0a bf ff f7 bcs 4000a6c0 <_Heap_Walk+0x24c>
4000a6e8: 90 10 00 19 mov %i1, %o0
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
4000a6ec: 9e 1d 40 11 xor %l5, %l1, %o7
4000a6f0: 80 a0 00 0f cmp %g0, %o7
4000a6f4: 9a 40 20 00 addx %g0, 0, %o5
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
4000a6f8: 90 10 00 16 mov %l6, %o0
4000a6fc: da 27 bf fc st %o5, [ %fp + -4 ]
4000a700: 7f ff dd 1c call 40001b70 <.urem>
4000a704: 92 10 00 1b mov %i3, %o1
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
4000a708: 80 a2 20 00 cmp %o0, 0
4000a70c: 02 80 00 18 be 4000a76c <_Heap_Walk+0x2f8>
4000a710: da 07 bf fc ld [ %fp + -4 ], %o5
4000a714: 80 8b 60 ff btst 0xff, %o5
4000a718: 12 80 00 8b bne 4000a944 <_Heap_Walk+0x4d0>
4000a71c: 90 10 00 19 mov %i1, %o0
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000a720: de 07 60 04 ld [ %i5 + 4 ], %o7
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
4000a724: 80 8b e0 01 btst 1, %o7
4000a728: 02 80 00 2b be 4000a7d4 <_Heap_Walk+0x360>
4000a72c: 80 a6 a0 00 cmp %i2, 0
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
4000a730: 22 80 00 21 be,a 4000a7b4 <_Heap_Walk+0x340>
4000a734: da 05 40 00 ld [ %l5 ], %o5
(*printer)(
4000a738: 90 10 00 19 mov %i1, %o0
4000a73c: 92 10 20 00 clr %o1
4000a740: 94 10 00 12 mov %l2, %o2
4000a744: 96 10 00 15 mov %l5, %o3
4000a748: 9f c5 c0 00 call %l7
4000a74c: 98 10 00 16 mov %l6, %o4
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
4000a750: 80 a7 00 1d cmp %i4, %i5
4000a754: 02 80 00 51 be 4000a898 <_Heap_Walk+0x424>
4000a758: aa 10 00 1d mov %i5, %l5
4000a75c: ec 07 60 04 ld [ %i5 + 4 ], %l6
4000a760: da 06 20 20 ld [ %i0 + 0x20 ], %o5
4000a764: 10 bf ff d1 b 4000a6a8 <_Heap_Walk+0x234>
4000a768: b4 0d a0 01 and %l6, 1, %i2
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
4000a76c: 80 a5 80 10 cmp %l6, %l0
4000a770: 0a 80 00 69 bcs 4000a914 <_Heap_Walk+0x4a0>
4000a774: 80 8b 60 ff btst 0xff, %o5
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
4000a778: 80 a5 40 1d cmp %l5, %i5
4000a77c: 2a bf ff ea bcs,a 4000a724 <_Heap_Walk+0x2b0>
4000a780: de 07 60 04 ld [ %i5 + 4 ], %o7
4000a784: 80 8b 60 ff btst 0xff, %o5
4000a788: 22 bf ff e7 be,a 4000a724 <_Heap_Walk+0x2b0>
4000a78c: de 07 60 04 ld [ %i5 + 4 ], %o7
(*printer)(
4000a790: 90 10 00 19 mov %i1, %o0
4000a794: 92 10 20 01 mov 1, %o1
4000a798: 96 10 00 15 mov %l5, %o3
4000a79c: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a7a0: 98 10 00 1d mov %i5, %o4
4000a7a4: 9f c5 c0 00 call %l7
4000a7a8: 94 12 a3 50 or %o2, 0x350, %o2
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
4000a7ac: 10 bf ff 40 b 4000a4ac <_Heap_Walk+0x38>
4000a7b0: 82 10 20 00 clr %g1
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
4000a7b4: 96 10 00 15 mov %l5, %o3
4000a7b8: 90 10 00 19 mov %i1, %o0
4000a7bc: 92 10 20 00 clr %o1
4000a7c0: 94 10 00 13 mov %l3, %o2
4000a7c4: 9f c5 c0 00 call %l7
4000a7c8: 98 10 00 16 mov %l6, %o4
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
4000a7cc: 10 bf ff e2 b 4000a754 <_Heap_Walk+0x2e0>
4000a7d0: 80 a7 00 1d cmp %i4, %i5
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
4000a7d4: da 05 60 0c ld [ %l5 + 0xc ], %o5
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
4000a7d8: de 06 20 08 ld [ %i0 + 8 ], %o7
4000a7dc: 80 a3 c0 0d cmp %o7, %o5
4000a7e0: 02 80 00 3d be 4000a8d4 <_Heap_Walk+0x460>
4000a7e4: d8 06 20 0c ld [ %i0 + 0xc ], %o4
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
4000a7e8: 80 a6 00 0d cmp %i0, %o5
4000a7ec: 02 80 00 40 be 4000a8ec <_Heap_Walk+0x478>
4000a7f0: 96 15 23 f8 or %l4, 0x3f8, %o3
block->next,
block->next == last_free_block ?
4000a7f4: de 05 60 08 ld [ %l5 + 8 ], %o7
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
4000a7f8: 80 a3 00 0f cmp %o4, %o7
4000a7fc: 02 80 00 33 be 4000a8c8 <_Heap_Walk+0x454>
4000a800: 80 a6 00 0f cmp %i0, %o7
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
4000a804: 02 80 00 37 be 4000a8e0 <_Heap_Walk+0x46c>
4000a808: 98 15 23 f8 or %l4, 0x3f8, %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)(
4000a80c: d6 23 a0 5c st %o3, [ %sp + 0x5c ]
4000a810: d8 23 a0 64 st %o4, [ %sp + 0x64 ]
4000a814: de 23 a0 60 st %o7, [ %sp + 0x60 ]
4000a818: 90 10 00 19 mov %i1, %o0
4000a81c: 92 10 20 00 clr %o1
4000a820: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a824: 96 10 00 15 mov %l5, %o3
4000a828: 94 12 a3 88 or %o2, 0x388, %o2
4000a82c: 9f c5 c0 00 call %l7
4000a830: 98 10 00 16 mov %l6, %o4
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
4000a834: da 07 40 00 ld [ %i5 ], %o5
4000a838: 80 a5 80 0d cmp %l6, %o5
4000a83c: 12 80 00 19 bne 4000a8a0 <_Heap_Walk+0x42c>
4000a840: 80 a6 a0 00 cmp %i2, 0
);
return false;
}
if ( !prev_used ) {
4000a844: 02 80 00 2d be 4000a8f8 <_Heap_Walk+0x484>
4000a848: 90 10 00 19 mov %i1, %o0
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
4000a84c: c4 06 20 08 ld [ %i0 + 8 ], %g2
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
4000a850: 80 a6 00 02 cmp %i0, %g2
4000a854: 02 80 00 0b be 4000a880 <_Heap_Walk+0x40c> <== NEVER TAKEN
4000a858: 92 10 20 01 mov 1, %o1
if ( free_block == block ) {
4000a85c: 80 a5 40 02 cmp %l5, %g2
4000a860: 02 bf ff bd be 4000a754 <_Heap_Walk+0x2e0>
4000a864: 80 a7 00 1d cmp %i4, %i5
return true;
}
free_block = free_block->next;
4000a868: c4 00 a0 08 ld [ %g2 + 8 ], %g2
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
4000a86c: 80 a6 00 02 cmp %i0, %g2
4000a870: 12 bf ff fc bne 4000a860 <_Heap_Walk+0x3ec>
4000a874: 80 a5 40 02 cmp %l5, %g2
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
4000a878: 90 10 00 19 mov %i1, %o0
4000a87c: 92 10 20 01 mov 1, %o1
4000a880: 15 10 00 5f sethi %hi(0x40017c00), %o2
4000a884: 96 10 00 15 mov %l5, %o3
4000a888: 9f c5 c0 00 call %l7
4000a88c: 94 12 a0 70 or %o2, 0x70, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000a890: 10 bf ff 42 b 4000a598 <_Heap_Walk+0x124>
4000a894: 82 10 20 00 clr %g1
}
block = next_block;
} while ( block != first_block );
return true;
4000a898: 10 bf ff 05 b 4000a4ac <_Heap_Walk+0x38>
4000a89c: 82 10 20 01 mov 1, %g1
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
4000a8a0: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
4000a8a4: 90 10 00 19 mov %i1, %o0
4000a8a8: 92 10 20 01 mov 1, %o1
4000a8ac: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a8b0: 96 10 00 15 mov %l5, %o3
4000a8b4: 94 12 a3 c0 or %o2, 0x3c0, %o2
4000a8b8: 9f c5 c0 00 call %l7
4000a8bc: 98 10 00 16 mov %l6, %o4
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000a8c0: 10 bf ff 36 b 4000a598 <_Heap_Walk+0x124>
4000a8c4: 82 10 20 00 clr %g1
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
4000a8c8: 03 10 00 5e sethi %hi(0x40017800), %g1
4000a8cc: 10 bf ff d0 b 4000a80c <_Heap_Walk+0x398>
4000a8d0: 98 10 60 50 or %g1, 0x50, %o4 ! 40017850 <__log2table+0x140>
4000a8d4: 03 10 00 5e sethi %hi(0x40017800), %g1
4000a8d8: 10 bf ff c7 b 4000a7f4 <_Heap_Walk+0x380>
4000a8dc: 96 10 60 30 or %g1, 0x30, %o3 ! 40017830 <__log2table+0x120>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
4000a8e0: 03 10 00 5e sethi %hi(0x40017800), %g1
4000a8e4: 10 bf ff ca b 4000a80c <_Heap_Walk+0x398>
4000a8e8: 98 10 60 60 or %g1, 0x60, %o4 ! 40017860 <__log2table+0x150>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
4000a8ec: 17 10 00 5e sethi %hi(0x40017800), %o3
4000a8f0: 10 bf ff c1 b 4000a7f4 <_Heap_Walk+0x380>
4000a8f4: 96 12 e0 40 or %o3, 0x40, %o3 ! 40017840 <__log2table+0x130>
return false;
}
if ( !prev_used ) {
(*printer)(
4000a8f8: 92 10 20 01 mov 1, %o1
4000a8fc: 15 10 00 5f sethi %hi(0x40017c00), %o2
4000a900: 96 10 00 15 mov %l5, %o3
4000a904: 9f c5 c0 00 call %l7
4000a908: 94 12 a0 00 mov %o2, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000a90c: 10 bf ff 23 b 4000a598 <_Heap_Walk+0x124>
4000a910: 82 10 20 00 clr %g1
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
4000a914: 02 bf ff 9a be 4000a77c <_Heap_Walk+0x308> <== NEVER TAKEN
4000a918: 80 a5 40 1d cmp %l5, %i5
(*printer)(
4000a91c: 90 10 00 19 mov %i1, %o0
4000a920: 92 10 20 01 mov 1, %o1
4000a924: 96 10 00 15 mov %l5, %o3
4000a928: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a92c: 98 10 00 16 mov %l6, %o4
4000a930: 94 12 a3 20 or %o2, 0x320, %o2
4000a934: 9f c5 c0 00 call %l7
4000a938: 9a 10 00 10 mov %l0, %o5
block,
block_size,
min_block_size
);
return false;
4000a93c: 10 bf fe dc b 4000a4ac <_Heap_Walk+0x38>
4000a940: 82 10 20 00 clr %g1
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
4000a944: 92 10 20 01 mov 1, %o1
4000a948: 96 10 00 15 mov %l5, %o3
4000a94c: 15 10 00 5e sethi %hi(0x40017800), %o2
4000a950: 98 10 00 16 mov %l6, %o4
4000a954: 9f c5 c0 00 call %l7
4000a958: 94 12 a2 f0 or %o2, 0x2f0, %o2
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
4000a95c: 10 bf fe d4 b 4000a4ac <_Heap_Walk+0x38>
4000a960: 82 10 20 00 clr %g1
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000a964: 80 a4 c0 1d cmp %l3, %i5
4000a968: 0a bf ff 43 bcs 4000a674 <_Heap_Walk+0x200> <== NEVER TAKEN
4000a96c: 90 10 00 19 mov %i1, %o0
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
4000a970: da 27 bf fc st %o5, [ %fp + -4 ]
4000a974: 90 07 60 08 add %i5, 8, %o0
4000a978: 7f ff dc 7e call 40001b70 <.urem>
4000a97c: 92 10 00 14 mov %l4, %o1
);
return false;
}
if (
4000a980: 80 a2 20 00 cmp %o0, 0
4000a984: 12 80 00 36 bne 4000aa5c <_Heap_Walk+0x5e8> <== NEVER TAKEN
4000a988: da 07 bf fc ld [ %fp + -4 ], %o5
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000a98c: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000a990: 82 08 7f fe and %g1, -2, %g1
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000a994: 82 07 40 01 add %i5, %g1, %g1
4000a998: c2 00 60 04 ld [ %g1 + 4 ], %g1
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
4000a99c: 80 88 60 01 btst 1, %g1
4000a9a0: 12 80 00 27 bne 4000aa3c <_Heap_Walk+0x5c8> <== NEVER TAKEN
4000a9a4: a4 10 00 1d mov %i5, %l2
4000a9a8: 10 80 00 19 b 4000aa0c <_Heap_Walk+0x598>
4000a9ac: 82 10 00 18 mov %i0, %g1
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
4000a9b0: 80 a6 00 1d cmp %i0, %i5
4000a9b4: 02 bf ff 37 be 4000a690 <_Heap_Walk+0x21c>
4000a9b8: 80 a7 40 0d cmp %i5, %o5
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4000a9bc: 0a bf ff 2e bcs 4000a674 <_Heap_Walk+0x200>
4000a9c0: 90 10 00 19 mov %i1, %o0
4000a9c4: 80 a7 40 13 cmp %i5, %l3
4000a9c8: 18 bf ff 2c bgu 4000a678 <_Heap_Walk+0x204> <== NEVER TAKEN
4000a9cc: 92 10 20 01 mov 1, %o1
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
4000a9d0: da 27 bf fc st %o5, [ %fp + -4 ]
4000a9d4: 90 07 60 08 add %i5, 8, %o0
4000a9d8: 7f ff dc 66 call 40001b70 <.urem>
4000a9dc: 92 10 00 14 mov %l4, %o1
);
return false;
}
if (
4000a9e0: 80 a2 20 00 cmp %o0, 0
4000a9e4: 12 80 00 1e bne 4000aa5c <_Heap_Walk+0x5e8>
4000a9e8: da 07 bf fc ld [ %fp + -4 ], %o5
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4000a9ec: de 07 60 04 ld [ %i5 + 4 ], %o7
4000a9f0: 82 10 00 12 mov %l2, %g1
4000a9f4: 9e 0b ff fe and %o7, -2, %o7
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4000a9f8: 9e 03 c0 1d add %o7, %i5, %o7
4000a9fc: de 03 e0 04 ld [ %o7 + 4 ], %o7
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
4000aa00: 80 8b e0 01 btst 1, %o7
4000aa04: 12 80 00 0e bne 4000aa3c <_Heap_Walk+0x5c8>
4000aa08: a4 10 00 1d mov %i5, %l2
);
return false;
}
if ( free_block->prev != prev_block ) {
4000aa0c: d8 07 60 0c ld [ %i5 + 0xc ], %o4
4000aa10: 80 a3 00 01 cmp %o4, %g1
4000aa14: 22 bf ff e7 be,a 4000a9b0 <_Heap_Walk+0x53c>
4000aa18: fa 07 60 08 ld [ %i5 + 8 ], %i5
(*printer)(
4000aa1c: 90 10 00 19 mov %i1, %o0
4000aa20: 92 10 20 01 mov 1, %o1
4000aa24: 15 10 00 5e sethi %hi(0x40017800), %o2
4000aa28: 96 10 00 1d mov %i5, %o3
4000aa2c: 9f c5 c0 00 call %l7
4000aa30: 94 12 a2 88 or %o2, 0x288, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000aa34: 10 bf fe d9 b 4000a598 <_Heap_Walk+0x124>
4000aa38: 82 10 20 00 clr %g1
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
4000aa3c: 90 10 00 19 mov %i1, %o0
4000aa40: 92 10 20 01 mov 1, %o1
4000aa44: 15 10 00 5e sethi %hi(0x40017800), %o2
4000aa48: 96 10 00 1d mov %i5, %o3
4000aa4c: 9f c5 c0 00 call %l7
4000aa50: 94 12 a2 68 or %o2, 0x268, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000aa54: 10 bf fe d1 b 4000a598 <_Heap_Walk+0x124>
4000aa58: 82 10 20 00 clr %g1
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
4000aa5c: 90 10 00 19 mov %i1, %o0
4000aa60: 92 10 20 01 mov 1, %o1
4000aa64: 15 10 00 5e sethi %hi(0x40017800), %o2
4000aa68: 96 10 00 1d mov %i5, %o3
4000aa6c: 9f c5 c0 00 call %l7
4000aa70: 94 12 a2 38 or %o2, 0x238, %o2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4000aa74: 10 bf fe c9 b 4000a598 <_Heap_Walk+0x124>
4000aa78: 82 10 20 00 clr %g1
40008e14 <_IO_Initialize_all_drivers>:
_IO_Driver_address_table[index] = driver_table[index];
}
void _IO_Initialize_all_drivers( void )
{
40008e14: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40008e18: 39 10 00 83 sethi %hi(0x40020c00), %i4
40008e1c: c2 07 20 08 ld [ %i4 + 8 ], %g1 ! 40020c08 <_IO_Number_of_drivers>
40008e20: ba 10 20 00 clr %i5
40008e24: 80 a0 60 00 cmp %g1, 0
40008e28: 02 80 00 0b be 40008e54 <_IO_Initialize_all_drivers+0x40> <== NEVER TAKEN
40008e2c: b8 17 20 08 or %i4, 8, %i4
(void) rtems_io_initialize( major, 0, NULL );
40008e30: 90 10 00 1d mov %i5, %o0
40008e34: 92 10 20 00 clr %o1
40008e38: 40 00 15 c1 call 4000e53c <rtems_io_initialize>
40008e3c: 94 10 20 00 clr %o2
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40008e40: c2 07 00 00 ld [ %i4 ], %g1
40008e44: ba 07 60 01 inc %i5
40008e48: 80 a0 40 1d cmp %g1, %i5
40008e4c: 18 bf ff fa bgu 40008e34 <_IO_Initialize_all_drivers+0x20>
40008e50: 90 10 00 1d mov %i5, %o0
40008e54: 81 c7 e0 08 ret
40008e58: 81 e8 00 00 restore
40008d44 <_IO_Manager_initialization>:
#include <rtems/score/wkspace.h>
#include <string.h>
void _IO_Manager_initialization(void)
{
40008d44: 9d e3 bf a0 save %sp, -96, %sp
uint32_t index;
rtems_driver_address_table *driver_table;
uint32_t drivers_in_table;
uint32_t number_of_drivers;
driver_table = rtems_configuration_get_device_driver_table();
40008d48: 03 10 00 75 sethi %hi(0x4001d400), %g1
40008d4c: 82 10 62 18 or %g1, 0x218, %g1 ! 4001d618 <Configuration>
drivers_in_table = rtems_configuration_get_number_of_device_drivers();
40008d50: f8 00 60 38 ld [ %g1 + 0x38 ], %i4
number_of_drivers = rtems_configuration_get_maximum_drivers();
40008d54: f6 00 60 34 ld [ %g1 + 0x34 ], %i3
/*
* If the user claims there are less drivers than are actually in
* the table, then let's just go with the table's count.
*/
if ( number_of_drivers <= drivers_in_table )
40008d58: 80 a7 00 1b cmp %i4, %i3
40008d5c: 0a 80 00 08 bcs 40008d7c <_IO_Manager_initialization+0x38>
40008d60: fa 00 60 3c ld [ %g1 + 0x3c ], %i5
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
_IO_Driver_address_table = driver_table;
40008d64: 03 10 00 83 sethi %hi(0x40020c00), %g1
40008d68: fa 20 60 0c st %i5, [ %g1 + 0xc ] ! 40020c0c <_IO_Driver_address_table>
_IO_Number_of_drivers = number_of_drivers;
40008d6c: 03 10 00 83 sethi %hi(0x40020c00), %g1
40008d70: f8 20 60 08 st %i4, [ %g1 + 8 ] ! 40020c08 <_IO_Number_of_drivers>
return;
40008d74: 81 c7 e0 08 ret
40008d78: 81 e8 00 00 restore
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
40008d7c: 83 2e e0 03 sll %i3, 3, %g1
40008d80: b5 2e e0 05 sll %i3, 5, %i2
40008d84: b4 26 80 01 sub %i2, %g1, %i2
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
40008d88: 40 00 0d 2f call 4000c244 <_Workspace_Allocate_or_fatal_error>
40008d8c: 90 10 00 1a mov %i2, %o0
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
40008d90: 03 10 00 83 sethi %hi(0x40020c00), %g1
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
40008d94: 33 10 00 83 sethi %hi(0x40020c00), %i1
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
40008d98: f6 20 60 08 st %i3, [ %g1 + 8 ]
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
40008d9c: d0 26 60 0c st %o0, [ %i1 + 0xc ]
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
memset(
40008da0: 92 10 20 00 clr %o1
40008da4: 40 00 21 75 call 40011378 <memset>
40008da8: 94 10 00 1a mov %i2, %o2
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
40008dac: 80 a7 20 00 cmp %i4, 0
40008db0: 02 bf ff f1 be 40008d74 <_IO_Manager_initialization+0x30> <== NEVER TAKEN
40008db4: c8 06 60 0c ld [ %i1 + 0xc ], %g4
#include <rtems/score/thread.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _IO_Manager_initialization(void)
40008db8: 85 2f 20 03 sll %i4, 3, %g2
40008dbc: b7 2f 20 05 sll %i4, 5, %i3
40008dc0: 82 10 20 00 clr %g1
40008dc4: b6 26 c0 02 sub %i3, %g2, %i3
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
40008dc8: c4 07 40 01 ld [ %i5 + %g1 ], %g2
40008dcc: 86 07 40 01 add %i5, %g1, %g3
40008dd0: c4 21 00 01 st %g2, [ %g4 + %g1 ]
40008dd4: f8 00 e0 04 ld [ %g3 + 4 ], %i4
40008dd8: 84 01 00 01 add %g4, %g1, %g2
40008ddc: f8 20 a0 04 st %i4, [ %g2 + 4 ]
40008de0: f8 00 e0 08 ld [ %g3 + 8 ], %i4
40008de4: 82 00 60 18 add %g1, 0x18, %g1
40008de8: f8 20 a0 08 st %i4, [ %g2 + 8 ]
40008dec: f8 00 e0 0c ld [ %g3 + 0xc ], %i4
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
40008df0: 80 a0 40 1b cmp %g1, %i3
_IO_Driver_address_table[index] = driver_table[index];
40008df4: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
40008df8: f8 00 e0 10 ld [ %g3 + 0x10 ], %i4
40008dfc: f8 20 a0 10 st %i4, [ %g2 + 0x10 ]
40008e00: c6 00 e0 14 ld [ %g3 + 0x14 ], %g3
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
40008e04: 12 bf ff f1 bne 40008dc8 <_IO_Manager_initialization+0x84>
40008e08: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
40008e0c: 81 c7 e0 08 ret
40008e10: 81 e8 00 00 restore
40009b0c <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
40009b0c: 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 );
40009b10: 13 10 00 2f sethi %hi(0x4000bc00), %o1
40009b14: 90 07 bf f4 add %fp, -12, %o0
40009b18: 92 12 60 7c or %o1, 0x7c, %o1
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
40009b1c: f0 27 bf f4 st %i0, [ %fp + -12 ]
40009b20: f2 2f bf f8 stb %i1, [ %fp + -8 ]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
40009b24: 40 00 08 61 call 4000bca8 <_User_extensions_Iterate>
40009b28: 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;
40009b2c: 05 10 00 81 sethi %hi(0x40020400), %g2 <== NOT EXECUTED
40009b30: 82 10 a3 ac or %g2, 0x3ac, %g1 ! 400207ac <_Internal_errors_What_happened><== NOT EXECUTED
40009b34: f0 20 a3 ac st %i0, [ %g2 + 0x3ac ] <== NOT EXECUTED
_Internal_errors_What_happened.is_internal = is_internal;
40009b38: f2 28 60 04 stb %i1, [ %g1 + 4 ] <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
40009b3c: 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;
40009b40: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
40009b44: 03 10 00 81 sethi %hi(0x40020400), %g1 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
40009b48: 7f ff e2 62 call 400024d0 <sparc_disable_interrupts> <== NOT EXECUTED
40009b4c: c4 20 63 b8 st %g2, [ %g1 + 0x3b8 ] ! 400207b8 <_System_state_Current><== NOT EXECUTED
40009b50: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
40009b54: 30 80 00 00 b,a 40009b54 <_Internal_error_Occurred+0x48> <== NOT EXECUTED
40009bc4 <_Objects_Allocate>:
#endif
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
40009bc4: 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 )
40009bc8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40009bcc: 80 a0 60 00 cmp %g1, 0
40009bd0: 02 80 00 26 be 40009c68 <_Objects_Allocate+0xa4> <== NEVER TAKEN
40009bd4: ba 10 00 18 mov %i0, %i5
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
40009bd8: b8 06 20 20 add %i0, 0x20, %i4
40009bdc: 7f ff fd 4c call 4000910c <_Chain_Get>
40009be0: 90 10 00 1c mov %i4, %o0
if ( information->auto_extend ) {
40009be4: c2 0f 60 12 ldub [ %i5 + 0x12 ], %g1
40009be8: 80 a0 60 00 cmp %g1, 0
40009bec: 02 80 00 16 be 40009c44 <_Objects_Allocate+0x80>
40009bf0: 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 ) {
40009bf4: 80 a2 20 00 cmp %o0, 0
40009bf8: 02 80 00 15 be 40009c4c <_Objects_Allocate+0x88>
40009bfc: 01 00 00 00 nop
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
40009c00: c4 07 60 08 ld [ %i5 + 8 ], %g2
40009c04: d0 06 20 08 ld [ %i0 + 8 ], %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
40009c08: d2 17 60 14 lduh [ %i5 + 0x14 ], %o1
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
40009c0c: 03 00 00 3f sethi %hi(0xfc00), %g1
40009c10: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40009c14: 90 0a 00 01 and %o0, %g1, %o0
40009c18: 82 08 80 01 and %g2, %g1, %g1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
40009c1c: 40 00 3f 96 call 40019a74 <.udiv>
40009c20: 90 22 00 01 sub %o0, %g1, %o0
information->inactive_per_block[ block ]--;
40009c24: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
40009c28: 91 2a 20 02 sll %o0, 2, %o0
40009c2c: c6 00 40 08 ld [ %g1 + %o0 ], %g3
information->inactive--;
40009c30: c4 17 60 2c lduh [ %i5 + 0x2c ], %g2
block = (uint32_t) _Objects_Get_index( the_object->id ) -
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
40009c34: 86 00 ff ff add %g3, -1, %g3
40009c38: c6 20 40 08 st %g3, [ %g1 + %o0 ]
information->inactive--;
40009c3c: 82 00 bf ff add %g2, -1, %g1
40009c40: c2 37 60 2c sth %g1, [ %i5 + 0x2c ]
);
}
#endif
return the_object;
}
40009c44: 81 c7 e0 08 ret
40009c48: 81 e8 00 00 restore
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
_Objects_Extend_information( information );
40009c4c: 40 00 00 10 call 40009c8c <_Objects_Extend_information>
40009c50: 90 10 00 1d mov %i5, %o0
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
40009c54: 7f ff fd 2e call 4000910c <_Chain_Get>
40009c58: 90 10 00 1c mov %i4, %o0
}
if ( the_object ) {
40009c5c: b0 92 20 00 orcc %o0, 0, %i0
40009c60: 32 bf ff e9 bne,a 40009c04 <_Objects_Allocate+0x40>
40009c64: c4 07 60 08 ld [ %i5 + 8 ], %g2
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
return NULL;
40009c68: 81 c7 e0 08 ret
40009c6c: 91 e8 20 00 restore %g0, 0, %o0
40009c8c <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
40009c8c: 9d e3 bf 90 save %sp, -112, %sp
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
40009c90: f2 06 20 34 ld [ %i0 + 0x34 ], %i1
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
40009c94: e0 16 20 0a lduh [ %i0 + 0xa ], %l0
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
40009c98: 80 a6 60 00 cmp %i1, 0
40009c9c: 02 80 00 a1 be 40009f20 <_Objects_Extend_information+0x294>
40009ca0: e2 16 20 10 lduh [ %i0 + 0x10 ], %l1
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
40009ca4: f6 16 20 14 lduh [ %i0 + 0x14 ], %i3
40009ca8: a3 2c 60 10 sll %l1, 0x10, %l1
40009cac: 92 10 00 1b mov %i3, %o1
40009cb0: 40 00 3f 71 call 40019a74 <.udiv>
40009cb4: 91 34 60 10 srl %l1, 0x10, %o0
40009cb8: 91 2a 20 10 sll %o0, 0x10, %o0
40009cbc: b5 32 20 10 srl %o0, 0x10, %i2
for ( ; block < block_count; block++ ) {
40009cc0: 80 a6 a0 00 cmp %i2, 0
40009cc4: 02 80 00 af be 40009f80 <_Objects_Extend_information+0x2f4><== NEVER TAKEN
40009cc8: 90 10 00 1b mov %i3, %o0
if ( information->object_blocks[ block ] == NULL ) {
40009ccc: c2 06 40 00 ld [ %i1 ], %g1
40009cd0: 80 a0 60 00 cmp %g1, 0
40009cd4: 02 80 00 b1 be 40009f98 <_Objects_Extend_information+0x30c><== NEVER TAKEN
40009cd8: b8 10 00 10 mov %l0, %i4
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
40009cdc: 10 80 00 06 b 40009cf4 <_Objects_Extend_information+0x68>
40009ce0: ba 10 20 00 clr %i5
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
40009ce4: c2 06 40 01 ld [ %i1 + %g1 ], %g1
40009ce8: 80 a0 60 00 cmp %g1, 0
40009cec: 22 80 00 08 be,a 40009d0c <_Objects_Extend_information+0x80>
40009cf0: b6 10 20 00 clr %i3
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
40009cf4: ba 07 60 01 inc %i5
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
40009cf8: b8 07 00 1b add %i4, %i3, %i4
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
40009cfc: 80 a6 80 1d cmp %i2, %i5
40009d00: 18 bf ff f9 bgu 40009ce4 <_Objects_Extend_information+0x58>
40009d04: 83 2f 60 02 sll %i5, 2, %g1
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
40009d08: b6 10 20 01 mov 1, %i3
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
40009d0c: b3 34 60 10 srl %l1, 0x10, %i1
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
40009d10: 03 00 00 3f sethi %hi(0xfc00), %g1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
40009d14: b2 06 40 08 add %i1, %o0, %i1
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
40009d18: 82 10 63 ff or %g1, 0x3ff, %g1
40009d1c: 80 a6 40 01 cmp %i1, %g1
40009d20: 18 80 00 9c bgu 40009f90 <_Objects_Extend_information+0x304>
40009d24: 01 00 00 00 nop
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
40009d28: 40 00 3f 19 call 4001998c <.umul>
40009d2c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
if ( information->auto_extend ) {
40009d30: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
40009d34: 80 a0 60 00 cmp %g1, 0
40009d38: 02 80 00 6d be 40009eec <_Objects_Extend_information+0x260>
40009d3c: 01 00 00 00 nop
new_object_block = _Workspace_Allocate( block_size );
40009d40: 40 00 09 33 call 4000c20c <_Workspace_Allocate>
40009d44: 01 00 00 00 nop
if ( !new_object_block )
40009d48: a2 92 20 00 orcc %o0, 0, %l1
40009d4c: 02 80 00 91 be 40009f90 <_Objects_Extend_information+0x304>
40009d50: 01 00 00 00 nop
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
40009d54: 80 8e e0 ff btst 0xff, %i3
40009d58: 22 80 00 42 be,a 40009e60 <_Objects_Extend_information+0x1d4>
40009d5c: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
40009d60: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
*/
/*
* Up the block count and maximum
*/
block_count++;
40009d64: b6 06 a0 01 add %i2, 1, %i3
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
40009d68: 80 a0 60 00 cmp %g1, 0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
40009d6c: 91 2e e0 01 sll %i3, 1, %o0
40009d70: 90 02 00 1b add %o0, %i3, %o0
((maximum + minimum_index) * sizeof(Objects_Control *));
40009d74: 90 06 40 08 add %i1, %o0, %o0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
40009d78: 90 02 00 10 add %o0, %l0, %o0
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
40009d7c: 12 80 00 60 bne 40009efc <_Objects_Extend_information+0x270>
40009d80: 91 2a 20 02 sll %o0, 2, %o0
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
return;
}
} else {
object_blocks = _Workspace_Allocate_or_fatal_error( block_size );
40009d84: 40 00 09 30 call 4000c244 <_Workspace_Allocate_or_fatal_error>
40009d88: 01 00 00 00 nop
40009d8c: a4 10 00 08 mov %o0, %l2
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
40009d90: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
/*
* Break the block into the various sections.
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
object_blocks, block_count * sizeof(void*) );
40009d94: b7 2e e0 02 sll %i3, 2, %i3
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
40009d98: 80 a4 00 01 cmp %l0, %g1
40009d9c: a6 04 80 1b add %l2, %i3, %l3
40009da0: 0a 80 00 67 bcs 40009f3c <_Objects_Extend_information+0x2b0>
40009da4: b6 04 c0 1b add %l3, %i3, %i3
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
40009da8: 85 2c 20 02 sll %l0, 2, %g2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
40009dac: 80 a4 20 00 cmp %l0, 0
40009db0: 02 80 00 07 be 40009dcc <_Objects_Extend_information+0x140><== NEVER TAKEN
40009db4: 82 10 20 00 clr %g1
local_table[ index ] = NULL;
40009db8: c0 20 40 1b clr [ %g1 + %i3 ]
40009dbc: 82 00 60 04 add %g1, 4, %g1
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
40009dc0: 80 a0 40 02 cmp %g1, %g2
40009dc4: 32 bf ff fe bne,a 40009dbc <_Objects_Extend_information+0x130><== NEVER TAKEN
40009dc8: c0 20 40 1b clr [ %g1 + %i3 ] <== NOT EXECUTED
40009dcc: b5 2e a0 02 sll %i2, 2, %i2
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
40009dd0: c6 16 20 14 lduh [ %i0 + 0x14 ], %g3
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
40009dd4: c0 24 80 1a clr [ %l2 + %i2 ]
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
40009dd8: 82 07 00 03 add %i4, %g3, %g1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
40009ddc: 80 a7 00 01 cmp %i4, %g1
40009de0: 1a 80 00 0b bcc 40009e0c <_Objects_Extend_information+0x180><== NEVER TAKEN
40009de4: c0 24 c0 1a clr [ %l3 + %i2 ]
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
40009de8: 85 2f 20 02 sll %i4, 2, %g2
40009dec: 87 28 e0 02 sll %g3, 2, %g3
40009df0: 84 06 c0 02 add %i3, %g2, %g2
40009df4: 82 10 20 00 clr %g1
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
40009df8: c0 20 80 01 clr [ %g2 + %g1 ]
40009dfc: 82 00 60 04 add %g1, 4, %g1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
40009e00: 80 a0 40 03 cmp %g1, %g3
40009e04: 32 bf ff fe bne,a 40009dfc <_Objects_Extend_information+0x170>
40009e08: c0 20 80 01 clr [ %g2 + %g1 ]
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
40009e0c: 7f ff e1 b1 call 400024d0 <sparc_disable_interrupts>
40009e10: 01 00 00 00 nop
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40009e14: c6 06 00 00 ld [ %i0 ], %g3
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
40009e18: c4 16 20 04 lduh [ %i0 + 4 ], %g2
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
40009e1c: f4 06 20 34 ld [ %i0 + 0x34 ], %i2
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
40009e20: f2 36 20 10 sth %i1, [ %i0 + 0x10 ]
40009e24: 87 28 e0 18 sll %g3, 0x18, %g3
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40009e28: 85 28 a0 1b sll %g2, 0x1b, %g2
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
40009e2c: e4 26 20 34 st %l2, [ %i0 + 0x34 ]
information->inactive_per_block = inactive_per_block;
40009e30: e6 26 20 30 st %l3, [ %i0 + 0x30 ]
information->local_table = local_table;
40009e34: f6 26 20 1c st %i3, [ %i0 + 0x1c ]
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40009e38: 03 00 00 40 sethi %hi(0x10000), %g1
40009e3c: 82 10 c0 01 or %g3, %g1, %g1
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40009e40: 82 10 40 02 or %g1, %g2, %g1
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40009e44: b2 10 40 19 or %g1, %i1, %i1
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
40009e48: f2 26 20 0c st %i1, [ %i0 + 0xc ]
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
40009e4c: 7f ff e1 a5 call 400024e0 <sparc_enable_interrupts>
40009e50: 01 00 00 00 nop
_Workspace_Free( old_tables );
40009e54: 40 00 08 f6 call 4000c22c <_Workspace_Free>
40009e58: 90 10 00 1a mov %i2, %o0
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
40009e5c: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40009e60: bb 2f 60 02 sll %i5, 2, %i5
40009e64: e2 20 40 1d st %l1, [ %g1 + %i5 ]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
40009e68: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40009e6c: d4 16 20 14 lduh [ %i0 + 0x14 ], %o2
40009e70: d2 00 40 1d ld [ %g1 + %i5 ], %o1
40009e74: d6 06 20 18 ld [ %i0 + 0x18 ], %o3
40009e78: 90 07 bf f4 add %fp, -12, %o0
40009e7c: 7f ff fc b4 call 4000914c <_Chain_Initialize>
40009e80: 35 00 00 40 sethi %hi(0x10000), %i2
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
40009e84: 10 80 00 0d b 40009eb8 <_Objects_Extend_information+0x22c>
40009e88: b6 06 20 20 add %i0, 0x20, %i3
the_object->id = _Objects_Build_id(
40009e8c: c6 16 20 04 lduh [ %i0 + 4 ], %g3
40009e90: 85 28 a0 18 sll %g2, 0x18, %g2
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40009e94: 87 28 e0 1b sll %g3, 0x1b, %g3
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40009e98: 84 10 80 1a or %g2, %i2, %g2
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
40009e9c: 84 10 80 03 or %g2, %g3, %g2
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
40009ea0: 84 10 80 1c or %g2, %i4, %g2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
40009ea4: 90 10 00 1b mov %i3, %o0
40009ea8: 92 10 00 01 mov %g1, %o1
index++;
40009eac: b8 07 20 01 inc %i4
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
40009eb0: 7f ff fc 8c call 400090e0 <_Chain_Append>
40009eb4: c4 20 60 08 st %g2, [ %g1 + 8 ]
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
40009eb8: 7f ff fc 95 call 4000910c <_Chain_Get>
40009ebc: 90 07 bf f4 add %fp, -12, %o0
40009ec0: 82 92 20 00 orcc %o0, 0, %g1
40009ec4: 32 bf ff f2 bne,a 40009e8c <_Objects_Extend_information+0x200>
40009ec8: c4 06 00 00 ld [ %i0 ], %g2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
40009ecc: c8 16 20 14 lduh [ %i0 + 0x14 ], %g4
40009ed0: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
40009ed4: c4 16 20 2c lduh [ %i0 + 0x2c ], %g2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
40009ed8: c8 20 c0 1d st %g4, [ %g3 + %i5 ]
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
40009edc: 82 00 80 04 add %g2, %g4, %g1
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
40009ee0: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
40009ee4: 81 c7 e0 08 ret
40009ee8: 81 e8 00 00 restore
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
40009eec: 40 00 08 d6 call 4000c244 <_Workspace_Allocate_or_fatal_error>
40009ef0: 01 00 00 00 nop
40009ef4: 10 bf ff 98 b 40009d54 <_Objects_Extend_information+0xc8>
40009ef8: a2 10 00 08 mov %o0, %l1
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
object_blocks = _Workspace_Allocate( block_size );
40009efc: 40 00 08 c4 call 4000c20c <_Workspace_Allocate>
40009f00: 01 00 00 00 nop
if ( !object_blocks ) {
40009f04: a4 92 20 00 orcc %o0, 0, %l2
40009f08: 32 bf ff a3 bne,a 40009d94 <_Objects_Extend_information+0x108>
40009f0c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
_Workspace_Free( new_object_block );
40009f10: 40 00 08 c7 call 4000c22c <_Workspace_Free>
40009f14: 90 10 00 11 mov %l1, %o0
40009f18: 81 c7 e0 08 ret
40009f1c: 81 e8 00 00 restore
40009f20: d0 16 20 14 lduh [ %i0 + 0x14 ], %o0
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
40009f24: b8 10 00 10 mov %l0, %i4
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
40009f28: b6 10 20 01 mov 1, %i3
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
40009f2c: ba 10 20 00 clr %i5
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
40009f30: b4 10 20 00 clr %i2
40009f34: 10 bf ff 76 b 40009d0c <_Objects_Extend_information+0x80>
40009f38: a3 2c 60 10 sll %l1, 0x10, %l1
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
40009f3c: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
information->object_blocks,
block_count * sizeof(void*) );
40009f40: b5 2e a0 02 sll %i2, 2, %i2
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
40009f44: 90 10 00 12 mov %l2, %o0
40009f48: 40 00 1c cf call 40011284 <memcpy>
40009f4c: 94 10 00 1a mov %i2, %o2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
40009f50: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
40009f54: 94 10 00 1a mov %i2, %o2
40009f58: 40 00 1c cb call 40011284 <memcpy>
40009f5c: 90 10 00 13 mov %l3, %o0
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
40009f60: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
40009f64: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
40009f68: 94 02 80 10 add %o2, %l0, %o2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
40009f6c: 90 10 00 1b mov %i3, %o0
40009f70: 40 00 1c c5 call 40011284 <memcpy>
40009f74: 95 2a a0 02 sll %o2, 2, %o2
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
40009f78: 10 bf ff 97 b 40009dd4 <_Objects_Extend_information+0x148>
40009f7c: c6 16 20 14 lduh [ %i0 + 0x14 ], %g3
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
40009f80: b8 10 00 10 mov %l0, %i4 <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
40009f84: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
40009f88: 10 bf ff 61 b 40009d0c <_Objects_Extend_information+0x80> <== NOT EXECUTED
40009f8c: ba 10 20 00 clr %i5 <== NOT EXECUTED
40009f90: 81 c7 e0 08 ret
40009f94: 81 e8 00 00 restore
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
40009f98: b6 10 20 00 clr %i3 <== NOT EXECUTED
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
40009f9c: 10 bf ff 5c b 40009d0c <_Objects_Extend_information+0x80> <== NOT EXECUTED
40009fa0: ba 10 20 00 clr %i5 <== NOT EXECUTED
4000a054 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
4000a054: 9d e3 bf a0 save %sp, -96, %sp
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
4000a058: 80 a6 60 00 cmp %i1, 0
4000a05c: 02 80 00 19 be 4000a0c0 <_Objects_Get_information+0x6c>
4000a060: 01 00 00 00 nop
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
4000a064: 40 00 12 b2 call 4000eb2c <_Objects_API_maximum_class>
4000a068: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum == 0 )
4000a06c: 80 a2 20 00 cmp %o0, 0
4000a070: 02 80 00 14 be 4000a0c0 <_Objects_Get_information+0x6c>
4000a074: 80 a2 00 19 cmp %o0, %i1
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
4000a078: 0a 80 00 12 bcs 4000a0c0 <_Objects_Get_information+0x6c>
4000a07c: 03 10 00 80 sethi %hi(0x40020000), %g1
return NULL;
if ( !_Objects_Information_table[ the_api ] )
4000a080: b1 2e 20 02 sll %i0, 2, %i0
4000a084: 82 10 62 14 or %g1, 0x214, %g1
4000a088: c2 00 40 18 ld [ %g1 + %i0 ], %g1
4000a08c: 80 a0 60 00 cmp %g1, 0
4000a090: 02 80 00 0c be 4000a0c0 <_Objects_Get_information+0x6c> <== NEVER TAKEN
4000a094: b3 2e 60 02 sll %i1, 2, %i1
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
4000a098: f0 00 40 19 ld [ %g1 + %i1 ], %i0
if ( !info )
4000a09c: 80 a6 20 00 cmp %i0, 0
4000a0a0: 02 80 00 08 be 4000a0c0 <_Objects_Get_information+0x6c> <== NEVER TAKEN
4000a0a4: 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 )
4000a0a8: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
4000a0ac: 80 a0 60 00 cmp %g1, 0
4000a0b0: 02 80 00 04 be 4000a0c0 <_Objects_Get_information+0x6c>
4000a0b4: 01 00 00 00 nop
return NULL;
#endif
return info;
}
4000a0b8: 81 c7 e0 08 ret
4000a0bc: 81 e8 00 00 restore
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
4000a0c0: 81 c7 e0 08 ret
4000a0c4: 91 e8 20 00 restore %g0, 0, %o0
400185e8 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
400185e8: 9d e3 bf 90 save %sp, -112, %sp
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
400185ec: 80 a6 60 00 cmp %i1, 0
400185f0: 02 80 00 11 be 40018634 <_Objects_Get_name_as_string+0x4c>
400185f4: 80 a6 a0 00 cmp %i2, 0
return NULL;
if ( name == NULL )
400185f8: 02 80 00 0f be 40018634 <_Objects_Get_name_as_string+0x4c>
400185fc: ba 96 20 00 orcc %i0, 0, %i5
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
40018600: 02 80 00 3d be 400186f4 <_Objects_Get_name_as_string+0x10c>
40018604: 03 10 00 cf sethi %hi(0x40033c00), %g1
information = _Objects_Get_information_id( tmpId );
40018608: 7f ff e0 5e call 40010780 <_Objects_Get_information_id>
4001860c: 90 10 00 1d mov %i5, %o0
if ( !information )
40018610: b8 92 20 00 orcc %o0, 0, %i4
40018614: 02 80 00 08 be 40018634 <_Objects_Get_name_as_string+0x4c>
40018618: 92 10 00 1d mov %i5, %o1
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
4001861c: 7f ff e0 99 call 40010880 <_Objects_Get>
40018620: 94 07 bf f4 add %fp, -12, %o2
switch ( location ) {
40018624: c2 07 bf f4 ld [ %fp + -12 ], %g1
40018628: 80 a0 60 00 cmp %g1, 0
4001862c: 22 80 00 05 be,a 40018640 <_Objects_Get_name_as_string+0x58>
40018630: c2 0f 20 38 ldub [ %i4 + 0x38 ], %g1
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
40018634: b4 10 20 00 clr %i2
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
40018638: 81 c7 e0 08 ret
4001863c: 91 e8 00 1a restore %g0, %i2, %o0
return NULL;
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
40018640: 80 a0 60 00 cmp %g1, 0
40018644: 12 80 00 2f bne 40018700 <_Objects_Get_name_as_string+0x118>
40018648: c2 02 20 0c ld [ %o0 + 0xc ], %g1
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
4001864c: 89 30 60 18 srl %g1, 0x18, %g4
lname[ 1 ] = (u32_name >> 16) & 0xff;
40018650: 87 30 60 10 srl %g1, 0x10, %g3
lname[ 2 ] = (u32_name >> 8) & 0xff;
40018654: 85 30 60 08 srl %g1, 8, %g2
lname[ 3 ] = (u32_name >> 0) & 0xff;
40018658: c2 2f bf fb stb %g1, [ %fp + -5 ]
lname[ 4 ] = '\0';
4001865c: c0 2f bf fc clrb [ %fp + -4 ]
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
40018660: c8 2f bf f8 stb %g4, [ %fp + -8 ]
lname[ 1 ] = (u32_name >> 16) & 0xff;
40018664: c6 2f bf f9 stb %g3, [ %fp + -7 ]
lname[ 2 ] = (u32_name >> 8) & 0xff;
40018668: c4 2f bf fa stb %g2, [ %fp + -6 ]
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
s = lname;
4001866c: 82 07 bf f8 add %fp, -8, %g1
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
40018670: 80 a6 60 01 cmp %i1, 1
40018674: 02 80 00 27 be 40018710 <_Objects_Get_name_as_string+0x128><== NEVER TAKEN
40018678: 86 10 00 1a mov %i2, %g3
4001867c: c6 48 40 00 ldsb [ %g1 ], %g3
40018680: 80 a0 e0 00 cmp %g3, 0
40018684: 02 80 00 22 be 4001870c <_Objects_Get_name_as_string+0x124>
40018688: c4 08 40 00 ldub [ %g1 ], %g2
* This method objects the name of an object and returns its name
* in the form of a C string. It attempts to be careful about
* overflowing the user's string and about returning unprintable characters.
*/
char *_Objects_Get_name_as_string(
4001868c: b6 06 7f ff add %i1, -1, %i3
40018690: 39 10 00 c9 sethi %hi(0x40032400), %i4
40018694: b6 00 40 1b add %g1, %i3, %i3
40018698: 86 10 00 1a mov %i2, %g3
4001869c: 10 80 00 06 b 400186b4 <_Objects_Get_name_as_string+0xcc>
400186a0: b8 17 20 58 or %i4, 0x58, %i4
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
400186a4: c8 48 40 00 ldsb [ %g1 ], %g4
400186a8: 80 a1 20 00 cmp %g4, 0
400186ac: 02 80 00 0e be 400186e4 <_Objects_Get_name_as_string+0xfc>
400186b0: c4 08 40 00 ldub [ %g1 ], %g2
*d = (isprint((unsigned char)*s)) ? *s : '*';
400186b4: fa 07 00 00 ld [ %i4 ], %i5
400186b8: 88 08 a0 ff and %g2, 0xff, %g4
400186bc: 88 07 40 04 add %i5, %g4, %g4
400186c0: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
400186c4: 80 89 20 97 btst 0x97, %g4
400186c8: 12 80 00 03 bne 400186d4 <_Objects_Get_name_as_string+0xec>
400186cc: 82 00 60 01 inc %g1
400186d0: 84 10 20 2a mov 0x2a, %g2
400186d4: c4 28 c0 00 stb %g2, [ %g3 ]
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
400186d8: 80 a0 40 1b cmp %g1, %i3
400186dc: 12 bf ff f2 bne 400186a4 <_Objects_Get_name_as_string+0xbc>
400186e0: 86 00 e0 01 inc %g3
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
_Thread_Enable_dispatch();
400186e4: 7f ff e4 73 call 400118b0 <_Thread_Enable_dispatch>
400186e8: c0 28 c0 00 clrb [ %g3 ]
return name;
}
return NULL; /* unreachable path */
}
400186ec: 81 c7 e0 08 ret
400186f0: 91 e8 00 1a restore %g0, %i2, %o0
return NULL;
if ( name == NULL )
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
400186f4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
400186f8: 10 bf ff c4 b 40018608 <_Objects_Get_name_as_string+0x20>
400186fc: fa 00 60 08 ld [ %g1 + 8 ], %i5
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
40018700: 80 a0 60 00 cmp %g1, 0
40018704: 12 bf ff dc bne 40018674 <_Objects_Get_name_as_string+0x8c>
40018708: 80 a6 60 01 cmp %i1, 1
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
*d = (isprint((unsigned char)*s)) ? *s : '*';
4001870c: 86 10 00 1a mov %i2, %g3
}
}
*d = '\0';
_Thread_Enable_dispatch();
40018710: 7f ff e4 68 call 400118b0 <_Thread_Enable_dispatch>
40018714: c0 28 c0 00 clrb [ %g3 ]
40018718: 30 bf ff f5 b,a 400186ec <_Objects_Get_name_as_string+0x104>
4001b3f8 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
4001b3f8: 9d e3 bf a0 save %sp, -96, %sp
Objects_Control *object;
Objects_Id next_id;
if ( !information )
4001b3fc: 80 a6 20 00 cmp %i0, 0
4001b400: 02 80 00 29 be 4001b4a4 <_Objects_Get_next+0xac>
4001b404: 80 a6 a0 00 cmp %i2, 0
return NULL;
if ( !location_p )
4001b408: 02 80 00 27 be 4001b4a4 <_Objects_Get_next+0xac>
4001b40c: 80 a6 e0 00 cmp %i3, 0
return NULL;
if ( !next_id_p )
4001b410: 02 80 00 25 be 4001b4a4 <_Objects_Get_next+0xac>
4001b414: 83 2e 60 10 sll %i1, 0x10, %g1
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
4001b418: 80 a0 60 00 cmp %g1, 0
4001b41c: 22 80 00 13 be,a 4001b468 <_Objects_Get_next+0x70>
4001b420: f2 06 20 08 ld [ %i0 + 8 ], %i1
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
4001b424: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2
4001b428: 83 2e 60 10 sll %i1, 0x10, %g1
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
4001b42c: 92 10 00 19 mov %i1, %o1
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
4001b430: 83 30 60 10 srl %g1, 0x10, %g1
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
4001b434: 90 10 00 18 mov %i0, %o0
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
4001b438: 80 a0 80 01 cmp %g2, %g1
4001b43c: 0a 80 00 13 bcs 4001b488 <_Objects_Get_next+0x90>
4001b440: 94 10 00 1a mov %i2, %o2
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
4001b444: 7f ff d5 0f call 40010880 <_Objects_Get>
4001b448: b2 06 60 01 inc %i1
next_id++;
} while (*location_p != OBJECTS_LOCAL);
4001b44c: c2 06 80 00 ld [ %i2 ], %g1
4001b450: 80 a0 60 00 cmp %g1, 0
4001b454: 32 bf ff f5 bne,a 4001b428 <_Objects_Get_next+0x30>
4001b458: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2
*next_id_p = next_id;
4001b45c: f2 26 c0 00 st %i1, [ %i3 ]
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
4001b460: 81 c7 e0 08 ret
4001b464: 91 e8 00 08 restore %g0, %o0, %o0
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
4001b468: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2
4001b46c: 83 2e 60 10 sll %i1, 0x10, %g1
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
4001b470: 92 10 00 19 mov %i1, %o1
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
4001b474: 83 30 60 10 srl %g1, 0x10, %g1
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
4001b478: 90 10 00 18 mov %i0, %o0
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
4001b47c: 80 a0 80 01 cmp %g2, %g1
4001b480: 1a bf ff f1 bcc 4001b444 <_Objects_Get_next+0x4c> <== ALWAYS TAKEN
4001b484: 94 10 00 1a mov %i2, %o2
{
*location_p = OBJECTS_ERROR;
4001b488: 82 10 20 01 mov 1, %g1
4001b48c: c2 26 80 00 st %g1, [ %i2 ]
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
4001b490: 90 10 20 00 clr %o0
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
4001b494: 82 10 3f ff mov -1, %g1
4001b498: c2 26 c0 00 st %g1, [ %i3 ]
return 0;
}
4001b49c: 81 c7 e0 08 ret
4001b4a0: 91 e8 00 08 restore %g0, %o0, %o0
{
Objects_Control *object;
Objects_Id next_id;
if ( !information )
return NULL;
4001b4a4: 10 bf ff ef b 4001b460 <_Objects_Get_next+0x68>
4001b4a8: 90 10 20 00 clr %o0
4001b63c <_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;
4001b63c: c4 02 20 08 ld [ %o0 + 8 ], %g2
if ( information->maximum >= index ) {
4001b640: 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;
4001b644: 92 22 40 02 sub %o1, %g2, %o1
4001b648: 92 02 60 01 inc %o1
if ( information->maximum >= index ) {
4001b64c: 80 a2 40 01 cmp %o1, %g1
4001b650: 18 80 00 09 bgu 4001b674 <_Objects_Get_no_protection+0x38>
4001b654: 93 2a 60 02 sll %o1, 2, %o1
if ( (the_object = information->local_table[ index ]) != NULL ) {
4001b658: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4001b65c: d0 00 40 09 ld [ %g1 + %o1 ], %o0
4001b660: 80 a2 20 00 cmp %o0, 0
4001b664: 02 80 00 05 be 4001b678 <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
4001b668: 82 10 20 01 mov 1, %g1
*location = OBJECTS_LOCAL;
return the_object;
4001b66c: 81 c3 e0 08 retl
4001b670: 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;
4001b674: 82 10 20 01 mov 1, %g1
return NULL;
4001b678: 90 10 20 00 clr %o0
}
4001b67c: 81 c3 e0 08 retl
4001b680: c2 22 80 00 st %g1, [ %o2 ]
400108f4 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
400108f4: 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;
400108f8: 80 a6 20 00 cmp %i0, 0
400108fc: 12 80 00 06 bne 40010914 <_Objects_Id_to_name+0x20>
40010900: 83 36 20 18 srl %i0, 0x18, %g1
40010904: 03 10 00 cf sethi %hi(0x40033c00), %g1
40010908: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 ! 40033c10 <_Per_CPU_Information+0x10>
4001090c: f0 00 60 08 ld [ %g1 + 8 ], %i0
40010910: 83 36 20 18 srl %i0, 0x18, %g1
40010914: 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 )
40010918: 84 00 7f ff add %g1, -1, %g2
4001091c: 80 a0 a0 02 cmp %g2, 2
40010920: 18 80 00 11 bgu 40010964 <_Objects_Id_to_name+0x70>
40010924: 83 28 60 02 sll %g1, 2, %g1
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
40010928: 05 10 00 cd sethi %hi(0x40033400), %g2
4001092c: 84 10 a2 14 or %g2, 0x214, %g2 ! 40033614 <_Objects_Information_table>
40010930: c2 00 80 01 ld [ %g2 + %g1 ], %g1
40010934: 80 a0 60 00 cmp %g1, 0
40010938: 02 80 00 0b be 40010964 <_Objects_Id_to_name+0x70>
4001093c: 85 36 20 1b srl %i0, 0x1b, %g2
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
40010940: 85 28 a0 02 sll %g2, 2, %g2
40010944: d0 00 40 02 ld [ %g1 + %g2 ], %o0
if ( !information )
40010948: 80 a2 20 00 cmp %o0, 0
4001094c: 02 80 00 06 be 40010964 <_Objects_Id_to_name+0x70> <== NEVER TAKEN
40010950: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
40010954: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
40010958: 80 a0 60 00 cmp %g1, 0
4001095c: 02 80 00 04 be 4001096c <_Objects_Id_to_name+0x78> <== ALWAYS TAKEN
40010960: 92 10 00 18 mov %i0, %o1
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
40010964: 81 c7 e0 08 ret
40010968: 91 e8 20 03 restore %g0, 3, %o0
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
4001096c: 7f ff ff c5 call 40010880 <_Objects_Get>
40010970: 94 07 bf fc add %fp, -4, %o2
if ( !the_object )
40010974: 80 a2 20 00 cmp %o0, 0
40010978: 02 bf ff fb be 40010964 <_Objects_Id_to_name+0x70>
4001097c: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
*name = the_object->name;
40010980: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
40010984: 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();
40010988: 40 00 03 ca call 400118b0 <_Thread_Enable_dispatch>
4001098c: c2 26 40 00 st %g1, [ %i1 ]
40010990: 81 c7 e0 08 ret
40010994: 81 e8 00 00 restore
4000a364 <_Objects_Shrink_information>:
#include <rtems/score/isr.h>
void _Objects_Shrink_information(
Objects_Information *information
)
{
4000a364: 9d e3 bf a0 save %sp, -96, %sp
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
4000a368: f8 16 20 0a lduh [ %i0 + 0xa ], %i4
block_count = (information->maximum - index_base) /
4000a36c: f6 16 20 14 lduh [ %i0 + 0x14 ], %i3
4000a370: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0
4000a374: 92 10 00 1b mov %i3, %o1
4000a378: 40 00 3d bf call 40019a74 <.udiv>
4000a37c: 90 22 00 1c sub %o0, %i4, %o0
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
4000a380: 80 a2 20 00 cmp %o0, 0
4000a384: 02 80 00 36 be 4000a45c <_Objects_Shrink_information+0xf8><== NEVER TAKEN
4000a388: 01 00 00 00 nop
if ( information->inactive_per_block[ block ] ==
4000a38c: c8 06 20 30 ld [ %i0 + 0x30 ], %g4
4000a390: c2 01 00 00 ld [ %g4 ], %g1
4000a394: 80 a6 c0 01 cmp %i3, %g1
4000a398: 02 80 00 0f be 4000a3d4 <_Objects_Shrink_information+0x70><== NEVER TAKEN
4000a39c: 82 10 20 00 clr %g1
4000a3a0: 10 80 00 07 b 4000a3bc <_Objects_Shrink_information+0x58>
4000a3a4: ba 10 20 04 mov 4, %i5
4000a3a8: c4 01 00 1d ld [ %g4 + %i5 ], %g2
4000a3ac: 80 a6 c0 02 cmp %i3, %g2
4000a3b0: 02 80 00 0a be 4000a3d8 <_Objects_Shrink_information+0x74>
4000a3b4: 86 07 60 04 add %i5, 4, %g3
4000a3b8: ba 10 00 03 mov %g3, %i5
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
4000a3bc: 82 00 60 01 inc %g1
4000a3c0: 80 a0 40 08 cmp %g1, %o0
4000a3c4: 12 bf ff f9 bne 4000a3a8 <_Objects_Shrink_information+0x44>
4000a3c8: b8 07 00 1b add %i4, %i3, %i4
4000a3cc: 81 c7 e0 08 ret
4000a3d0: 81 e8 00 00 restore
if ( information->inactive_per_block[ block ] ==
4000a3d4: ba 10 20 00 clr %i5 <== NOT EXECUTED
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
4000a3d8: 35 00 00 3f sethi %hi(0xfc00), %i2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000a3dc: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000a3e0: 10 80 00 05 b 4000a3f4 <_Objects_Shrink_information+0x90>
4000a3e4: b4 16 a3 ff or %i2, 0x3ff, %i2
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
4000a3e8: 90 96 e0 00 orcc %i3, 0, %o0
4000a3ec: 22 80 00 12 be,a 4000a434 <_Objects_Shrink_information+0xd0>
4000a3f0: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
4000a3f4: c2 02 20 08 ld [ %o0 + 8 ], %g1
4000a3f8: 82 08 40 1a and %g1, %i2, %g1
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
4000a3fc: 80 a0 40 1c cmp %g1, %i4
4000a400: 0a bf ff fa bcs 4000a3e8 <_Objects_Shrink_information+0x84>
4000a404: f6 02 00 00 ld [ %o0 ], %i3
(index < (index_base + information->allocation_size))) {
4000a408: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2
4000a40c: 84 07 00 02 add %i4, %g2, %g2
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
4000a410: 80 a0 40 02 cmp %g1, %g2
4000a414: 3a bf ff f6 bcc,a 4000a3ec <_Objects_Shrink_information+0x88>
4000a418: 90 96 e0 00 orcc %i3, 0, %o0
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
4000a41c: 40 00 10 5f call 4000e598 <_Chain_Extract>
4000a420: 01 00 00 00 nop
}
}
while ( the_object );
4000a424: 90 96 e0 00 orcc %i3, 0, %o0
4000a428: 32 bf ff f4 bne,a 4000a3f8 <_Objects_Shrink_information+0x94><== ALWAYS TAKEN
4000a42c: c2 02 20 08 ld [ %o0 + 8 ], %g1
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
4000a430: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
4000a434: 40 00 07 7e call 4000c22c <_Workspace_Free>
4000a438: d0 00 40 1d ld [ %g1 + %i5 ], %o0
information->object_blocks[ block ] = NULL;
4000a43c: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
4000a440: c4 16 20 2c lduh [ %i0 + 0x2c ], %g2
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
4000a444: c0 20 40 1d clr [ %g1 + %i5 ]
information->inactive_per_block[ block ] = 0;
4000a448: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
information->inactive -= information->allocation_size;
4000a44c: c2 16 20 14 lduh [ %i0 + 0x14 ], %g1
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
4000a450: c0 20 c0 1d clr [ %g3 + %i5 ]
information->inactive -= information->allocation_size;
4000a454: 82 20 80 01 sub %g2, %g1, %g1
4000a458: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
return;
4000a45c: 81 c7 e0 08 ret
4000a460: 81 e8 00 00 restore
40010114 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
40010114: 9d e3 bf a0 save %sp, -96, %sp
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
40010118: 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 ];
4001011c: 35 00 00 3f sethi %hi(0xfc00), %i2
40010120: b3 30 60 18 srl %g1, 0x18, %i1
40010124: b4 16 a3 ff or %i2, 0x3ff, %i2
40010128: b2 0e 60 07 and %i1, 7, %i1
4001012c: b4 08 40 1a and %g1, %i2, %i2
40010130: b2 06 60 04 add %i1, 4, %i1
40010134: 3b 10 00 81 sethi %hi(0x40020400), %i5
40010138: b5 2e a0 02 sll %i2, 2, %i2
4001013c: ba 17 62 8c or %i5, 0x28c, %i5
40010140: b3 2e 60 02 sll %i1, 2, %i1
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
40010144: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1
40010148: 80 a0 60 00 cmp %g1, 0
4001014c: 02 80 00 21 be 400101d0 <_POSIX_Keys_Run_destructors+0xbc>
40010150: b8 10 20 01 mov 1, %i4
40010154: 86 10 20 01 mov 1, %g3
40010158: b6 10 00 01 mov %g1, %i3
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
4001015c: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
_POSIX_Keys_Information.local_table [ index ];
40010160: 85 2f 20 10 sll %i4, 0x10, %g2
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
40010164: 85 30 a0 0e srl %g2, 0xe, %g2
40010168: c4 01 00 02 ld [ %g4 + %g2 ], %g2
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
4001016c: 80 a0 a0 00 cmp %g2, 0
40010170: 02 80 00 10 be 400101b0 <_POSIX_Keys_Run_destructors+0x9c>
40010174: 82 00 80 19 add %g2, %i1, %g1
40010178: c8 00 a0 10 ld [ %g2 + 0x10 ], %g4
4001017c: 80 a1 20 00 cmp %g4, 0
40010180: 22 80 00 0d be,a 400101b4 <_POSIX_Keys_Run_destructors+0xa0>
40010184: b8 07 20 01 inc %i4
void *value = key->Values [ thread_api ][ thread_index ];
40010188: c8 00 60 04 ld [ %g1 + 4 ], %g4
4001018c: d0 01 00 1a ld [ %g4 + %i2 ], %o0
if ( value != NULL ) {
40010190: 80 a2 20 00 cmp %o0, 0
40010194: 22 80 00 08 be,a 400101b4 <_POSIX_Keys_Run_destructors+0xa0><== ALWAYS TAKEN
40010198: b8 07 20 01 inc %i4
key->Values [ thread_api ][ thread_index ] = NULL;
4001019c: c0 21 00 1a clr [ %g4 + %i2 ] <== NOT EXECUTED
(*key->destructor)( value );
400101a0: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 <== NOT EXECUTED
400101a4: 9f c0 40 00 call %g1 <== NOT EXECUTED
400101a8: 01 00 00 00 nop <== NOT EXECUTED
done = false;
400101ac: 86 10 20 00 clr %g3 ! 0 <PROM_START> <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
400101b0: b8 07 20 01 inc %i4
400101b4: 85 2f 20 10 sll %i4, 0x10, %g2
400101b8: 85 30 a0 10 srl %g2, 0x10, %g2
400101bc: 80 a6 c0 02 cmp %i3, %g2
400101c0: 1a bf ff e7 bcc 4001015c <_POSIX_Keys_Run_destructors+0x48>
400101c4: 80 88 e0 ff btst 0xff, %g3
* number of iterations. An infinite loop may happen if destructors set
* thread specific data. This can be considered dubious.
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
400101c8: 22 bf ff e0 be,a 40010148 <_POSIX_Keys_Run_destructors+0x34><== NEVER TAKEN
400101cc: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
400101d0: 81 c7 e0 08 ret
400101d4: 81 e8 00 00 restore
4000d428 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
4000d428: 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(
4000d42c: 11 10 00 a8 sethi %hi(0x4002a000), %o0
4000d430: 92 10 00 18 mov %i0, %o1
4000d434: 90 12 23 b0 or %o0, 0x3b0, %o0
4000d438: 40 00 0d 8d call 40010a6c <_Objects_Get>
4000d43c: 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 ) {
4000d440: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000d444: 80 a0 60 00 cmp %g1, 0
4000d448: 22 80 00 08 be,a 4000d468 <_POSIX_Message_queue_Receive_support+0x40>
4000d44c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
4000d450: 40 00 29 59 call 400179b4 <__errno>
4000d454: b0 10 3f ff mov -1, %i0
4000d458: 82 10 20 09 mov 9, %g1
4000d45c: c2 22 00 00 st %g1, [ %o0 ]
}
4000d460: 81 c7 e0 08 ret
4000d464: 81 e8 00 00 restore
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
4000d468: 84 08 60 03 and %g1, 3, %g2
4000d46c: 80 a0 a0 01 cmp %g2, 1
4000d470: 02 80 00 39 be 4000d554 <_POSIX_Message_queue_Receive_support+0x12c>
4000d474: 01 00 00 00 nop
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
4000d478: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
4000d47c: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
4000d480: 80 a0 80 1a cmp %g2, %i2
4000d484: 18 80 00 23 bgu 4000d510 <_POSIX_Message_queue_Receive_support+0xe8>
4000d488: 84 10 3f ff mov -1, %g2
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
4000d48c: c4 27 bf fc st %g2, [ %fp + -4 ]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
4000d490: 80 a7 20 00 cmp %i4, 0
4000d494: 12 80 00 1b bne 4000d500 <_POSIX_Message_queue_Receive_support+0xd8>
4000d498: 98 10 20 00 clr %o4
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
4000d49c: 9a 10 00 1d mov %i5, %o5
4000d4a0: 90 02 20 1c add %o0, 0x1c, %o0
4000d4a4: 92 10 00 18 mov %i0, %o1
4000d4a8: 94 10 00 19 mov %i1, %o2
4000d4ac: 96 07 bf fc add %fp, -4, %o3
4000d4b0: 40 00 08 f2 call 4000f878 <_CORE_message_queue_Seize>
4000d4b4: 98 0b 20 01 and %o4, 1, %o4
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
4000d4b8: 40 00 11 48 call 400119d8 <_Thread_Enable_dispatch>
4000d4bc: 3b 10 00 a9 sethi %hi(0x4002a400), %i5
if (msg_prio) {
4000d4c0: 80 a6 e0 00 cmp %i3, 0
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
4000d4c4: ba 17 60 30 or %i5, 0x30, %i5
do_wait,
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
4000d4c8: 02 80 00 07 be 4000d4e4 <_POSIX_Message_queue_Receive_support+0xbc><== NEVER TAKEN
4000d4cc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return (unsigned int) ((priority >= 0) ? priority : -priority);
4000d4d0: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
4000d4d4: 85 38 e0 1f sra %g3, 0x1f, %g2
4000d4d8: 86 18 80 03 xor %g2, %g3, %g3
4000d4dc: 84 20 c0 02 sub %g3, %g2, %g2
*msg_prio = _POSIX_Message_queue_Priority_from_core(
4000d4e0: c4 26 c0 00 st %g2, [ %i3 ]
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
4000d4e4: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
4000d4e8: 80 a0 60 00 cmp %g1, 0
4000d4ec: 12 80 00 11 bne 4000d530 <_POSIX_Message_queue_Receive_support+0x108>
4000d4f0: 01 00 00 00 nop
return length_out;
4000d4f4: f0 07 bf fc ld [ %fp + -4 ], %i0
4000d4f8: 81 c7 e0 08 ret
4000d4fc: 81 e8 00 00 restore
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
4000d500: 99 30 60 0e srl %g1, 0xe, %o4
4000d504: 98 1b 20 01 xor %o4, 1, %o4
4000d508: 10 bf ff e5 b 4000d49c <_POSIX_Message_queue_Receive_support+0x74>
4000d50c: 98 0b 20 01 and %o4, 1, %o4
}
the_mq = the_mq_fd->Queue;
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
_Thread_Enable_dispatch();
4000d510: 40 00 11 32 call 400119d8 <_Thread_Enable_dispatch>
4000d514: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EMSGSIZE );
4000d518: 40 00 29 27 call 400179b4 <__errno>
4000d51c: 01 00 00 00 nop
4000d520: 82 10 20 7a mov 0x7a, %g1 ! 7a <PROM_START+0x7a>
4000d524: c2 22 00 00 st %g1, [ %o0 ]
4000d528: 81 c7 e0 08 ret
4000d52c: 81 e8 00 00 restore
}
if ( !_Thread_Executing->Wait.return_code )
return length_out;
rtems_set_errno_and_return_minus_one(
4000d530: 40 00 29 21 call 400179b4 <__errno>
4000d534: b0 10 3f ff mov -1, %i0
4000d538: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d53c: b8 10 00 08 mov %o0, %i4
4000d540: 40 00 00 a2 call 4000d7c8 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
4000d544: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
4000d548: d0 27 00 00 st %o0, [ %i4 ]
4000d54c: 81 c7 e0 08 ret
4000d550: 81 e8 00 00 restore
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
_Thread_Enable_dispatch();
4000d554: 40 00 11 21 call 400119d8 <_Thread_Enable_dispatch>
4000d558: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EBADF );
4000d55c: 40 00 29 16 call 400179b4 <__errno>
4000d560: 01 00 00 00 nop
4000d564: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
4000d568: c2 22 00 00 st %g1, [ %o0 ]
4000d56c: 81 c7 e0 08 ret
4000d570: 81 e8 00 00 restore
4000ffb0 <_POSIX_Semaphore_Create_support>:
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
4000ffb0: 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)
4000ffb4: 80 a6 a0 00 cmp %i2, 0
4000ffb8: 12 80 00 2f bne 40010074 <_POSIX_Semaphore_Create_support+0xc4>
4000ffbc: 03 10 00 93 sethi %hi(0x40024c00), %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;
4000ffc0: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 40024cb0 <_Thread_Dispatch_disable_level>
++level;
4000ffc4: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
4000ffc8: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ]
* _POSIX_Semaphore_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
4000ffcc: 35 10 00 93 sethi %hi(0x40024c00), %i2
4000ffd0: 7f ff ee 18 call 4000b830 <_Objects_Allocate>
4000ffd4: 90 16 a3 74 or %i2, 0x374, %o0 ! 40024f74 <_POSIX_Semaphore_Information>
rtems_set_errno_and_return_minus_one( ENOSYS );
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
4000ffd8: ba 92 20 00 orcc %o0, 0, %i5
4000ffdc: 02 80 00 2c be 4001008c <_POSIX_Semaphore_Create_support+0xdc>
4000ffe0: 80 a6 20 00 cmp %i0, 0
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
if ( name_arg != NULL ) {
4000ffe4: 02 80 00 1e be 4001005c <_POSIX_Semaphore_Create_support+0xac>
4000ffe8: 92 10 00 19 mov %i1, %o1
name = _Workspace_String_duplicate( name_arg, name_len );
4000ffec: 40 00 04 10 call 4001102c <_Workspace_String_duplicate>
4000fff0: 90 10 00 18 mov %i0, %o0
if ( !name ) {
4000fff4: b2 92 20 00 orcc %o0, 0, %i1
4000fff8: 02 80 00 2d be 400100ac <_POSIX_Semaphore_Create_support+0xfc><== NEVER TAKEN
4000fffc: 82 10 20 01 mov 1, %g1
}
the_semaphore->process_shared = pshared;
if ( name ) {
the_semaphore->named = true;
40010000: 84 10 20 01 mov 1, %g2
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
40010004: c0 27 60 10 clr [ %i5 + 0x10 ]
if ( name ) {
the_semaphore->named = true;
40010008: c4 2f 60 14 stb %g2, [ %i5 + 0x14 ]
the_semaphore->open_count = 1;
4001000c: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
the_semaphore->linked = true;
40010010: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
40010014: 82 10 3f ff mov -1, %g1
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
40010018: 90 07 60 1c add %i5, 0x1c, %o0
4001001c: 92 07 60 5c add %i5, 0x5c, %o1
40010020: 94 10 00 1b mov %i3, %o2
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
40010024: c2 27 60 5c st %g1, [ %i5 + 0x5c ]
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
40010028: 7f ff ec 5f call 4000b1a4 <_CORE_semaphore_Initialize>
4001002c: c0 27 60 60 clr [ %i5 + 0x60 ]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
40010030: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40010034: b4 16 a3 74 or %i2, 0x374, %i2
40010038: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2
4001003c: 83 28 60 02 sll %g1, 2, %g1
40010040: 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;
40010044: f2 27 60 0c st %i1, [ %i5 + 0xc ]
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
40010048: fa 27 00 00 st %i5, [ %i4 ]
_Thread_Enable_dispatch();
4001004c: 7f ff f3 45 call 4000cd60 <_Thread_Enable_dispatch>
40010050: b0 10 20 00 clr %i0
return 0;
40010054: 81 c7 e0 08 ret
40010058: 81 e8 00 00 restore
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
4001005c: c0 27 60 10 clr [ %i5 + 0x10 ]
if ( name ) {
the_semaphore->named = true;
the_semaphore->open_count = 1;
the_semaphore->linked = true;
} else {
the_semaphore->named = false;
40010060: c0 2f 60 14 clrb [ %i5 + 0x14 ]
the_semaphore->open_count = 0;
40010064: c0 27 60 18 clr [ %i5 + 0x18 ]
the_semaphore->linked = false;
40010068: c0 2f 60 15 clrb [ %i5 + 0x15 ]
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
} else {
name = NULL;
4001006c: 10 bf ff ea b 40010014 <_POSIX_Semaphore_Create_support+0x64>
40010070: b2 10 20 00 clr %i1
CORE_semaphore_Attributes *the_sem_attr;
char *name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
rtems_set_errno_and_return_minus_one( ENOSYS );
40010074: 40 00 09 fa call 4001285c <__errno>
40010078: b0 10 3f ff mov -1, %i0
4001007c: 82 10 20 58 mov 0x58, %g1
40010080: c2 22 00 00 st %g1, [ %o0 ]
40010084: 81 c7 e0 08 ret
40010088: 81 e8 00 00 restore
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
4001008c: 7f ff f3 35 call 4000cd60 <_Thread_Enable_dispatch>
40010090: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( ENOSPC );
40010094: 40 00 09 f2 call 4001285c <__errno>
40010098: 01 00 00 00 nop
4001009c: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c>
400100a0: c2 22 00 00 st %g1, [ %o0 ]
400100a4: 81 c7 e0 08 ret
400100a8: 81 e8 00 00 restore
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
400100ac: 90 16 a3 74 or %i2, 0x374, %o0 <== NOT EXECUTED
400100b0: 7f ff ee d8 call 4000bc10 <_Objects_Free> <== NOT EXECUTED
400100b4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
*/
if ( name_arg != NULL ) {
name = _Workspace_String_duplicate( name_arg, name_len );
if ( !name ) {
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
400100b8: 7f ff f3 2a call 4000cd60 <_Thread_Enable_dispatch> <== NOT EXECUTED
400100bc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
400100c0: 40 00 09 e7 call 4001285c <__errno> <== NOT EXECUTED
400100c4: 01 00 00 00 nop <== NOT EXECUTED
400100c8: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
400100cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400100d0: 81 c7 e0 08 ret <== NOT EXECUTED
400100d4: 81 e8 00 00 restore <== NOT EXECUTED
4000d664 <_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 ];
4000d664: c2 02 21 50 ld [ %o0 + 0x150 ], %g1
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
4000d668: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2
4000d66c: 80 a0 a0 00 cmp %g2, 0
4000d670: 12 80 00 06 bne 4000d688 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24><== NEVER TAKEN
4000d674: 01 00 00 00 nop
4000d678: c4 00 60 dc ld [ %g1 + 0xdc ], %g2
4000d67c: 80 a0 a0 01 cmp %g2, 1
4000d680: 22 80 00 05 be,a 4000d694 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x30>
4000d684: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
4000d688: 82 13 c0 00 mov %o7, %g1
4000d68c: 7f ff f6 0c call 4000aebc <_Thread_Enable_dispatch>
4000d690: 9e 10 40 00 mov %g1, %o7
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
4000d694: 80 a0 60 00 cmp %g1, 0
4000d698: 02 bf ff fc be 4000d688 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24>
4000d69c: 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;
4000d6a0: 03 10 00 64 sethi %hi(0x40019000), %g1
4000d6a4: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400190e0 <_Thread_Dispatch_disable_level>
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
4000d6a8: 92 10 3f ff mov -1, %o1
--level;
4000d6ac: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000d6b0: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ]
4000d6b4: 82 13 c0 00 mov %o7, %g1
4000d6b8: 40 00 01 d9 call 4000de1c <_POSIX_Thread_Exit>
4000d6bc: 9e 10 40 00 mov %g1, %o7
4000eb60 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
4000eb60: 9d e3 bf a0 save %sp, -96, %sp
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
4000eb64: 7f ff ff f2 call 4000eb2c <_POSIX_Priority_Is_valid>
4000eb68: d0 06 40 00 ld [ %i1 ], %o0
4000eb6c: 80 8a 20 ff btst 0xff, %o0
4000eb70: 32 80 00 04 bne,a 4000eb80 <_POSIX_Thread_Translate_sched_param+0x20><== ALWAYS TAKEN
4000eb74: c0 26 80 00 clr [ %i2 ]
return EINVAL;
4000eb78: 81 c7 e0 08 ret
4000eb7c: 91 e8 20 16 restore %g0, 0x16, %o0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
4000eb80: 80 a6 20 00 cmp %i0, 0
4000eb84: 02 80 00 2c be 4000ec34 <_POSIX_Thread_Translate_sched_param+0xd4>
4000eb88: c0 26 c0 00 clr [ %i3 ]
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
4000eb8c: 80 a6 20 01 cmp %i0, 1
4000eb90: 02 80 00 2d be 4000ec44 <_POSIX_Thread_Translate_sched_param+0xe4>
4000eb94: 80 a6 20 02 cmp %i0, 2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
4000eb98: 02 80 00 2d be 4000ec4c <_POSIX_Thread_Translate_sched_param+0xec>
4000eb9c: 80 a6 20 04 cmp %i0, 4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
4000eba0: 12 bf ff f6 bne 4000eb78 <_POSIX_Thread_Translate_sched_param+0x18>
4000eba4: 01 00 00 00 nop
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
4000eba8: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000ebac: 80 a0 60 00 cmp %g1, 0
4000ebb0: 32 80 00 07 bne,a 4000ebcc <_POSIX_Thread_Translate_sched_param+0x6c>
4000ebb4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000ebb8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000ebbc: 80 a0 60 00 cmp %g1, 0
4000ebc0: 02 bf ff ee be 4000eb78 <_POSIX_Thread_Translate_sched_param+0x18>
4000ebc4: 01 00 00 00 nop
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
4000ebc8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000ebcc: 80 a0 60 00 cmp %g1, 0
4000ebd0: 12 80 00 06 bne 4000ebe8 <_POSIX_Thread_Translate_sched_param+0x88>
4000ebd4: 01 00 00 00 nop
4000ebd8: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000ebdc: 80 a0 60 00 cmp %g1, 0
4000ebe0: 02 bf ff e6 be 4000eb78 <_POSIX_Thread_Translate_sched_param+0x18>
4000ebe4: 01 00 00 00 nop
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
4000ebe8: 7f ff f7 15 call 4000c83c <_Timespec_To_ticks>
4000ebec: 90 06 60 08 add %i1, 8, %o0
4000ebf0: ba 10 00 08 mov %o0, %i5
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
4000ebf4: 7f ff f7 12 call 4000c83c <_Timespec_To_ticks>
4000ebf8: 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 ) <
4000ebfc: 80 a7 40 08 cmp %i5, %o0
4000ec00: 0a bf ff de bcs 4000eb78 <_POSIX_Thread_Translate_sched_param+0x18>
4000ec04: 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 ) )
4000ec08: 7f ff ff c9 call 4000eb2c <_POSIX_Priority_Is_valid>
4000ec0c: d0 06 60 04 ld [ %i1 + 4 ], %o0
4000ec10: 80 8a 20 ff btst 0xff, %o0
4000ec14: 02 bf ff d9 be 4000eb78 <_POSIX_Thread_Translate_sched_param+0x18>
4000ec18: 82 10 20 03 mov 3, %g1
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
4000ec1c: c2 26 80 00 st %g1, [ %i2 ]
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
4000ec20: 03 10 00 22 sethi %hi(0x40008800), %g1
4000ec24: 82 10 60 ac or %g1, 0xac, %g1 ! 400088ac <_POSIX_Threads_Sporadic_budget_callout>
4000ec28: c2 26 c0 00 st %g1, [ %i3 ]
return 0;
4000ec2c: 81 c7 e0 08 ret
4000ec30: 91 e8 20 00 restore %g0, 0, %o0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4000ec34: 82 10 20 01 mov 1, %g1
4000ec38: c2 26 80 00 st %g1, [ %i2 ]
return 0;
4000ec3c: 81 c7 e0 08 ret
4000ec40: 81 e8 00 00 restore
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
4000ec44: 81 c7 e0 08 ret
4000ec48: 91 e8 20 00 restore %g0, 0, %o0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
4000ec4c: f0 26 80 00 st %i0, [ %i2 ]
return 0;
4000ec50: 81 c7 e0 08 ret
4000ec54: 91 e8 20 00 restore %g0, 0, %o0
4000dd9c <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
4000dd9c: 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 ];
4000dda0: f0 06 61 50 ld [ %i1 + 0x150 ], %i0
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
4000dda4: 40 00 08 c0 call 400100a4 <_POSIX_Threads_cancel_run>
4000dda8: 90 10 00 19 mov %i1, %o0
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
4000ddac: 90 10 00 19 mov %i1, %o0
4000ddb0: 40 00 08 d9 call 40010114 <_POSIX_Keys_Run_destructors>
4000ddb4: 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 )) )
4000ddb8: 10 80 00 03 b 4000ddc4 <_POSIX_Threads_Delete_extension+0x28>
4000ddbc: f8 06 60 28 ld [ %i1 + 0x28 ], %i4
*(void **)the_thread->Wait.return_argument = value_ptr;
4000ddc0: 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 )) )
4000ddc4: 7f ff f5 9a call 4000b42c <_Thread_queue_Dequeue>
4000ddc8: 90 10 00 1d mov %i5, %o0
4000ddcc: 80 a2 20 00 cmp %o0, 0
4000ddd0: 32 bf ff fc bne,a 4000ddc0 <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN
4000ddd4: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 <== NOT EXECUTED
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
4000ddd8: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
4000dddc: 80 a0 60 04 cmp %g1, 4
4000dde0: 02 80 00 05 be 4000ddf4 <_POSIX_Threads_Delete_extension+0x58>
4000dde4: 01 00 00 00 nop
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
4000dde8: c0 26 61 50 clr [ %i1 + 0x150 ]
_Workspace_Free( api );
4000ddec: 7f ff f9 10 call 4000c22c <_Workspace_Free>
4000ddf0: 81 e8 00 00 restore
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
4000ddf4: 7f ff f8 50 call 4000bf34 <_Watchdog_Remove>
4000ddf8: 90 06 20 a8 add %i0, 0xa8, %o0
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
4000ddfc: c0 26 61 50 clr [ %i1 + 0x150 ]
_Workspace_Free( api );
4000de00: 7f ff f9 0b call 4000c22c <_Workspace_Free>
4000de04: 81 e8 00 00 restore
400085c0 <_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)
{
400085c0: 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;
400085c4: 03 10 00 80 sethi %hi(0x40020000), %g1
400085c8: 82 10 60 04 or %g1, 4, %g1 ! 40020004 <Configuration_POSIX_API>
maximum = Configuration_POSIX_API.number_of_initialization_threads;
400085cc: f6 00 60 30 ld [ %g1 + 0x30 ], %i3
if ( !user_threads || maximum == 0 )
400085d0: 80 a6 e0 00 cmp %i3, 0
400085d4: 02 80 00 18 be 40008634 <_POSIX_Threads_Initialize_user_threads_body+0x74><== NEVER TAKEN
400085d8: fa 00 60 34 ld [ %g1 + 0x34 ], %i5
400085dc: 80 a7 60 00 cmp %i5, 0
400085e0: 02 80 00 15 be 40008634 <_POSIX_Threads_Initialize_user_threads_body+0x74><== NEVER TAKEN
400085e4: 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 );
400085e8: 40 00 19 9c call 4000ec58 <pthread_attr_init>
400085ec: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
400085f0: 92 10 20 02 mov 2, %o1
400085f4: 40 00 19 a5 call 4000ec88 <pthread_attr_setinheritsched>
400085f8: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
400085fc: d2 07 60 04 ld [ %i5 + 4 ], %o1
40008600: 40 00 19 b2 call 4000ecc8 <pthread_attr_setstacksize>
40008604: 90 07 bf c0 add %fp, -64, %o0
status = pthread_create(
40008608: d4 07 40 00 ld [ %i5 ], %o2
4000860c: 90 07 bf bc add %fp, -68, %o0
40008610: 92 07 bf c0 add %fp, -64, %o1
40008614: 7f ff ff 00 call 40008214 <pthread_create>
40008618: 96 10 20 00 clr %o3
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
4000861c: 94 92 20 00 orcc %o0, 0, %o2
40008620: 12 80 00 07 bne 4000863c <_POSIX_Threads_Initialize_user_threads_body+0x7c>
40008624: b8 07 20 01 inc %i4
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
40008628: 80 a7 00 1b cmp %i4, %i3
4000862c: 12 bf ff ef bne 400085e8 <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN
40008630: ba 07 60 08 add %i5, 8, %i5
40008634: 81 c7 e0 08 ret
40008638: 81 e8 00 00 restore
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
4000863c: 90 10 20 02 mov 2, %o0
40008640: 40 00 08 79 call 4000a824 <_Internal_error_Occurred>
40008644: 92 10 20 01 mov 1, %o1
4000df28 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
4000df28: 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 ];
4000df2c: fa 06 61 50 ld [ %i1 + 0x150 ], %i5
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
4000df30: 40 00 03 bb call 4000ee1c <_Timespec_To_ticks>
4000df34: 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);
4000df38: c4 07 60 88 ld [ %i5 + 0x88 ], %g2
4000df3c: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000df40: d2 08 60 dc ldub [ %g1 + 0xdc ], %o1 ! 4001f4dc <rtems_maximum_priority>
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
4000df44: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4000df48: 92 22 40 02 sub %o1, %g2, %o1
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
the_thread->cpu_time_budget = ticks;
4000df4c: d0 26 60 74 st %o0, [ %i1 + 0x74 ]
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
4000df50: 80 a0 60 00 cmp %g1, 0
4000df54: 12 80 00 06 bne 4000df6c <_POSIX_Threads_Sporadic_budget_TSR+0x44><== NEVER TAKEN
4000df58: 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 ) {
4000df5c: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000df60: 80 a0 40 09 cmp %g1, %o1
4000df64: 18 80 00 09 bgu 4000df88 <_POSIX_Threads_Sporadic_budget_TSR+0x60>
4000df68: 90 10 00 19 mov %i1, %o0
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
4000df6c: 90 07 60 90 add %i5, 0x90, %o0
4000df70: 40 00 03 ab call 4000ee1c <_Timespec_To_ticks>
4000df74: 31 10 00 80 sethi %hi(0x40020000), %i0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4000df78: b2 07 60 a8 add %i5, 0xa8, %i1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4000df7c: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4000df80: 7f ff f7 8e call 4000bdb8 <_Watchdog_Insert>
4000df84: 91 ee 23 48 restore %i0, 0x348, %o0
if ( the_thread->resource_count == 0 ) {
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
_Thread_Change_priority( the_thread, new_priority, true );
4000df88: 7f ff f3 16 call 4000abe0 <_Thread_Change_priority>
4000df8c: 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 );
4000df90: 90 07 60 90 add %i5, 0x90, %o0
4000df94: 40 00 03 a2 call 4000ee1c <_Timespec_To_ticks>
4000df98: 31 10 00 80 sethi %hi(0x40020000), %i0
4000df9c: b2 07 60 a8 add %i5, 0xa8, %i1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4000dfa0: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4000dfa4: 7f ff f7 85 call 4000bdb8 <_Watchdog_Insert>
4000dfa8: 91 ee 23 48 restore %i0, 0x348, %o0
4000dfac <_POSIX_Threads_Sporadic_budget_callout>:
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000dfac: c4 02 21 50 ld [ %o0 + 0x150 ], %g2
4000dfb0: c6 00 a0 8c ld [ %g2 + 0x8c ], %g3
4000dfb4: 05 10 00 7d sethi %hi(0x4001f400), %g2
4000dfb8: d2 08 a0 dc ldub [ %g2 + 0xdc ], %o1 ! 4001f4dc <rtems_maximum_priority>
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
4000dfbc: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
4000dfc0: 92 22 40 03 sub %o1, %g3, %o1
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
4000dfc4: 86 10 3f ff mov -1, %g3
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
4000dfc8: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
4000dfcc: 80 a0 a0 00 cmp %g2, 0
4000dfd0: 12 80 00 06 bne 4000dfe8 <_POSIX_Threads_Sporadic_budget_callout+0x3c><== NEVER TAKEN
4000dfd4: c6 22 20 74 st %g3, [ %o0 + 0x74 ]
/*
* Make sure we are actually lowering it. If they have lowered it
* to logically lower than sched_ss_low_priority, then we do not want to
* change it.
*/
if ( the_thread->current_priority < new_priority ) {
4000dfd8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000dfdc: 80 a0 40 09 cmp %g1, %o1
4000dfe0: 0a 80 00 04 bcs 4000dff0 <_POSIX_Threads_Sporadic_budget_callout+0x44><== ALWAYS TAKEN
4000dfe4: 94 10 20 01 mov 1, %o2
4000dfe8: 81 c3 e0 08 retl <== NOT EXECUTED
4000dfec: 01 00 00 00 nop <== NOT EXECUTED
_Thread_Change_priority( the_thread, new_priority, true );
4000dff0: 82 13 c0 00 mov %o7, %g1
4000dff4: 7f ff f2 fb call 4000abe0 <_Thread_Change_priority>
4000dff8: 9e 10 40 00 mov %g1, %o7
400100a4 <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
400100a4: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Cancel_Handler_control *handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
400100a8: f8 06 21 50 ld [ %i0 + 0x150 ], %i4
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
400100ac: 84 10 20 01 mov 1, %g2
while ( !_Chain_Is_empty( handler_stack ) ) {
400100b0: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
400100b4: b6 07 20 e8 add %i4, 0xe8, %i3
400100b8: 80 a0 40 1b cmp %g1, %i3
400100bc: 02 80 00 14 be 4001010c <_POSIX_Threads_cancel_run+0x68>
400100c0: c4 27 20 d8 st %g2, [ %i4 + 0xd8 ]
_ISR_Disable( level );
400100c4: 7f ff c9 03 call 400024d0 <sparc_disable_interrupts>
400100c8: 01 00 00 00 nop
handler = (POSIX_Cancel_Handler_control *)
400100cc: fa 07 20 ec ld [ %i4 + 0xec ], %i5
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
400100d0: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
400100d4: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
400100d8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
400100dc: c4 20 40 00 st %g2, [ %g1 ]
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
400100e0: 7f ff c9 00 call 400024e0 <sparc_enable_interrupts>
400100e4: 01 00 00 00 nop
(*handler->routine)( handler->arg );
400100e8: c2 07 60 08 ld [ %i5 + 8 ], %g1
400100ec: 9f c0 40 00 call %g1
400100f0: d0 07 60 0c ld [ %i5 + 0xc ], %o0
_Workspace_Free( handler );
400100f4: 7f ff f0 4e call 4000c22c <_Workspace_Free>
400100f8: 90 10 00 1d mov %i5, %o0
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
400100fc: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1
40010100: 80 a0 40 1b cmp %g1, %i3
40010104: 12 bf ff f0 bne 400100c4 <_POSIX_Threads_cancel_run+0x20> <== NEVER TAKEN
40010108: 01 00 00 00 nop
4001010c: 81 c7 e0 08 ret
40010110: 81 e8 00 00 restore
4000834c <_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)
{
4000834c: 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;
40008350: c4 06 60 68 ld [ %i1 + 0x68 ], %g2
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
40008354: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
40008358: 84 00 a0 01 inc %g2
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
4000835c: 80 a0 60 00 cmp %g1, 0
40008360: 12 80 00 0e bne 40008398 <_POSIX_Timer_TSR+0x4c>
40008364: c4 26 60 68 st %g2, [ %i1 + 0x68 ]
40008368: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
4000836c: 80 a0 60 00 cmp %g1, 0
40008370: 32 80 00 0b bne,a 4000839c <_POSIX_Timer_TSR+0x50> <== ALWAYS TAKEN
40008374: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
40008378: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED
4000837c: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] <== NOT EXECUTED
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
40008380: d0 06 60 38 ld [ %i1 + 0x38 ], %o0
40008384: 40 00 18 4c call 4000e4b4 <pthread_kill>
40008388: d2 06 60 44 ld [ %i1 + 0x44 ], %o1
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
4000838c: c0 26 60 68 clr [ %i1 + 0x68 ]
40008390: 81 c7 e0 08 ret
40008394: 81 e8 00 00 restore
ptimer->overrun = ptimer->overrun + 1;
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
40008398: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
4000839c: d4 06 60 08 ld [ %i1 + 8 ], %o2
400083a0: 90 06 60 10 add %i1, 0x10, %o0
400083a4: 98 10 00 19 mov %i1, %o4
400083a8: 17 10 00 20 sethi %hi(0x40008000), %o3
400083ac: 40 00 19 69 call 4000e950 <_POSIX_Timer_Insert_helper>
400083b0: 96 12 e3 4c or %o3, 0x34c, %o3 ! 4000834c <_POSIX_Timer_TSR>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
400083b4: 80 8a 20 ff btst 0xff, %o0
400083b8: 02 bf ff f6 be 40008390 <_POSIX_Timer_TSR+0x44> <== NEVER TAKEN
400083bc: 90 07 bf f8 add %fp, -8, %o0
400083c0: 13 10 00 83 sethi %hi(0x40020c00), %o1
400083c4: 40 00 06 3b call 40009cb0 <_TOD_Get_with_nanoseconds>
400083c8: 92 12 61 48 or %o1, 0x148, %o1 ! 40020d48 <_TOD>
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
}
400083cc: 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);
400083d0: 94 10 20 00 clr %o2
400083d4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400083d8: 90 10 00 1c mov %i4, %o0
400083dc: 96 12 e2 00 or %o3, 0x200, %o3
400083e0: 40 00 4a 34 call 4001acb0 <__divdi3>
400083e4: 92 10 00 1d mov %i5, %o1
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
400083e8: 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);
400083ec: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
400083f0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400083f4: 90 10 00 1c mov %i4, %o0
400083f8: 96 12 e2 00 or %o3, 0x200, %o3
400083fc: 40 00 4b 18 call 4001b05c <__moddi3>
40008400: 92 10 00 1d mov %i5, %o1
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
40008404: 82 10 20 03 mov 3, %g1
40008408: d2 26 60 70 st %o1, [ %i1 + 0x70 ]
4000840c: 10 bf ff dd b 40008380 <_POSIX_Timer_TSR+0x34>
40008410: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
400101d8 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
400101d8: 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,
400101dc: 98 10 20 01 mov 1, %o4
400101e0: 90 10 00 18 mov %i0, %o0
400101e4: 92 10 00 19 mov %i1, %o1
400101e8: 94 07 bf cc add %fp, -52, %o2
400101ec: 40 00 00 2e call 400102a4 <_POSIX_signals_Clear_signals>
400101f0: 96 10 00 1a mov %i2, %o3
400101f4: 80 8a 20 ff btst 0xff, %o0
400101f8: 02 80 00 23 be 40010284 <_POSIX_signals_Check_signal+0xac>
400101fc: 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 )
40010200: 85 2e 60 02 sll %i1, 2, %g2
40010204: 37 10 00 82 sethi %hi(0x40020800), %i3
40010208: b9 2e 60 04 sll %i1, 4, %i4
4001020c: b6 16 e0 20 or %i3, 0x20, %i3
40010210: b8 27 00 02 sub %i4, %g2, %i4
40010214: 84 06 c0 1c add %i3, %i4, %g2
40010218: fa 00 a0 08 ld [ %g2 + 8 ], %i5
4001021c: 80 a7 60 01 cmp %i5, 1
40010220: 02 80 00 19 be 40010284 <_POSIX_signals_Check_signal+0xac><== NEVER TAKEN
40010224: 21 10 00 81 sethi %hi(0x40020400), %l0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
40010228: f4 06 20 d0 ld [ %i0 + 0xd0 ], %i2
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
4001022c: c2 00 a0 04 ld [ %g2 + 4 ], %g1
/*
* We have to save the blocking information of the current wait queue
* because the signal handler may subsequently go on and put the thread
* on a wait queue, for its own purposes.
*/
memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
40010230: a0 14 23 c0 or %l0, 0x3c0, %l0
40010234: d2 04 20 10 ld [ %l0 + 0x10 ], %o1
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
40010238: 82 10 40 1a or %g1, %i2, %g1
/*
* We have to save the blocking information of the current wait queue
* because the signal handler may subsequently go on and put the thread
* on a wait queue, for its own purposes.
*/
memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
4001023c: 90 07 bf d8 add %fp, -40, %o0
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
40010240: 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,
40010244: 92 02 60 20 add %o1, 0x20, %o1
40010248: 40 00 04 0f call 40011284 <memcpy>
4001024c: 94 10 20 28 mov 0x28, %o2
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
40010250: c2 06 c0 1c ld [ %i3 + %i4 ], %g1
40010254: 80 a0 60 02 cmp %g1, 2
40010258: 02 80 00 0e be 40010290 <_POSIX_signals_Check_signal+0xb8>
4001025c: 90 10 00 19 mov %i1, %o0
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
40010260: 9f c7 40 00 call %i5
40010264: 01 00 00 00 nop
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
40010268: d0 04 20 10 ld [ %l0 + 0x10 ], %o0
4001026c: 92 07 bf d8 add %fp, -40, %o1
40010270: 90 02 20 20 add %o0, 0x20, %o0
40010274: 40 00 04 04 call 40011284 <memcpy>
40010278: 94 10 20 28 mov 0x28, %o2
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
4001027c: 82 10 20 01 mov 1, %g1
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
40010280: f4 26 20 d0 st %i2, [ %i0 + 0xd0 ]
return true;
}
40010284: b0 08 60 01 and %g1, 1, %i0
40010288: 81 c7 e0 08 ret
4001028c: 81 e8 00 00 restore
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
40010290: 92 07 bf cc add %fp, -52, %o1
40010294: 9f c7 40 00 call %i5
40010298: 94 10 20 00 clr %o2
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
4001029c: 10 bf ff f4 b 4001026c <_POSIX_signals_Check_signal+0x94>
400102a0: d0 04 20 10 ld [ %l0 + 0x10 ], %o0
40010898 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
40010898: 9d e3 bf a0 save %sp, -96, %sp
4001089c: 84 10 20 01 mov 1, %g2
400108a0: 82 06 3f ff add %i0, -1, %g1
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
400108a4: 7f ff c7 0b call 400024d0 <sparc_disable_interrupts>
400108a8: bb 28 80 01 sll %g2, %g1, %i5
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
400108ac: 05 10 00 82 sethi %hi(0x40020800), %g2
400108b0: 83 2e 20 02 sll %i0, 2, %g1
400108b4: 84 10 a0 20 or %g2, 0x20, %g2
400108b8: b1 2e 20 04 sll %i0, 4, %i0
400108bc: 82 26 00 01 sub %i0, %g1, %g1
400108c0: c4 00 80 01 ld [ %g2 + %g1 ], %g2
400108c4: 80 a0 a0 02 cmp %g2, 2
400108c8: 02 80 00 08 be 400108e8 <_POSIX_signals_Clear_process_signals+0x50>
400108cc: 31 10 00 82 sethi %hi(0x40020800), %i0
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
400108d0: 03 10 00 82 sethi %hi(0x40020800), %g1
400108d4: c4 00 62 14 ld [ %g1 + 0x214 ], %g2 ! 40020a14 <_POSIX_signals_Pending>
400108d8: ba 28 80 1d andn %g2, %i5, %i5
400108dc: fa 20 62 14 st %i5, [ %g1 + 0x214 ]
}
_ISR_Enable( level );
400108e0: 7f ff c7 00 call 400024e0 <sparc_enable_interrupts>
400108e4: 91 e8 00 08 restore %g0, %o0, %o0
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
400108e8: b0 16 22 18 or %i0, 0x218, %i0
400108ec: c4 00 40 18 ld [ %g1 + %i0 ], %g2
400108f0: b0 00 40 18 add %g1, %i0, %i0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
400108f4: b0 06 20 04 add %i0, 4, %i0
400108f8: 80 a0 80 18 cmp %g2, %i0
400108fc: 02 bf ff f6 be 400108d4 <_POSIX_signals_Clear_process_signals+0x3c><== ALWAYS TAKEN
40010900: 03 10 00 82 sethi %hi(0x40020800), %g1
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
40010904: 7f ff c6 f7 call 400024e0 <sparc_enable_interrupts> <== NOT EXECUTED
40010908: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40008ec0 <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
40008ec0: 82 10 20 1b mov 0x1b, %g1
40008ec4: 86 10 20 01 mov 1, %g3
#include <rtems/posix/psignalimpl.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
40008ec8: 84 00 7f ff add %g1, -1, %g2
40008ecc: 85 28 c0 02 sll %g3, %g2, %g2
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
40008ed0: 80 88 80 08 btst %g2, %o0
40008ed4: 12 80 00 11 bne 40008f18 <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
40008ed8: 01 00 00 00 nop
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
40008edc: 82 00 60 01 inc %g1
40008ee0: 80 a0 60 20 cmp %g1, 0x20
40008ee4: 12 bf ff fa bne 40008ecc <_POSIX_signals_Get_lowest+0xc>
40008ee8: 84 00 7f ff add %g1, -1, %g2
40008eec: 82 10 20 01 mov 1, %g1
40008ef0: 10 80 00 05 b 40008f04 <_POSIX_signals_Get_lowest+0x44>
40008ef4: 86 10 20 01 mov 1, %g3
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
40008ef8: 80 a0 60 1b cmp %g1, 0x1b
40008efc: 02 80 00 07 be 40008f18 <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
40008f00: 01 00 00 00 nop
#include <rtems/posix/psignalimpl.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
40008f04: 84 00 7f ff add %g1, -1, %g2
40008f08: 85 28 c0 02 sll %g3, %g2, %g2
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
40008f0c: 80 88 80 08 btst %g2, %o0
40008f10: 22 bf ff fa be,a 40008ef8 <_POSIX_signals_Get_lowest+0x38>
40008f14: 82 00 60 01 inc %g1
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
40008f18: 81 c3 e0 08 retl
40008f1c: 90 10 00 01 mov %g1, %o0
4000dadc <_POSIX_signals_Post_switch_hook>:
*/
static void _POSIX_signals_Post_switch_hook(
Thread_Control *the_thread
)
{
4000dadc: 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;
4000dae0: 35 10 00 81 sethi %hi(0x40020400), %i2
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000dae4: f8 06 21 50 ld [ %i0 + 0x150 ], %i4
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
4000dae8: b4 16 a3 c0 or %i2, 0x3c0, %i2
4000daec: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
4000daf0: 80 a7 20 00 cmp %i4, 0
4000daf4: 02 80 00 34 be 4000dbc4 <_POSIX_signals_Post_switch_hook+0xe8><== NEVER TAKEN
4000daf8: f2 00 60 34 ld [ %g1 + 0x34 ], %i1
*
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
4000dafc: 7f ff d2 75 call 400024d0 <sparc_disable_interrupts>
4000db00: 37 10 00 82 sethi %hi(0x40020800), %i3
4000db04: b6 16 e2 14 or %i3, 0x214, %i3 ! 40020a14 <_POSIX_signals_Pending>
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
4000db08: c6 06 c0 00 ld [ %i3 ], %g3
4000db0c: c2 07 20 d4 ld [ %i4 + 0xd4 ], %g1
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
4000db10: c4 07 20 d0 ld [ %i4 + 0xd0 ], %g2
(api->signals_pending | _POSIX_signals_Pending)) ) {
4000db14: 82 10 c0 01 or %g3, %g1, %g1
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
4000db18: 80 a8 40 02 andncc %g1, %g2, %g0
4000db1c: 02 80 00 26 be 4000dbb4 <_POSIX_signals_Post_switch_hook+0xd8>
4000db20: 01 00 00 00 nop
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
4000db24: 7f ff d2 6f call 400024e0 <sparc_enable_interrupts>
4000db28: ba 10 20 1b mov 0x1b, %i5 ! 1b <PROM_START+0x1b>
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
4000db2c: 92 10 00 1d mov %i5, %o1
4000db30: 94 10 20 00 clr %o2
4000db34: 40 00 09 a9 call 400101d8 <_POSIX_signals_Check_signal>
4000db38: 90 10 00 1c mov %i4, %o0
_POSIX_signals_Check_signal( api, signo, true );
4000db3c: 92 10 00 1d mov %i5, %o1
4000db40: 90 10 00 1c mov %i4, %o0
4000db44: 40 00 09 a5 call 400101d8 <_POSIX_signals_Check_signal>
4000db48: 94 10 20 01 mov 1, %o2
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
4000db4c: ba 07 60 01 inc %i5
4000db50: 80 a7 60 20 cmp %i5, 0x20
4000db54: 12 bf ff f7 bne 4000db30 <_POSIX_signals_Post_switch_hook+0x54>
4000db58: 92 10 00 1d mov %i5, %o1
4000db5c: ba 10 20 01 mov 1, %i5
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
4000db60: 92 10 00 1d mov %i5, %o1
4000db64: 94 10 20 00 clr %o2
4000db68: 40 00 09 9c call 400101d8 <_POSIX_signals_Check_signal>
4000db6c: 90 10 00 1c mov %i4, %o0
_POSIX_signals_Check_signal( api, signo, true );
4000db70: 92 10 00 1d mov %i5, %o1
4000db74: 90 10 00 1c mov %i4, %o0
4000db78: 40 00 09 98 call 400101d8 <_POSIX_signals_Check_signal>
4000db7c: 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++ ) {
4000db80: ba 07 60 01 inc %i5
4000db84: 80 a7 60 1b cmp %i5, 0x1b
4000db88: 12 bf ff f7 bne 4000db64 <_POSIX_signals_Post_switch_hook+0x88>
4000db8c: 92 10 00 1d mov %i5, %o1
*
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
4000db90: 7f ff d2 50 call 400024d0 <sparc_disable_interrupts>
4000db94: 01 00 00 00 nop
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
4000db98: c6 06 c0 00 ld [ %i3 ], %g3
4000db9c: c2 07 20 d4 ld [ %i4 + 0xd4 ], %g1
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
4000dba0: c4 07 20 d0 ld [ %i4 + 0xd0 ], %g2
(api->signals_pending | _POSIX_signals_Pending)) ) {
4000dba4: 82 10 c0 01 or %g3, %g1, %g1
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
4000dba8: 80 a8 40 02 andncc %g1, %g2, %g0
4000dbac: 12 bf ff de bne 4000db24 <_POSIX_signals_Post_switch_hook+0x48><== NEVER TAKEN
4000dbb0: 01 00 00 00 nop
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
4000dbb4: 7f ff d2 4b call 400024e0 <sparc_enable_interrupts>
4000dbb8: 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;
4000dbbc: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
4000dbc0: f2 20 60 34 st %i1, [ %g1 + 0x34 ]
4000dbc4: 81 c7 e0 08 ret
4000dbc8: 81 e8 00 00 restore
4001cef8 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
4001cef8: 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 ) ) {
4001cefc: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4001cf00: 05 04 00 20 sethi %hi(0x10008000), %g2
4001cf04: 88 10 20 01 mov 1, %g4
4001cf08: 86 06 7f ff add %i1, -1, %g3
4001cf0c: ba 08 40 02 and %g1, %g2, %i5
{
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4001cf10: f8 06 21 50 ld [ %i0 + 0x150 ], %i4
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
4001cf14: 80 a7 40 02 cmp %i5, %g2
4001cf18: 02 80 00 2c be 4001cfc8 <_POSIX_signals_Unblock_thread+0xd0>
4001cf1c: 87 29 00 03 sll %g4, %g3, %g3
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
4001cf20: c4 07 20 d0 ld [ %i4 + 0xd0 ], %g2
4001cf24: 80 a8 c0 02 andncc %g3, %g2, %g0
4001cf28: 02 80 00 24 be 4001cfb8 <_POSIX_signals_Unblock_thread+0xc0>
4001cf2c: 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 ) ) {
4001cf30: 80 88 40 02 btst %g1, %g2
4001cf34: 02 80 00 15 be 4001cf88 <_POSIX_signals_Unblock_thread+0x90>
4001cf38: 80 a0 60 00 cmp %g1, 0
the_thread->Wait.return_code = EINTR;
4001cf3c: 84 10 20 04 mov 4, %g2
4001cf40: c4 26 20 34 st %g2, [ %i0 + 0x34 ]
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
4001cf44: 05 00 00 ef sethi %hi(0x3bc00), %g2
4001cf48: 84 10 a2 e0 or %g2, 0x2e0, %g2 ! 3bee0 <PROM_START+0x3bee0>
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
4001cf4c: 80 88 40 02 btst %g1, %g2
4001cf50: 12 80 00 38 bne 4001d030 <_POSIX_signals_Unblock_thread+0x138>
4001cf54: 80 88 60 08 btst 8, %g1
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
4001cf58: 22 80 00 19 be,a 4001cfbc <_POSIX_signals_Unblock_thread+0xc4><== NEVER TAKEN
4001cf5c: b0 10 20 00 clr %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
4001cf60: 7f ff bb f5 call 4000bf34 <_Watchdog_Remove>
4001cf64: 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 );
4001cf68: 90 10 00 18 mov %i0, %o0
4001cf6c: 13 04 01 ff sethi %hi(0x1007fc00), %o1
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
4001cf70: b0 10 20 00 clr %i0
4001cf74: 7f ff b7 68 call 4000ad14 <_Thread_Clear_state>
4001cf78: 92 12 63 f8 or %o1, 0x3f8, %o1
4001cf7c: b0 0e 20 01 and %i0, 1, %i0
4001cf80: 81 c7 e0 08 ret
4001cf84: 81 e8 00 00 restore
else if ( _States_Is_delaying(the_thread->current_state) ) {
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
4001cf88: 32 80 00 0d bne,a 4001cfbc <_POSIX_signals_Unblock_thread+0xc4><== NEVER TAKEN
4001cf8c: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001cf90: 03 10 00 81 sethi %hi(0x40020400), %g1
4001cf94: 82 10 63 c0 or %g1, 0x3c0, %g1 ! 400207c0 <_Per_CPU_Information>
4001cf98: c4 00 60 08 ld [ %g1 + 8 ], %g2
4001cf9c: 80 a0 a0 00 cmp %g2, 0
4001cfa0: 22 80 00 07 be,a 4001cfbc <_POSIX_signals_Unblock_thread+0xc4>
4001cfa4: b0 10 20 00 clr %i0
4001cfa8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001cfac: 80 a6 00 02 cmp %i0, %g2
4001cfb0: 22 80 00 02 be,a 4001cfb8 <_POSIX_signals_Unblock_thread+0xc0><== ALWAYS TAKEN
4001cfb4: c8 28 60 0c stb %g4, [ %g1 + 0xc ]
_Thread_Dispatch_necessary = true;
}
}
return false;
4001cfb8: b0 10 20 00 clr %i0
}
4001cfbc: b0 0e 20 01 and %i0, 1, %i0
4001cfc0: 81 c7 e0 08 ret
4001cfc4: 81 e8 00 00 restore
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
4001cfc8: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
4001cfcc: 80 88 c0 01 btst %g3, %g1
4001cfd0: 22 80 00 13 be,a 4001d01c <_POSIX_signals_Unblock_thread+0x124>
4001cfd4: c2 07 20 d0 ld [ %i4 + 0xd0 ], %g1
the_thread->Wait.return_code = EINTR;
4001cfd8: 82 10 20 04 mov 4, %g1
4001cfdc: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
4001cfe0: 80 a6 a0 00 cmp %i2, 0
4001cfe4: 02 80 00 19 be 4001d048 <_POSIX_signals_Unblock_thread+0x150>
4001cfe8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
the_info->si_signo = signo;
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
4001cfec: c4 06 80 00 ld [ %i2 ], %g2
4001cff0: c4 20 40 00 st %g2, [ %g1 ]
4001cff4: c4 06 a0 04 ld [ %i2 + 4 ], %g2
4001cff8: c4 20 60 04 st %g2, [ %g1 + 4 ]
4001cffc: c4 06 a0 08 ld [ %i2 + 8 ], %g2
4001d000: c4 20 60 08 st %g2, [ %g1 + 8 ]
}
_Thread_queue_Extract_with_proxy( the_thread );
4001d004: 90 10 00 18 mov %i0, %o0
4001d008: 7f ff ba 19 call 4000b86c <_Thread_queue_Extract_with_proxy>
4001d00c: b0 10 20 01 mov 1, %i0
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
4001d010: b0 0e 20 01 and %i0, 1, %i0
4001d014: 81 c7 e0 08 ret
4001d018: 81 e8 00 00 restore
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
4001d01c: 80 a8 c0 01 andncc %g3, %g1, %g0
4001d020: 32 bf ff ef bne,a 4001cfdc <_POSIX_signals_Unblock_thread+0xe4>
4001d024: 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;
4001d028: 10 bf ff e5 b 4001cfbc <_POSIX_signals_Unblock_thread+0xc4>
4001d02c: 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 );
4001d030: 90 10 00 18 mov %i0, %o0
4001d034: 7f ff ba 0e call 4000b86c <_Thread_queue_Extract_with_proxy>
4001d038: b0 10 20 00 clr %i0
4001d03c: b0 0e 20 01 and %i0, 1, %i0
4001d040: 81 c7 e0 08 ret
4001d044: 81 e8 00 00 restore
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
4001d048: 84 10 20 01 mov 1, %g2
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
4001d04c: f2 20 40 00 st %i1, [ %g1 ]
the_info->si_code = SI_USER;
4001d050: c4 20 60 04 st %g2, [ %g1 + 4 ]
the_info->si_value.sival_int = 0;
4001d054: 10 bf ff ec b 4001d004 <_POSIX_signals_Unblock_thread+0x10c>
4001d058: c0 20 60 08 clr [ %g1 + 8 ]
4000aff4 <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
4000aff4: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
4000aff8: 80 a6 60 00 cmp %i1, 0
4000affc: 02 80 00 4c be 4000b12c <_RBTree_Extract_unprotected+0x138>
4000b000: 01 00 00 00 nop
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
4000b004: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000b008: 80 a0 40 19 cmp %g1, %i1
4000b00c: 02 80 00 56 be 4000b164 <_RBTree_Extract_unprotected+0x170>
4000b010: 90 10 00 19 mov %i1, %o0
the_rbtree->first[RBT_LEFT] = next;
}
/* Check if max needs to be updated. min=max for 1 element trees so
* do not use else if here. */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
4000b014: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000b018: 80 a0 40 19 cmp %g1, %i1
4000b01c: 02 80 00 56 be 4000b174 <_RBTree_Extract_unprotected+0x180>
4000b020: 90 10 00 19 mov %i1, %o0
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
4000b024: fa 06 60 04 ld [ %i1 + 4 ], %i5
4000b028: 80 a7 60 00 cmp %i5, 0
4000b02c: 22 80 00 5a be,a 4000b194 <_RBTree_Extract_unprotected+0x1a0>
4000b030: f8 06 60 08 ld [ %i1 + 8 ], %i4
4000b034: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000b038: 80 a0 60 00 cmp %g1, 0
4000b03c: 32 80 00 05 bne,a 4000b050 <_RBTree_Extract_unprotected+0x5c>
4000b040: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000b044: 10 80 00 3c b 4000b134 <_RBTree_Extract_unprotected+0x140>
4000b048: 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];
4000b04c: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000b050: 80 a0 60 00 cmp %g1, 0
4000b054: 32 bf ff fe bne,a 4000b04c <_RBTree_Extract_unprotected+0x58>
4000b058: 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];
4000b05c: f8 07 60 04 ld [ %i5 + 4 ], %i4
if(leaf) {
4000b060: 80 a7 20 00 cmp %i4, 0
4000b064: 02 80 00 48 be 4000b184 <_RBTree_Extract_unprotected+0x190>
4000b068: 01 00 00 00 nop
leaf->parent = target->parent;
4000b06c: c2 07 40 00 ld [ %i5 ], %g1
4000b070: c2 27 00 00 st %g1, [ %i4 ]
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
dir = target != target->parent->child[0];
4000b074: c4 07 40 00 ld [ %i5 ], %g2
target->parent->child[dir] = leaf;
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
4000b078: c2 06 40 00 ld [ %i1 ], %g1
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
dir = target != target->parent->child[0];
4000b07c: c8 00 a0 04 ld [ %g2 + 4 ], %g4
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
4000b080: c6 07 60 0c ld [ %i5 + 0xc ], %g3
dir = target != target->parent->child[0];
4000b084: 88 1f 40 04 xor %i5, %g4, %g4
4000b088: 80 a0 00 04 cmp %g0, %g4
4000b08c: 88 40 20 00 addx %g0, 0, %g4
target->parent->child[dir] = leaf;
4000b090: 89 29 20 02 sll %g4, 2, %g4
4000b094: 84 00 80 04 add %g2, %g4, %g2
4000b098: f8 20 a0 04 st %i4, [ %g2 + 4 ]
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
4000b09c: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000b0a0: 84 18 80 19 xor %g2, %i1, %g2
4000b0a4: 80 a0 00 02 cmp %g0, %g2
4000b0a8: 84 40 20 00 addx %g0, 0, %g2
the_node->parent->child[dir] = target;
4000b0ac: 85 28 a0 02 sll %g2, 2, %g2
4000b0b0: 82 00 40 02 add %g1, %g2, %g1
4000b0b4: fa 20 60 04 st %i5, [ %g1 + 4 ]
/* set target's new children to the original node's children */
target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];
4000b0b8: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000b0bc: c2 27 60 08 st %g1, [ %i5 + 8 ]
if (the_node->child[RBT_RIGHT])
4000b0c0: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000b0c4: 80 a0 60 00 cmp %g1, 0
4000b0c8: 32 80 00 02 bne,a 4000b0d0 <_RBTree_Extract_unprotected+0xdc><== ALWAYS TAKEN
4000b0cc: fa 20 40 00 st %i5, [ %g1 ]
the_node->child[RBT_RIGHT]->parent = target;
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
4000b0d0: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000b0d4: c2 27 60 04 st %g1, [ %i5 + 4 ]
if (the_node->child[RBT_LEFT])
4000b0d8: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000b0dc: 80 a0 60 00 cmp %g1, 0
4000b0e0: 32 80 00 02 bne,a 4000b0e8 <_RBTree_Extract_unprotected+0xf4>
4000b0e4: fa 20 40 00 st %i5, [ %g1 ]
/* finally, update the parent node and recolor. target has completely
* replaced the_node, and target's child has moved up the tree if needed.
* the_node is no longer part of the tree, although it has valid pointers
* still.
*/
target->parent = the_node->parent;
4000b0e8: c4 06 40 00 ld [ %i1 ], %g2
target->color = the_node->color;
4000b0ec: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/* finally, update the parent node and recolor. target has completely
* replaced the_node, and target's child has moved up the tree if needed.
* the_node is no longer part of the tree, although it has valid pointers
* still.
*/
target->parent = the_node->parent;
4000b0f0: c4 27 40 00 st %g2, [ %i5 ]
target->color = the_node->color;
4000b0f4: c2 27 60 0c st %g1, [ %i5 + 0xc ]
/* fix coloring. leaf has moved up the tree. The color of the deleted
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
4000b0f8: 80 a0 e0 00 cmp %g3, 0
4000b0fc: 32 80 00 06 bne,a 4000b114 <_RBTree_Extract_unprotected+0x120>
4000b100: c2 06 20 04 ld [ %i0 + 4 ], %g1
if (leaf) {
4000b104: 80 a7 20 00 cmp %i4, 0
4000b108: 32 80 00 02 bne,a 4000b110 <_RBTree_Extract_unprotected+0x11c>
4000b10c: 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;
4000b110: 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;
4000b114: c0 26 60 08 clr [ %i1 + 8 ]
4000b118: c0 26 60 04 clr [ %i1 + 4 ]
4000b11c: 80 a0 60 00 cmp %g1, 0
4000b120: 02 80 00 03 be 4000b12c <_RBTree_Extract_unprotected+0x138>
4000b124: c0 26 40 00 clr [ %i1 ]
4000b128: c0 20 60 0c clr [ %g1 + 0xc ]
4000b12c: 81 c7 e0 08 ret
4000b130: 81 e8 00 00 restore
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
if( leaf ) {
leaf->parent = the_node->parent;
4000b134: c2 06 40 00 ld [ %i1 ], %g1
4000b138: c2 27 00 00 st %g1, [ %i4 ]
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
4000b13c: c2 06 40 00 ld [ %i1 ], %g1
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
4000b140: c6 06 60 0c ld [ %i1 + 0xc ], %g3
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
4000b144: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000b148: 84 18 80 19 xor %g2, %i1, %g2
4000b14c: 80 a0 00 02 cmp %g0, %g2
4000b150: 84 40 20 00 addx %g0, 0, %g2
the_node->parent->child[dir] = leaf;
4000b154: 85 28 a0 02 sll %g2, 2, %g2
4000b158: 82 00 40 02 add %g1, %g2, %g1
4000b15c: 10 bf ff e7 b 4000b0f8 <_RBTree_Extract_unprotected+0x104>
4000b160: f8 20 60 04 st %i4, [ %g1 + 4 ]
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_RIGHT );
4000b164: 40 00 00 eb call 4000b510 <_RBTree_Next_unprotected>
4000b168: 92 10 20 01 mov 1, %o1
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
RBTree_Node *next;
next = _RBTree_Successor_unprotected(the_node);
the_rbtree->first[RBT_LEFT] = next;
4000b16c: 10 bf ff aa b 4000b014 <_RBTree_Extract_unprotected+0x20>
4000b170: d0 26 20 08 st %o0, [ %i0 + 8 ]
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_LEFT );
4000b174: 40 00 00 e7 call 4000b510 <_RBTree_Next_unprotected>
4000b178: 92 10 20 00 clr %o1
/* Check if max needs to be updated. min=max for 1 element trees so
* do not use else if here. */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
RBTree_Node *previous;
previous = _RBTree_Predecessor_unprotected(the_node);
the_rbtree->first[RBT_RIGHT] = previous;
4000b17c: 10 bf ff aa b 4000b024 <_RBTree_Extract_unprotected+0x30>
4000b180: d0 26 20 0c st %o0, [ %i0 + 0xc ]
leaf = target->child[RBT_LEFT];
if(leaf) {
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
4000b184: 7f ff fe d3 call 4000acd0 <_RBTree_Extract_validate_unprotected>
4000b188: 90 10 00 1d mov %i5, %o0
}
victim_color = target->color;
dir = target != target->parent->child[0];
4000b18c: 10 bf ff bb b 4000b078 <_RBTree_Extract_unprotected+0x84>
4000b190: c4 07 40 00 ld [ %i5 ], %g2
* violated. We will fix it later.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
if( leaf ) {
4000b194: 80 a7 20 00 cmp %i4, 0
4000b198: 32 bf ff e8 bne,a 4000b138 <_RBTree_Extract_unprotected+0x144>
4000b19c: c2 06 40 00 ld [ %i1 ], %g1
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
4000b1a0: 7f ff fe cc call 4000acd0 <_RBTree_Extract_validate_unprotected>
4000b1a4: 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];
4000b1a8: 10 bf ff e6 b 4000b140 <_RBTree_Extract_unprotected+0x14c>
4000b1ac: c2 06 40 00 ld [ %i1 ], %g1
4000acd0 <_RBTree_Extract_validate_unprotected>:
)
{
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
4000acd0: c2 02 00 00 ld [ %o0 ], %g1
if(!parent->parent) return;
4000acd4: c4 00 40 00 ld [ %g1 ], %g2
4000acd8: 80 a0 a0 00 cmp %g2, 0
4000acdc: 02 80 00 3f be 4000add8 <_RBTree_Extract_validate_unprotected+0x108>
4000ace0: 01 00 00 00 nop
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
4000ace4: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000ace8: 80 a2 00 02 cmp %o0, %g2
4000acec: 22 80 00 02 be,a 4000acf4 <_RBTree_Extract_validate_unprotected+0x24>
4000acf0: c4 00 60 08 ld [ %g1 + 8 ], %g2
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4000acf4: c6 02 20 0c ld [ %o0 + 0xc ], %g3
4000acf8: 80 a0 e0 01 cmp %g3, 1
4000acfc: 02 80 00 32 be 4000adc4 <_RBTree_Extract_validate_unprotected+0xf4>
4000ad00: 9a 10 20 01 mov 1, %o5
sibling = _RBTree_Sibling(the_node);
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
4000ad04: c6 00 40 00 ld [ %g1 ], %g3
4000ad08: 80 a0 e0 00 cmp %g3, 0
4000ad0c: 02 80 00 2e be 4000adc4 <_RBTree_Extract_validate_unprotected+0xf4>
4000ad10: 80 a0 a0 00 cmp %g2, 0
4000ad14: 22 80 00 07 be,a 4000ad30 <_RBTree_Extract_validate_unprotected+0x60><== NEVER TAKEN
4000ad18: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED
4000ad1c: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
4000ad20: 80 a1 20 01 cmp %g4, 1
4000ad24: 22 80 00 63 be,a 4000aeb0 <_RBTree_Extract_validate_unprotected+0x1e0>
4000ad28: d8 00 60 04 ld [ %g1 + 4 ], %o4
_RBTree_Rotate(parent, dir);
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
4000ad2c: c6 00 a0 08 ld [ %g2 + 8 ], %g3
4000ad30: 80 a0 e0 00 cmp %g3, 0
4000ad34: 22 80 00 07 be,a 4000ad50 <_RBTree_Extract_validate_unprotected+0x80>
4000ad38: c6 00 a0 04 ld [ %g2 + 4 ], %g3
4000ad3c: c6 00 e0 0c ld [ %g3 + 0xc ], %g3
4000ad40: 80 a0 e0 01 cmp %g3, 1
4000ad44: 22 80 00 29 be,a 4000ade8 <_RBTree_Extract_validate_unprotected+0x118>
4000ad48: c6 00 60 04 ld [ %g1 + 4 ], %g3
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
4000ad4c: c6 00 a0 04 ld [ %g2 + 4 ], %g3
4000ad50: 80 a0 e0 00 cmp %g3, 0
4000ad54: 22 80 00 07 be,a 4000ad70 <_RBTree_Extract_validate_unprotected+0xa0>
4000ad58: da 20 a0 0c st %o5, [ %g2 + 0xc ]
4000ad5c: c6 00 e0 0c ld [ %g3 + 0xc ], %g3
4000ad60: 80 a0 e0 01 cmp %g3, 1
4000ad64: 22 80 00 21 be,a 4000ade8 <_RBTree_Extract_validate_unprotected+0x118>
4000ad68: c6 00 60 04 ld [ %g1 + 4 ], %g3
sibling->color = RBT_RED;
4000ad6c: da 20 a0 0c st %o5, [ %g2 + 0xc ]
4000ad70: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000ad74: 80 a0 a0 01 cmp %g2, 1
4000ad78: 22 80 00 99 be,a 4000afdc <_RBTree_Extract_validate_unprotected+0x30c>
4000ad7c: c0 20 60 0c clr [ %g1 + 0xc ]
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
4000ad80: c6 00 40 00 ld [ %g1 ], %g3
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
4000ad84: 80 a0 e0 00 cmp %g3, 0
4000ad88: 02 80 00 6c be 4000af38 <_RBTree_Extract_validate_unprotected+0x268><== NEVER TAKEN
4000ad8c: 90 10 00 01 mov %g1, %o0
if(!(the_node->parent->parent)) return NULL;
4000ad90: c4 00 c0 00 ld [ %g3 ], %g2
4000ad94: 80 a0 a0 00 cmp %g2, 0
4000ad98: 02 80 00 69 be 4000af3c <_RBTree_Extract_validate_unprotected+0x26c>
4000ad9c: 84 10 20 00 clr %g2
if(the_node == the_node->parent->child[RBT_LEFT])
4000ada0: c4 00 e0 04 ld [ %g3 + 4 ], %g2
4000ada4: 80 a0 40 02 cmp %g1, %g2
4000ada8: 22 80 00 0e be,a 4000ade0 <_RBTree_Extract_validate_unprotected+0x110>
4000adac: c4 00 e0 08 ld [ %g3 + 8 ], %g2
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
4000adb0: 82 10 00 03 mov %g3, %g1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4000adb4: c6 02 20 0c ld [ %o0 + 0xc ], %g3
4000adb8: 80 a0 e0 01 cmp %g3, 1
4000adbc: 32 bf ff d3 bne,a 4000ad08 <_RBTree_Extract_validate_unprotected+0x38><== ALWAYS TAKEN
4000adc0: c6 00 40 00 ld [ %g1 ], %g3
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
4000adc4: c2 02 00 00 ld [ %o0 ], %g1
4000adc8: c2 00 40 00 ld [ %g1 ], %g1
4000adcc: 80 a0 60 00 cmp %g1, 0
4000add0: 02 80 00 5f be 4000af4c <_RBTree_Extract_validate_unprotected+0x27c>
4000add4: 01 00 00 00 nop
4000add8: 81 c3 e0 08 retl
4000addc: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
4000ade0: 10 bf ff f5 b 4000adb4 <_RBTree_Extract_validate_unprotected+0xe4>
4000ade4: 82 10 00 03 mov %g3, %g1
* cases, either the_node is to the left or the right of the parent.
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
4000ade8: 86 1a 00 03 xor %o0, %g3, %g3
4000adec: 80 a0 00 03 cmp %g0, %g3
4000adf0: 9a 40 20 00 addx %g0, 0, %o5
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
4000adf4: 86 1b 60 01 xor %o5, 1, %g3
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
4000adf8: 87 28 e0 02 sll %g3, 2, %g3
4000adfc: 88 00 80 03 add %g2, %g3, %g4
4000ae00: c8 01 20 04 ld [ %g4 + 4 ], %g4
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4000ae04: 80 a1 20 00 cmp %g4, 0
4000ae08: 22 80 00 07 be,a 4000ae24 <_RBTree_Extract_validate_unprotected+0x154>
4000ae0c: 9b 2b 60 02 sll %o5, 2, %o5
4000ae10: d8 01 20 0c ld [ %g4 + 0xc ], %o4
4000ae14: 80 a3 20 01 cmp %o4, 1
4000ae18: 22 80 00 4f be,a 4000af54 <_RBTree_Extract_validate_unprotected+0x284>
4000ae1c: d6 00 60 0c ld [ %g1 + 0xc ], %o3
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
4000ae20: 9b 2b 60 02 sll %o5, 2, %o5
4000ae24: 98 00 80 0d add %g2, %o5, %o4
4000ae28: c8 03 20 04 ld [ %o4 + 4 ], %g4
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
sibling->color = RBT_RED;
4000ae2c: 96 10 20 01 mov 1, %o3
4000ae30: d6 20 a0 0c st %o3, [ %g2 + 0xc ]
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
4000ae34: 80 a1 20 00 cmp %g4, 0
4000ae38: 02 80 00 15 be 4000ae8c <_RBTree_Extract_validate_unprotected+0x1bc><== NEVER TAKEN
4000ae3c: c0 21 20 0c clr [ %g4 + 0xc ]
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
4000ae40: 96 01 00 03 add %g4, %g3, %o3
4000ae44: d4 02 e0 04 ld [ %o3 + 4 ], %o2
4000ae48: d4 23 20 04 st %o2, [ %o4 + 4 ]
if (c->child[dir])
4000ae4c: d8 02 e0 04 ld [ %o3 + 4 ], %o4
4000ae50: 80 a3 20 00 cmp %o4, 0
4000ae54: 32 80 00 02 bne,a 4000ae5c <_RBTree_Extract_validate_unprotected+0x18c>
4000ae58: c4 23 00 00 st %g2, [ %o4 ]
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000ae5c: d8 00 80 00 ld [ %g2 ], %o4
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
4000ae60: 96 01 00 03 add %g4, %g3, %o3
4000ae64: c4 22 e0 04 st %g2, [ %o3 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000ae68: d6 03 20 04 ld [ %o4 + 4 ], %o3
c->parent = the_node->parent;
4000ae6c: d8 21 00 00 st %o4, [ %g4 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000ae70: 96 18 80 0b xor %g2, %o3, %o3
c->parent = the_node->parent;
the_node->parent = c;
4000ae74: c8 20 80 00 st %g4, [ %g2 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000ae78: 80 a0 00 0b cmp %g0, %o3
4000ae7c: 84 40 20 00 addx %g0, 0, %g2
4000ae80: 85 28 a0 02 sll %g2, 2, %g2
4000ae84: 98 03 00 02 add %o4, %g2, %o4
4000ae88: c8 23 20 04 st %g4, [ %o4 + 4 ]
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
sibling->color = parent->color;
4000ae8c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
4000ae90: 84 00 40 03 add %g1, %g3, %g2
4000ae94: c4 00 a0 04 ld [ %g2 + 4 ], %g2
}
sibling->color = parent->color;
4000ae98: c8 20 a0 0c st %g4, [ %g2 + 0xc ]
4000ae9c: 88 00 80 03 add %g2, %g3, %g4
4000aea0: c8 01 20 04 ld [ %g4 + 4 ], %g4
parent->color = RBT_BLACK;
4000aea4: c0 20 60 0c clr [ %g1 + 0xc ]
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
4000aea8: 10 80 00 33 b 4000af74 <_RBTree_Extract_validate_unprotected+0x2a4>
4000aeac: c0 21 20 0c clr [ %g4 + 0xc ]
* then rotate parent left, making the sibling be the_node's grandparent.
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
4000aeb0: c8 20 60 0c st %g4, [ %g1 + 0xc ]
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
4000aeb4: 88 1b 00 08 xor %o4, %o0, %g4
4000aeb8: 80 a0 00 04 cmp %g0, %g4
4000aebc: 94 40 20 00 addx %g0, 0, %o2
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
4000aec0: 96 1a a0 01 xor %o2, 1, %o3
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
4000aec4: 97 2a e0 02 sll %o3, 2, %o3
4000aec8: 98 00 40 0b add %g1, %o3, %o4
4000aecc: c8 03 20 04 ld [ %o4 + 4 ], %g4
4000aed0: 80 a1 20 00 cmp %g4, 0
4000aed4: 02 80 00 1c be 4000af44 <_RBTree_Extract_validate_unprotected+0x274><== NEVER TAKEN
4000aed8: c0 20 a0 0c clr [ %g2 + 0xc ]
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
4000aedc: 95 2a a0 02 sll %o2, 2, %o2
4000aee0: 84 01 00 0a add %g4, %o2, %g2
4000aee4: d2 00 a0 04 ld [ %g2 + 4 ], %o1
4000aee8: d2 23 20 04 st %o1, [ %o4 + 4 ]
if (c->child[dir])
4000aeec: c4 00 a0 04 ld [ %g2 + 4 ], %g2
4000aef0: 80 a0 a0 00 cmp %g2, 0
4000aef4: 02 80 00 04 be 4000af04 <_RBTree_Extract_validate_unprotected+0x234><== NEVER TAKEN
4000aef8: 94 01 00 0a add %g4, %o2, %o2
c->child[dir]->parent = the_node;
4000aefc: c2 20 80 00 st %g1, [ %g2 ]
4000af00: c6 00 40 00 ld [ %g1 ], %g3
c->child[dir] = the_node;
4000af04: c2 22 a0 04 st %g1, [ %o2 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000af08: c4 00 e0 04 ld [ %g3 + 4 ], %g2
c->parent = the_node->parent;
4000af0c: c6 21 00 00 st %g3, [ %g4 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000af10: 84 18 40 02 xor %g1, %g2, %g2
4000af14: 80 a0 00 02 cmp %g0, %g2
4000af18: 84 40 20 00 addx %g0, 0, %g2
4000af1c: 85 28 a0 02 sll %g2, 2, %g2
4000af20: 96 00 40 0b add %g1, %o3, %o3
4000af24: 86 00 c0 02 add %g3, %g2, %g3
c->parent = the_node->parent;
the_node->parent = c;
4000af28: c8 20 40 00 st %g4, [ %g1 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000af2c: c8 20 e0 04 st %g4, [ %g3 + 4 ]
4000af30: 10 bf ff 7f b 4000ad2c <_RBTree_Extract_validate_unprotected+0x5c>
4000af34: c4 02 e0 04 ld [ %o3 + 4 ], %g2
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
4000af38: 84 10 20 00 clr %g2 <== NOT EXECUTED
4000af3c: 10 bf ff 9e b 4000adb4 <_RBTree_Extract_validate_unprotected+0xe4>
4000af40: 82 10 00 03 mov %g3, %g1
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
4000af44: 10 bf ff 7a b 4000ad2c <_RBTree_Extract_validate_unprotected+0x5c><== NOT EXECUTED
4000af48: 84 10 20 00 clr %g2 <== NOT EXECUTED
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
4000af4c: 81 c3 e0 08 retl
4000af50: c0 22 20 0c clr [ %o0 + 0xc ]
4000af54: 98 00 40 03 add %g1, %g3, %o4
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
sibling->color = parent->color;
4000af58: d6 20 a0 0c st %o3, [ %g2 + 0xc ]
parent->color = RBT_BLACK;
4000af5c: c0 20 60 0c clr [ %g1 + 0xc ]
4000af60: c4 03 20 04 ld [ %o4 + 4 ], %g2
4000af64: 80 a0 a0 00 cmp %g2, 0
4000af68: 02 bf ff 97 be 4000adc4 <_RBTree_Extract_validate_unprotected+0xf4><== NEVER TAKEN
4000af6c: c0 21 20 0c clr [ %g4 + 0xc ]
4000af70: 9b 2b 60 02 sll %o5, 2, %o5
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
4000af74: 88 00 80 0d add %g2, %o5, %g4
4000af78: d8 01 20 04 ld [ %g4 + 4 ], %o4
4000af7c: 86 00 40 03 add %g1, %g3, %g3
4000af80: d8 20 e0 04 st %o4, [ %g3 + 4 ]
if (c->child[dir])
4000af84: c6 01 20 04 ld [ %g4 + 4 ], %g3
4000af88: 80 a0 e0 00 cmp %g3, 0
4000af8c: 32 80 00 02 bne,a 4000af94 <_RBTree_Extract_validate_unprotected+0x2c4>
4000af90: c2 20 c0 00 st %g1, [ %g3 ]
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000af94: c6 00 40 00 ld [ %g1 ], %g3
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
4000af98: 9a 00 80 0d add %g2, %o5, %o5
4000af9c: c2 23 60 04 st %g1, [ %o5 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000afa0: c8 00 e0 04 ld [ %g3 + 4 ], %g4
c->parent = the_node->parent;
4000afa4: c6 20 80 00 st %g3, [ %g2 ]
the_node->parent = c;
4000afa8: 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;
4000afac: 88 18 40 04 xor %g1, %g4, %g4
4000afb0: 80 a0 00 04 cmp %g0, %g4
4000afb4: 82 40 20 00 addx %g0, 0, %g1
4000afb8: 83 28 60 02 sll %g1, 2, %g1
4000afbc: 86 00 c0 01 add %g3, %g1, %g3
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
4000afc0: c2 02 00 00 ld [ %o0 ], %g1
4000afc4: c4 20 e0 04 st %g2, [ %g3 + 4 ]
4000afc8: c2 00 40 00 ld [ %g1 ], %g1
4000afcc: 80 a0 60 00 cmp %g1, 0
4000afd0: 12 bf ff 82 bne 4000add8 <_RBTree_Extract_validate_unprotected+0x108><== ALWAYS TAKEN
4000afd4: 01 00 00 00 nop
4000afd8: 30 bf ff dd b,a 4000af4c <_RBTree_Extract_validate_unprotected+0x27c><== NOT EXECUTED
4000afdc: c2 02 00 00 ld [ %o0 ], %g1
4000afe0: c2 00 40 00 ld [ %g1 ], %g1
4000afe4: 80 a0 60 00 cmp %g1, 0
4000afe8: 12 bf ff 7c bne 4000add8 <_RBTree_Extract_validate_unprotected+0x108><== ALWAYS TAKEN
4000afec: 01 00 00 00 nop
4000aff0: 30 bf ff d7 b,a 4000af4c <_RBTree_Extract_validate_unprotected+0x27c><== NOT EXECUTED
4000be8c <_RBTree_Find>:
RBTree_Node *_RBTree_Find(
RBTree_Control *the_rbtree,
RBTree_Node *search_node
)
{
4000be8c: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
RBTree_Node *return_node;
return_node = NULL;
_ISR_Disable( level );
4000be90: 7f ff df 23 call 40003b1c <sparc_disable_interrupts>
4000be94: b8 10 00 18 mov %i0, %i4
4000be98: b6 10 00 08 mov %o0, %i3
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
4000be9c: fa 06 20 04 ld [ %i0 + 4 ], %i5
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
4000bea0: 80 a7 60 00 cmp %i5, 0
4000bea4: 02 80 00 15 be 4000bef8 <_RBTree_Find+0x6c> <== NEVER TAKEN
4000bea8: b0 10 20 00 clr %i0
compare_result = the_rbtree->compare_function(the_node, iter_node);
4000beac: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
4000beb0: 92 10 00 1d mov %i5, %o1
4000beb4: 9f c0 40 00 call %g1
4000beb8: 90 10 00 19 mov %i1, %o0
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
4000bebc: 83 3a 20 1f sra %o0, 0x1f, %g1
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
4000bec0: 80 a2 20 00 cmp %o0, 0
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
4000bec4: 82 20 40 08 sub %g1, %o0, %g1
4000bec8: 83 30 60 1f srl %g1, 0x1f, %g1
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
4000becc: 83 28 60 02 sll %g1, 2, %g1
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
4000bed0: 12 80 00 06 bne 4000bee8 <_RBTree_Find+0x5c>
4000bed4: 82 07 40 01 add %i5, %g1, %g1
found = iter_node;
if ( the_rbtree->is_unique )
4000bed8: c4 0f 20 14 ldub [ %i4 + 0x14 ], %g2
4000bedc: 80 a0 a0 00 cmp %g2, 0
4000bee0: 12 80 00 0a bne 4000bf08 <_RBTree_Find+0x7c>
4000bee4: b0 10 00 1d mov %i5, %i0
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
4000bee8: fa 00 60 04 ld [ %g1 + 4 ], %i5
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
4000beec: 80 a7 60 00 cmp %i5, 0
4000bef0: 32 bf ff f0 bne,a 4000beb0 <_RBTree_Find+0x24>
4000bef4: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
return_node = _RBTree_Find_unprotected( the_rbtree, search_node );
_ISR_Enable( level );
4000bef8: 7f ff df 0d call 40003b2c <sparc_enable_interrupts>
4000befc: 90 10 00 1b mov %i3, %o0
return return_node;
}
4000bf00: 81 c7 e0 08 ret
4000bf04: 81 e8 00 00 restore
RBTree_Node *return_node;
return_node = NULL;
_ISR_Disable( level );
return_node = _RBTree_Find_unprotected( the_rbtree, search_node );
_ISR_Enable( level );
4000bf08: 7f ff df 09 call 40003b2c <sparc_enable_interrupts>
4000bf0c: 90 10 00 1b mov %i3, %o0
return return_node;
}
4000bf10: 81 c7 e0 08 ret
4000bf14: 81 e8 00 00 restore
4000c2f8 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
4000c2f8: 9d e3 bf a0 save %sp, -96, %sp
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
4000c2fc: 80 a6 20 00 cmp %i0, 0
4000c300: 02 80 00 0f be 4000c33c <_RBTree_Initialize+0x44> <== NEVER TAKEN
4000c304: 80 a6 e0 00 cmp %i3, 0
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
4000c308: c0 26 00 00 clr [ %i0 ]
the_rbtree->root = NULL;
4000c30c: c0 26 20 04 clr [ %i0 + 4 ]
the_rbtree->first[0] = NULL;
4000c310: c0 26 20 08 clr [ %i0 + 8 ]
the_rbtree->first[1] = NULL;
4000c314: c0 26 20 0c clr [ %i0 + 0xc ]
the_rbtree->compare_function = compare_function;
4000c318: 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-- ) {
4000c31c: 02 80 00 08 be 4000c33c <_RBTree_Initialize+0x44> <== NEVER TAKEN
4000c320: fa 2e 20 14 stb %i5, [ %i0 + 0x14 ]
_RBTree_Insert_unprotected(the_rbtree, next);
4000c324: 92 10 00 1a mov %i2, %o1
4000c328: 7f ff ff 0b call 4000bf54 <_RBTree_Insert_unprotected>
4000c32c: 90 10 00 18 mov %i0, %o0
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
4000c330: b6 86 ff ff addcc %i3, -1, %i3
4000c334: 12 bf ff fc bne 4000c324 <_RBTree_Initialize+0x2c>
4000c338: b4 06 80 1c add %i2, %i4, %i2
4000c33c: 81 c7 e0 08 ret
4000c340: 81 e8 00 00 restore
4000b1d4 <_RBTree_Insert_unprotected>:
*/
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
4000b1d4: 9d e3 bf a0 save %sp, -96, %sp
if(!the_node) return (RBTree_Node*)-1;
4000b1d8: 80 a6 60 00 cmp %i1, 0
4000b1dc: 02 80 00 9c be 4000b44c <_RBTree_Insert_unprotected+0x278>
4000b1e0: b8 10 00 18 mov %i0, %i4
RBTree_Node *iter_node = the_rbtree->root;
4000b1e4: fa 06 20 04 ld [ %i0 + 4 ], %i5
int compare_result;
if (!iter_node) { /* special case: first node inserted */
4000b1e8: 80 a7 60 00 cmp %i5, 0
4000b1ec: 32 80 00 05 bne,a 4000b200 <_RBTree_Insert_unprotected+0x2c>
4000b1f0: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
the_node->color = RBT_BLACK;
4000b1f4: 10 80 00 9a b 4000b45c <_RBTree_Insert_unprotected+0x288>
4000b1f8: c0 26 60 0c clr [ %i1 + 0xc ]
the_node->parent = (RBTree_Node *) the_rbtree;
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
} else {
/* typical binary search tree insert, descend tree to leaf and insert */
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
4000b1fc: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
4000b200: 92 10 00 1d mov %i5, %o1
4000b204: 9f c0 40 00 call %g1
4000b208: 90 10 00 19 mov %i1, %o0
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
4000b20c: c4 0f 20 14 ldub [ %i4 + 0x14 ], %g2
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
4000b210: b6 38 00 08 xnor %g0, %o0, %i3
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
} else {
/* typical binary search tree insert, descend tree to leaf and insert */
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
4000b214: 80 a0 a0 00 cmp %g2, 0
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
4000b218: b7 36 e0 1f srl %i3, 0x1f, %i3
if (!iter_node->child[dir]) {
4000b21c: 83 2e e0 02 sll %i3, 2, %g1
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
} else {
/* typical binary search tree insert, descend tree to leaf and insert */
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
4000b220: 02 80 00 05 be 4000b234 <_RBTree_Insert_unprotected+0x60>
4000b224: 82 07 40 01 add %i5, %g1, %g1
4000b228: 80 a2 20 00 cmp %o0, 0
4000b22c: 02 80 00 8a be 4000b454 <_RBTree_Insert_unprotected+0x280>
4000b230: 01 00 00 00 nop
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
if (!iter_node->child[dir]) {
4000b234: f0 00 60 04 ld [ %g1 + 4 ], %i0
4000b238: 80 a6 20 00 cmp %i0, 0
4000b23c: 32 bf ff f0 bne,a 4000b1fc <_RBTree_Insert_unprotected+0x28>
4000b240: ba 10 00 18 mov %i0, %i5
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
the_node->color = RBT_RED;
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
/* update min/max */
compare_result = the_rbtree->compare_function(
4000b244: c4 07 20 10 ld [ %i4 + 0x10 ], %g2
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
4000b248: b4 06 e0 02 add %i3, 2, %i2
4000b24c: 87 2e a0 02 sll %i2, 2, %g3
4000b250: d2 07 00 03 ld [ %i4 + %g3 ], %o1
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
if (!iter_node->child[dir]) {
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
4000b254: c0 26 60 08 clr [ %i1 + 8 ]
4000b258: c0 26 60 04 clr [ %i1 + 4 ]
the_node->color = RBT_RED;
iter_node->child[dir] = the_node;
4000b25c: 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;
4000b260: 82 10 20 01 mov 1, %g1
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
4000b264: fa 26 40 00 st %i5, [ %i1 ]
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
if (!iter_node->child[dir]) {
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
the_node->color = RBT_RED;
4000b268: c2 26 60 0c st %g1, [ %i1 + 0xc ]
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
/* update min/max */
compare_result = the_rbtree->compare_function(
4000b26c: 9f c0 80 00 call %g2
4000b270: 90 10 00 19 mov %i1, %o0
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
4000b274: 80 a6 e0 00 cmp %i3, 0
4000b278: 12 80 00 10 bne 4000b2b8 <_RBTree_Insert_unprotected+0xe4>
4000b27c: 80 a2 20 00 cmp %o0, 0
4000b280: 06 80 00 10 bl 4000b2c0 <_RBTree_Insert_unprotected+0xec>
4000b284: b5 2e a0 02 sll %i2, 2, %i2
4000b288: c2 06 40 00 ld [ %i1 ], %g1
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
}
the_node->parent->color = RBT_BLACK;
g->color = RBT_RED;
4000b28c: b4 10 20 01 mov 1, %i2
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
4000b290: c4 00 40 00 ld [ %g1 ], %g2
4000b294: 86 90 a0 00 orcc %g2, 0, %g3
4000b298: 22 80 00 06 be,a 4000b2b0 <_RBTree_Insert_unprotected+0xdc>
4000b29c: c0 26 60 0c clr [ %i1 + 0xc ]
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4000b2a0: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4000b2a4: 80 a1 20 01 cmp %g4, 1
4000b2a8: 22 80 00 08 be,a 4000b2c8 <_RBTree_Insert_unprotected+0xf4>
4000b2ac: f6 00 80 00 ld [ %g2 ], %i3
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
4000b2b0: 81 c7 e0 08 ret
4000b2b4: 81 e8 00 00 restore
compare_result = the_rbtree->compare_function(
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
(dir && _RBTree_Is_greater(compare_result)) ) {
4000b2b8: 04 bf ff f4 ble 4000b288 <_RBTree_Insert_unprotected+0xb4>
4000b2bc: b5 2e a0 02 sll %i2, 2, %i2
the_rbtree->first[dir] = the_node;
4000b2c0: 10 bf ff f2 b 4000b288 <_RBTree_Insert_unprotected+0xb4>
4000b2c4: f2 27 00 1a st %i1, [ %i4 + %i2 ]
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(!(the_node->parent->parent->parent)) return NULL;
4000b2c8: 80 a6 e0 00 cmp %i3, 0
4000b2cc: 02 80 00 0c be 4000b2fc <_RBTree_Insert_unprotected+0x128><== NEVER TAKEN
4000b2d0: c8 00 a0 04 ld [ %g2 + 4 ], %g4
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
4000b2d4: 80 a1 00 01 cmp %g4, %g1
4000b2d8: 02 80 00 5b be 4000b444 <_RBTree_Insert_unprotected+0x270>
4000b2dc: ba 10 00 04 mov %g4, %i5
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4000b2e0: 80 a7 60 00 cmp %i5, 0
4000b2e4: 22 80 00 07 be,a 4000b300 <_RBTree_Insert_unprotected+0x12c>
4000b2e8: fa 00 60 04 ld [ %g1 + 4 ], %i5
4000b2ec: f8 07 60 0c ld [ %i5 + 0xc ], %i4
4000b2f0: 80 a7 20 01 cmp %i4, 1
4000b2f4: 22 80 00 4f be,a 4000b430 <_RBTree_Insert_unprotected+0x25c>
4000b2f8: c0 20 60 0c clr [ %g1 + 0xc ]
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
4000b2fc: fa 00 60 04 ld [ %g1 + 4 ], %i5
RBTree_Direction pdir = the_node->parent != g->child[0];
4000b300: 88 18 40 04 xor %g1, %g4, %g4
4000b304: 80 a0 00 04 cmp %g0, %g4
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
4000b308: ba 1e 40 1d xor %i1, %i5, %i5
RBTree_Direction pdir = the_node->parent != g->child[0];
4000b30c: 88 40 20 00 addx %g0, 0, %g4
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
4000b310: 80 a0 00 1d cmp %g0, %i5
4000b314: ba 40 20 00 addx %g0, 0, %i5
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
4000b318: 80 a7 40 04 cmp %i5, %g4
4000b31c: 02 80 00 20 be 4000b39c <_RBTree_Insert_unprotected+0x1c8>
4000b320: 80 a0 00 04 cmp %g0, %g4
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
4000b324: b6 60 3f ff subx %g0, -1, %i3
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
4000b328: b7 2e e0 02 sll %i3, 2, %i3
4000b32c: b6 00 40 1b add %g1, %i3, %i3
4000b330: fa 06 e0 04 ld [ %i3 + 4 ], %i5
4000b334: 80 a7 60 00 cmp %i5, 0
4000b338: 02 80 00 16 be 4000b390 <_RBTree_Insert_unprotected+0x1bc><== NEVER TAKEN
4000b33c: b9 29 20 02 sll %g4, 2, %i4
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
4000b340: 9e 07 40 1c add %i5, %i4, %o7
4000b344: da 03 e0 04 ld [ %o7 + 4 ], %o5
4000b348: da 26 e0 04 st %o5, [ %i3 + 4 ]
if (c->child[dir])
4000b34c: f6 03 e0 04 ld [ %o7 + 4 ], %i3
4000b350: 80 a6 e0 00 cmp %i3, 0
4000b354: 22 80 00 05 be,a 4000b368 <_RBTree_Insert_unprotected+0x194>
4000b358: b6 07 40 1c add %i5, %i4, %i3
c->child[dir]->parent = the_node;
4000b35c: c2 26 c0 00 st %g1, [ %i3 ]
4000b360: c4 00 40 00 ld [ %g1 ], %g2
c->child[dir] = the_node;
4000b364: b6 07 40 1c add %i5, %i4, %i3
4000b368: c2 26 e0 04 st %g1, [ %i3 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000b36c: f6 00 a0 04 ld [ %g2 + 4 ], %i3
c->parent = the_node->parent;
4000b370: c4 27 40 00 st %g2, [ %i5 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000b374: b6 1e c0 01 xor %i3, %g1, %i3
c->parent = the_node->parent;
the_node->parent = c;
4000b378: fa 20 40 00 st %i5, [ %g1 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000b37c: 80 a0 00 1b cmp %g0, %i3
4000b380: 82 40 20 00 addx %g0, 0, %g1
4000b384: 83 28 60 02 sll %g1, 2, %g1
4000b388: 84 00 80 01 add %g2, %g1, %g2
4000b38c: fa 20 a0 04 st %i5, [ %g2 + 4 ]
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
4000b390: b2 06 40 1c add %i1, %i4, %i1
4000b394: f2 06 60 04 ld [ %i1 + 4 ], %i1
4000b398: c2 06 40 00 ld [ %i1 ], %g1
}
the_node->parent->color = RBT_BLACK;
4000b39c: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
4000b3a0: 88 26 80 04 sub %i2, %g4, %g4
4000b3a4: ba 19 20 01 xor %g4, 1, %i5
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
4000b3a8: bb 2f 60 02 sll %i5, 2, %i5
4000b3ac: ba 00 c0 1d add %g3, %i5, %i5
4000b3b0: c4 07 60 04 ld [ %i5 + 4 ], %g2
4000b3b4: 80 a0 a0 00 cmp %g2, 0
4000b3b8: 02 bf ff b6 be 4000b290 <_RBTree_Insert_unprotected+0xbc> <== NEVER TAKEN
4000b3bc: f4 20 e0 0c st %i2, [ %g3 + 0xc ]
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
4000b3c0: 89 29 20 02 sll %g4, 2, %g4
4000b3c4: 82 00 80 04 add %g2, %g4, %g1
4000b3c8: f8 00 60 04 ld [ %g1 + 4 ], %i4
4000b3cc: f8 27 60 04 st %i4, [ %i5 + 4 ]
if (c->child[dir])
4000b3d0: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000b3d4: 80 a0 60 00 cmp %g1, 0
4000b3d8: 32 80 00 02 bne,a 4000b3e0 <_RBTree_Insert_unprotected+0x20c>
4000b3dc: c6 20 40 00 st %g3, [ %g1 ]
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000b3e0: fa 00 c0 00 ld [ %g3 ], %i5
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
4000b3e4: 88 00 80 04 add %g2, %g4, %g4
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
c->parent = the_node->parent;
4000b3e8: fa 20 80 00 st %i5, [ %g2 ]
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
4000b3ec: c6 21 20 04 st %g3, [ %g4 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000b3f0: c8 07 60 04 ld [ %i5 + 4 ], %g4
c->parent = the_node->parent;
the_node->parent = c;
4000b3f4: c4 20 c0 00 st %g2, [ %g3 ]
4000b3f8: c2 06 40 00 ld [ %i1 ], %g1
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000b3fc: 86 18 c0 04 xor %g3, %g4, %g3
4000b400: 80 a0 00 03 cmp %g0, %g3
4000b404: 86 40 20 00 addx %g0, 0, %g3
4000b408: 87 28 e0 02 sll %g3, 2, %g3
4000b40c: ba 07 40 03 add %i5, %g3, %i5
4000b410: c4 27 60 04 st %g2, [ %i5 + 4 ]
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
4000b414: c4 00 40 00 ld [ %g1 ], %g2
4000b418: 86 90 a0 00 orcc %g2, 0, %g3
4000b41c: 32 bf ff a2 bne,a 4000b2a4 <_RBTree_Insert_unprotected+0xd0><== ALWAYS TAKEN
4000b420: c8 00 60 0c ld [ %g1 + 0xc ], %g4
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
4000b424: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
4000b428: 81 c7 e0 08 ret <== NOT EXECUTED
4000b42c: 81 e8 00 00 restore <== NOT EXECUTED
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
4000b430: c0 27 60 0c clr [ %i5 + 0xc ]
g->color = RBT_RED;
4000b434: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
4000b438: 82 10 00 1b mov %i3, %g1
4000b43c: 10 bf ff 95 b 4000b290 <_RBTree_Insert_unprotected+0xbc>
4000b440: b2 10 00 02 mov %g2, %i1
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
4000b444: 10 bf ff a7 b 4000b2e0 <_RBTree_Insert_unprotected+0x10c>
4000b448: fa 00 a0 08 ld [ %g2 + 8 ], %i5
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
if(!the_node) return (RBTree_Node*)-1;
4000b44c: 81 c7 e0 08 ret
4000b450: 91 e8 3f ff restore %g0, -1, %o0
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
} else {
/* typical binary search tree insert, descend tree to leaf and insert */
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
4000b454: 81 c7 e0 08 ret
4000b458: 91 e8 00 1d restore %g0, %i5, %o0
RBTree_Node *iter_node = the_rbtree->root;
int compare_result;
if (!iter_node) { /* special case: first node inserted */
the_node->color = RBT_BLACK;
the_rbtree->root = the_node;
4000b45c: f2 26 20 04 st %i1, [ %i0 + 4 ]
the_rbtree->first[0] = the_rbtree->first[1] = the_node;
4000b460: f2 26 20 0c st %i1, [ %i0 + 0xc ]
4000b464: f2 26 20 08 st %i1, [ %i0 + 8 ]
the_node->parent = (RBTree_Node *) the_rbtree;
4000b468: f0 26 40 00 st %i0, [ %i1 ]
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
4000b46c: c0 26 60 08 clr [ %i1 + 8 ]
4000b470: c0 26 60 04 clr [ %i1 + 4 ]
} /* while(iter_node) */
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
4000b474: 81 c7 e0 08 ret
4000b478: 91 e8 20 00 restore %g0, 0, %o0
4000b4ac <_RBTree_Iterate_unprotected>:
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
4000b4ac: 9d e3 bf a0 save %sp, -96, %sp
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
4000b4b0: 80 a0 00 19 cmp %g0, %i1
4000b4b4: 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];
4000b4b8: 82 00 60 02 add %g1, 2, %g1
4000b4bc: 83 28 60 02 sll %g1, 2, %g1
4000b4c0: fa 06 00 01 ld [ %i0 + %g1 ], %i5
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
4000b4c4: 80 a7 60 00 cmp %i5, 0
4000b4c8: 12 80 00 06 bne 4000b4e0 <_RBTree_Iterate_unprotected+0x34><== ALWAYS TAKEN
4000b4cc: 94 10 00 1b mov %i3, %o2
4000b4d0: 30 80 00 0e b,a 4000b508 <_RBTree_Iterate_unprotected+0x5c><== NOT EXECUTED
4000b4d4: 80 8f 20 ff btst 0xff, %i4
4000b4d8: 02 80 00 0c be 4000b508 <_RBTree_Iterate_unprotected+0x5c><== NEVER TAKEN
4000b4dc: 94 10 00 1b mov %i3, %o2
stop = (*visitor)( current, dir, visitor_arg );
4000b4e0: 90 10 00 1d mov %i5, %o0
4000b4e4: 9f c6 80 00 call %i2
4000b4e8: 92 10 00 19 mov %i1, %o1
current = _RBTree_Next_unprotected( current, dir );
4000b4ec: 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 );
4000b4f0: b8 10 00 08 mov %o0, %i4
current = _RBTree_Next_unprotected( current, dir );
4000b4f4: 40 00 00 07 call 4000b510 <_RBTree_Next_unprotected>
4000b4f8: 90 10 00 1d mov %i5, %o0
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
4000b4fc: ba 92 20 00 orcc %o0, 0, %i5
4000b500: 12 bf ff f5 bne 4000b4d4 <_RBTree_Iterate_unprotected+0x28>
4000b504: b8 1f 20 01 xor %i4, 1, %i4
4000b508: 81 c7 e0 08 ret
4000b50c: 81 e8 00 00 restore
40009618 <_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 )
{
40009618: 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 ];
4000961c: fa 06 21 4c ld [ %i0 + 0x14c ], %i5
if ( !api )
40009620: 80 a7 60 00 cmp %i5, 0
40009624: 02 80 00 1e be 4000969c <_RTEMS_signal_Post_switch_hook+0x84><== NEVER TAKEN
40009628: 01 00 00 00 nop
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
4000962c: 7f ff e7 52 call 40003374 <sparc_disable_interrupts>
40009630: 01 00 00 00 nop
signal_set = asr->signals_posted;
40009634: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
asr->signals_posted = 0;
40009638: c0 27 60 14 clr [ %i5 + 0x14 ]
_ISR_Enable( level );
4000963c: 7f ff e7 52 call 40003384 <sparc_enable_interrupts>
40009640: 01 00 00 00 nop
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
40009644: 80 a7 20 00 cmp %i4, 0
40009648: 32 80 00 04 bne,a 40009658 <_RTEMS_signal_Post_switch_hook+0x40>
4000964c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40009650: 81 c7 e0 08 ret
40009654: 81 e8 00 00 restore
return;
asr->nest_level += 1;
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
40009658: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
4000965c: 82 00 60 01 inc %g1
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
40009660: 94 07 bf fc add %fp, -4, %o2
40009664: 37 00 00 3f sethi %hi(0xfc00), %i3
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
40009668: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
4000966c: 40 00 01 07 call 40009a88 <rtems_task_mode>
40009670: 92 16 e3 ff or %i3, 0x3ff, %o1
(*asr->handler)( signal_set );
40009674: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40009678: 9f c0 40 00 call %g1
4000967c: 90 10 00 1c mov %i4, %o0
asr->nest_level -= 1;
40009680: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
40009684: 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;
40009688: 82 00 7f ff add %g1, -1, %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
4000968c: 92 16 e3 ff or %i3, 0x3ff, %o1
40009690: 94 07 bf fc add %fp, -4, %o2
40009694: 40 00 00 fd call 40009a88 <rtems_task_mode>
40009698: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
4000969c: 81 c7 e0 08 ret
400096a0: 81 e8 00 00 restore
400089cc <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
400089cc: 9d e3 bf 98 save %sp, -104, %sp
rtems_initialization_tasks_table *user_tasks;
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
400089d0: 03 10 00 7d sethi %hi(0x4001f400), %g1
400089d4: 82 10 60 e4 or %g1, 0xe4, %g1 ! 4001f4e4 <Configuration_RTEMS_API>
400089d8: fa 00 60 2c ld [ %g1 + 0x2c ], %i5
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
400089dc: 80 a7 60 00 cmp %i5, 0
400089e0: 02 80 00 18 be 40008a40 <_RTEMS_tasks_Initialize_user_tasks_body+0x74>
400089e4: f6 00 60 28 ld [ %g1 + 0x28 ], %i3
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
400089e8: 80 a6 e0 00 cmp %i3, 0
400089ec: 02 80 00 15 be 40008a40 <_RTEMS_tasks_Initialize_user_tasks_body+0x74><== NEVER TAKEN
400089f0: b8 10 20 00 clr %i4
return_value = rtems_task_create(
400089f4: d4 07 60 04 ld [ %i5 + 4 ], %o2
400089f8: d0 07 40 00 ld [ %i5 ], %o0
400089fc: d2 07 60 08 ld [ %i5 + 8 ], %o1
40008a00: d6 07 60 14 ld [ %i5 + 0x14 ], %o3
40008a04: d8 07 60 0c ld [ %i5 + 0xc ], %o4
40008a08: 7f ff ff 70 call 400087c8 <rtems_task_create>
40008a0c: 9a 07 bf fc add %fp, -4, %o5
user_tasks[ index ].stack_size,
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
40008a10: 94 92 20 00 orcc %o0, 0, %o2
40008a14: 12 80 00 0d bne 40008a48 <_RTEMS_tasks_Initialize_user_tasks_body+0x7c>
40008a18: d0 07 bf fc ld [ %fp + -4 ], %o0
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
return_value = rtems_task_start(
40008a1c: d4 07 60 18 ld [ %i5 + 0x18 ], %o2
40008a20: 40 00 00 0e call 40008a58 <rtems_task_start>
40008a24: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
40008a28: 94 92 20 00 orcc %o0, 0, %o2
40008a2c: 12 80 00 07 bne 40008a48 <_RTEMS_tasks_Initialize_user_tasks_body+0x7c>
40008a30: b8 07 20 01 inc %i4
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
40008a34: 80 a7 00 1b cmp %i4, %i3
40008a38: 12 bf ff ef bne 400089f4 <_RTEMS_tasks_Initialize_user_tasks_body+0x28><== NEVER TAKEN
40008a3c: ba 07 60 1c add %i5, 0x1c, %i5
40008a40: 81 c7 e0 08 ret
40008a44: 81 e8 00 00 restore
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
40008a48: 90 10 20 01 mov 1, %o0
40008a4c: 40 00 04 30 call 40009b0c <_Internal_error_Occurred>
40008a50: 92 10 20 01 mov 1, %o1
4000e2e0 <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
4000e2e0: c2 02 21 58 ld [ %o0 + 0x158 ], %g1
while (tvp) {
4000e2e4: 80 a0 60 00 cmp %g1, 0
4000e2e8: 22 80 00 0c be,a 4000e318 <_RTEMS_tasks_Switch_extension+0x38>
4000e2ec: c2 02 61 58 ld [ %o1 + 0x158 ], %g1
tvp->tval = *tvp->ptr;
4000e2f0: c4 00 60 04 ld [ %g1 + 4 ], %g2
*tvp->ptr = tvp->gval;
4000e2f4: c6 00 60 08 ld [ %g1 + 8 ], %g3
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
4000e2f8: c8 00 80 00 ld [ %g2 ], %g4
4000e2fc: c8 20 60 0c st %g4, [ %g1 + 0xc ]
*tvp->ptr = tvp->gval;
4000e300: c6 20 80 00 st %g3, [ %g2 ]
tvp = (rtems_task_variable_t *)tvp->next;
4000e304: c2 00 40 00 ld [ %g1 ], %g1
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
4000e308: 80 a0 60 00 cmp %g1, 0
4000e30c: 32 bf ff fa bne,a 4000e2f4 <_RTEMS_tasks_Switch_extension+0x14><== NEVER TAKEN
4000e310: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
4000e314: c2 02 61 58 ld [ %o1 + 0x158 ], %g1
while (tvp) {
4000e318: 80 a0 60 00 cmp %g1, 0
4000e31c: 02 80 00 0d be 4000e350 <_RTEMS_tasks_Switch_extension+0x70>
4000e320: 01 00 00 00 nop
tvp->gval = *tvp->ptr;
4000e324: c4 00 60 04 ld [ %g1 + 4 ], %g2
*tvp->ptr = tvp->tval;
4000e328: c6 00 60 0c ld [ %g1 + 0xc ], %g3
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
4000e32c: c8 00 80 00 ld [ %g2 ], %g4
4000e330: c8 20 60 08 st %g4, [ %g1 + 8 ]
*tvp->ptr = tvp->tval;
4000e334: c6 20 80 00 st %g3, [ %g2 ]
tvp = (rtems_task_variable_t *)tvp->next;
4000e338: c2 00 40 00 ld [ %g1 ], %g1
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
4000e33c: 80 a0 60 00 cmp %g1, 0
4000e340: 32 bf ff fa bne,a 4000e328 <_RTEMS_tasks_Switch_extension+0x48><== NEVER TAKEN
4000e344: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED
4000e348: 81 c3 e0 08 retl
4000e34c: 01 00 00 00 nop
4000e350: 81 c3 e0 08 retl
4003888c <_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
)
{
4003888c: 9d e3 bf 98 save %sp, -104, %sp
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
40038890: 13 10 01 a5 sethi %hi(0x40069400), %o1
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
#endif
Thread_Control *owning_thread = the_period->owner;
40038894: f6 06 20 40 ld [ %i0 + 0x40 ], %i3
40038898: 90 07 bf f8 add %fp, -8, %o0
4003889c: 7f ff 41 e1 call 40009020 <_TOD_Get_with_nanoseconds>
400388a0: 92 12 63 e0 or %o1, 0x3e0, %o1
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
400388a4: c4 1f bf f8 ldd [ %fp + -8 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
400388a8: 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) {
400388ac: 03 10 01 a7 sethi %hi(0x40069c00), %g1
400388b0: 82 10 61 a0 or %g1, 0x1a0, %g1 ! 40069da0 <_Per_CPU_Information>
400388b4: de 00 60 10 ld [ %g1 + 0x10 ], %o7
400388b8: ba a0 c0 1d subcc %g3, %i5, %i5
400388bc: b8 60 80 1c subx %g2, %i4, %i4
400388c0: f8 3e 40 00 std %i4, [ %i1 ]
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
400388c4: 88 10 20 01 mov 1, %g4
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
400388c8: 80 a3 c0 1b cmp %o7, %i3
400388cc: 02 80 00 05 be 400388e0 <_Rate_monotonic_Get_status+0x54>
400388d0: f8 1e e0 80 ldd [ %i3 + 0x80 ], %i4
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
}
400388d4: b0 09 20 01 and %g4, 1, %i0
400388d8: 81 c7 e0 08 ret
400388dc: 81 e8 00 00 restore
400388e0: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400388e4: f0 1e 20 48 ldd [ %i0 + 0x48 ], %i0
400388e8: 86 a0 c0 0d subcc %g3, %o5, %g3
400388ec: 84 60 80 0c subx %g2, %o4, %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
400388f0: 9a 87 40 03 addcc %i5, %g3, %o5
400388f4: 98 47 00 02 addx %i4, %g2, %o4
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
400388f8: 80 a6 00 0c cmp %i0, %o4
400388fc: 14 bf ff f6 bg 400388d4 <_Rate_monotonic_Get_status+0x48> <== NEVER TAKEN
40038900: 88 10 20 00 clr %g4
40038904: 02 80 00 09 be 40038928 <_Rate_monotonic_Get_status+0x9c>
40038908: 80 a6 40 0d cmp %i1, %o5
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
4003890c: 9a a3 40 19 subcc %o5, %i1, %o5
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
40038910: 88 10 20 01 mov 1, %g4
40038914: 98 63 00 18 subx %o4, %i0, %o4
}
40038918: b0 09 20 01 and %g4, 1, %i0
4003891c: d8 3e 80 00 std %o4, [ %i2 ]
40038920: 81 c7 e0 08 ret
40038924: 81 e8 00 00 restore
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
40038928: 28 bf ff fa bleu,a 40038910 <_Rate_monotonic_Get_status+0x84>
4003892c: 9a a3 40 19 subcc %o5, %i1, %o5
return false;
40038930: 10 bf ff e9 b 400388d4 <_Rate_monotonic_Get_status+0x48>
40038934: 88 10 20 00 clr %g4
40038cdc <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
40038cdc: 9d e3 bf 98 save %sp, -104, %sp
40038ce0: 11 10 01 a8 sethi %hi(0x4006a000), %o0
40038ce4: 92 10 00 18 mov %i0, %o1
40038ce8: 90 12 23 68 or %o0, 0x368, %o0
40038cec: 7f ff 43 a1 call 40009b70 <_Objects_Get>
40038cf0: 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 ) {
40038cf4: c2 07 bf fc ld [ %fp + -4 ], %g1
40038cf8: 80 a0 60 00 cmp %g1, 0
40038cfc: 12 80 00 16 bne 40038d54 <_Rate_monotonic_Timeout+0x78> <== NEVER TAKEN
40038d00: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
the_thread = the_period->owner;
40038d04: d0 02 20 40 ld [ %o0 + 0x40 ], %o0
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
40038d08: 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);
40038d0c: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
40038d10: 80 88 80 01 btst %g2, %g1
40038d14: 22 80 00 08 be,a 40038d34 <_Rate_monotonic_Timeout+0x58>
40038d18: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
40038d1c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
40038d20: c2 07 60 08 ld [ %i5 + 8 ], %g1
40038d24: 80 a0 80 01 cmp %g2, %g1
40038d28: 02 80 00 19 be 40038d8c <_Rate_monotonic_Timeout+0xb0>
40038d2c: 13 04 01 ff sethi %hi(0x1007fc00), %o1
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
40038d30: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
40038d34: 80 a0 60 01 cmp %g1, 1
40038d38: 02 80 00 09 be 40038d5c <_Rate_monotonic_Timeout+0x80>
40038d3c: 82 10 20 04 mov 4, %g1
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
40038d40: 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;
40038d44: 03 10 01 a6 sethi %hi(0x40069800), %g1
40038d48: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 40069890 <_Thread_Dispatch_disable_level>
--level;
40038d4c: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
40038d50: c4 20 60 90 st %g2, [ %g1 + 0x90 ]
40038d54: 81 c7 e0 08 ret
40038d58: 81 e8 00 00 restore
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
40038d5c: 82 10 20 03 mov 3, %g1
_Rate_monotonic_Initiate_statistics( the_period );
40038d60: 90 10 00 1d mov %i5, %o0
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
40038d64: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
_Rate_monotonic_Initiate_statistics( the_period );
40038d68: 7f ff ff 43 call 40038a74 <_Rate_monotonic_Initiate_statistics>
40038d6c: 01 00 00 00 nop
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40038d70: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40038d74: 11 10 01 a6 sethi %hi(0x40069800), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40038d78: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40038d7c: 90 12 21 28 or %o0, 0x128, %o0
40038d80: 7f ff 4a 6f call 4000b73c <_Watchdog_Insert>
40038d84: 92 07 60 10 add %i5, 0x10, %o1
40038d88: 30 bf ff ef b,a 40038d44 <_Rate_monotonic_Timeout+0x68>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
40038d8c: 7f ff 46 43 call 4000a698 <_Thread_Clear_state>
40038d90: 92 12 63 f8 or %o1, 0x3f8, %o1
the_thread = the_period->owner;
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
40038d94: 10 bf ff f5 b 40038d68 <_Rate_monotonic_Timeout+0x8c>
40038d98: 90 10 00 1d mov %i5, %o0
40038938 <_Rate_monotonic_Update_statistics>:
}
static void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
40038938: 9d e3 bf 90 save %sp, -112, %sp
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
4003893c: c4 06 20 58 ld [ %i0 + 0x58 ], %g2
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
40038940: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
40038944: 84 00 a0 01 inc %g2
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
40038948: 80 a0 60 04 cmp %g1, 4
4003894c: 02 80 00 32 be 40038a14 <_Rate_monotonic_Update_statistics+0xdc>
40038950: c4 26 20 58 st %g2, [ %i0 + 0x58 ]
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
40038954: 90 10 00 18 mov %i0, %o0
40038958: 92 07 bf f8 add %fp, -8, %o1
4003895c: 7f ff ff cc call 4003888c <_Rate_monotonic_Get_status>
40038960: 94 07 bf f0 add %fp, -16, %o2
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
40038964: 80 8a 20 ff btst 0xff, %o0
40038968: 02 80 00 21 be 400389ec <_Rate_monotonic_Update_statistics+0xb4>
4003896c: c4 1f bf f0 ldd [ %fp + -16 ], %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
40038970: 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 ) )
40038974: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
40038978: b6 87 40 03 addcc %i5, %g3, %i3
4003897c: b4 47 00 02 addx %i4, %g2, %i2
40038980: 80 a0 40 02 cmp %g1, %g2
40038984: 04 80 00 1c ble 400389f4 <_Rate_monotonic_Update_statistics+0xbc>
40038988: f4 3e 20 70 std %i2, [ %i0 + 0x70 ]
stats->min_cpu_time = executed;
4003898c: c4 3e 20 60 std %g2, [ %i0 + 0x60 ]
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
40038990: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
40038994: 80 a0 40 02 cmp %g1, %g2
40038998: 26 80 00 05 bl,a 400389ac <_Rate_monotonic_Update_statistics+0x74><== NEVER TAKEN
4003899c: c4 3e 20 68 std %g2, [ %i0 + 0x68 ] <== NOT EXECUTED
400389a0: 80 a0 40 02 cmp %g1, %g2
400389a4: 22 80 00 28 be,a 40038a44 <_Rate_monotonic_Update_statistics+0x10c><== ALWAYS TAKEN
400389a8: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
/*
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
400389ac: c4 1f bf f8 ldd [ %fp + -8 ], %g2
400389b0: f8 1e 20 88 ldd [ %i0 + 0x88 ], %i4
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
400389b4: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
400389b8: b6 87 40 03 addcc %i5, %g3, %i3
400389bc: b4 47 00 02 addx %i4, %g2, %i2
400389c0: 80 a0 40 02 cmp %g1, %g2
400389c4: 14 80 00 1b bg 40038a30 <_Rate_monotonic_Update_statistics+0xf8>
400389c8: f4 3e 20 88 std %i2, [ %i0 + 0x88 ]
400389cc: 80 a0 40 02 cmp %g1, %g2
400389d0: 22 80 00 15 be,a 40038a24 <_Rate_monotonic_Update_statistics+0xec><== ALWAYS TAKEN
400389d4: c2 06 20 7c ld [ %i0 + 0x7c ], %g1
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
400389d8: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
400389dc: 80 a0 40 02 cmp %g1, %g2
400389e0: 16 80 00 1e bge 40038a58 <_Rate_monotonic_Update_statistics+0x120><== ALWAYS TAKEN
400389e4: 01 00 00 00 nop
stats->max_wall_time = since_last_period;
400389e8: c4 3e 20 80 std %g2, [ %i0 + 0x80 ] <== NOT EXECUTED
400389ec: 81 c7 e0 08 ret
400389f0: 81 e8 00 00 restore
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
400389f4: 32 bf ff e8 bne,a 40038994 <_Rate_monotonic_Update_statistics+0x5c><== NEVER TAKEN
400389f8: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED
400389fc: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
40038a00: 80 a0 40 03 cmp %g1, %g3
40038a04: 28 bf ff e4 bleu,a 40038994 <_Rate_monotonic_Update_statistics+0x5c>
40038a08: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
stats->min_cpu_time = executed;
40038a0c: 10 bf ff e1 b 40038990 <_Rate_monotonic_Update_statistics+0x58>
40038a10: c4 3e 20 60 std %g2, [ %i0 + 0x60 ]
*/
stats = &the_period->Statistics;
stats->count++;
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
stats->missed_count++;
40038a14: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
40038a18: 82 00 60 01 inc %g1
40038a1c: 10 bf ff ce b 40038954 <_Rate_monotonic_Update_statistics+0x1c>
40038a20: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
40038a24: 80 a0 40 03 cmp %g1, %g3
40038a28: 28 bf ff ed bleu,a 400389dc <_Rate_monotonic_Update_statistics+0xa4>
40038a2c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
40038a30: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
40038a34: 80 a0 40 02 cmp %g1, %g2
40038a38: 06 bf ff ec bl 400389e8 <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN
40038a3c: c4 3e 20 78 std %g2, [ %i0 + 0x78 ]
40038a40: 30 80 00 06 b,a 40038a58 <_Rate_monotonic_Update_statistics+0x120>
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
stats->min_cpu_time = executed;
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
40038a44: 80 a0 40 03 cmp %g1, %g3
40038a48: 3a bf ff da bcc,a 400389b0 <_Rate_monotonic_Update_statistics+0x78>
40038a4c: c4 1f bf f8 ldd [ %fp + -8 ], %g2
stats->max_cpu_time = executed;
40038a50: 10 bf ff d7 b 400389ac <_Rate_monotonic_Update_statistics+0x74>
40038a54: c4 3e 20 68 std %g2, [ %i0 + 0x68 ]
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
40038a58: 12 bf ff e5 bne 400389ec <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN
40038a5c: 01 00 00 00 nop
40038a60: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
40038a64: 80 a0 40 03 cmp %g1, %g3
40038a68: 2a bf ff e1 bcs,a 400389ec <_Rate_monotonic_Update_statistics+0xb4>
40038a6c: c4 3e 20 80 std %g2, [ %i0 + 0x80 ]
40038a70: 30 bf ff df b,a 400389ec <_Rate_monotonic_Update_statistics+0xb4>
4000afbc <_Scheduler_CBS_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_CBS_Allocate(
Thread_Control *the_thread
)
{
4000afbc: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_CBS_Per_thread *schinfo;
sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));
4000afc0: 40 00 07 11 call 4000cc04 <_Workspace_Allocate>
4000afc4: 90 10 20 1c mov 0x1c, %o0
if ( sched ) {
4000afc8: 80 a2 20 00 cmp %o0, 0
4000afcc: 02 80 00 06 be 4000afe4 <_Scheduler_CBS_Allocate+0x28> <== NEVER TAKEN
4000afd0: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
4000afd4: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
schinfo->edf_per_thread.thread = the_thread;
4000afd8: f0 22 00 00 st %i0, [ %o0 ]
schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
4000afdc: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
schinfo->cbs_server = NULL;
4000afe0: c0 22 20 18 clr [ %o0 + 0x18 ]
}
return sched;
}
4000afe4: 81 c7 e0 08 ret
4000afe8: 91 e8 00 08 restore %g0, %o0, %o0
4000c390 <_Scheduler_CBS_Budget_callout>:
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
4000c390: 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;
4000c394: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
4000c398: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000c39c: 80 a0 40 09 cmp %g1, %o1
4000c3a0: 32 80 00 02 bne,a 4000c3a8 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN
4000c3a4: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
4000c3a8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000c3ac: 80 a0 40 09 cmp %g1, %o1
4000c3b0: 02 80 00 04 be 4000c3c0 <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN
4000c3b4: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
4000c3b8: 40 00 01 92 call 4000ca00 <_Thread_Change_priority>
4000c3bc: 94 10 20 01 mov 1, %o2
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
4000c3c0: fa 06 20 88 ld [ %i0 + 0x88 ], %i5
if ( sched_info->cbs_server->cbs_budget_overrun ) {
4000c3c4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000c3c8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000c3cc: 80 a0 a0 00 cmp %g2, 0
4000c3d0: 02 80 00 09 be 4000c3f4 <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN
4000c3d4: 01 00 00 00 nop
_Scheduler_CBS_Get_server_id(
4000c3d8: d0 00 40 00 ld [ %g1 ], %o0
4000c3dc: 7f ff ff d5 call 4000c330 <_Scheduler_CBS_Get_server_id>
4000c3e0: 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 );
4000c3e4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000c3e8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000c3ec: 9f c0 40 00 call %g1
4000c3f0: d0 07 bf fc ld [ %fp + -4 ], %o0
4000c3f4: 81 c7 e0 08 ret
4000c3f8: 81 e8 00 00 restore
4000bee8 <_Scheduler_CBS_Cleanup>:
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Cleanup (void)
{
4000bee8: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000beec: 39 10 00 8b sethi %hi(0x40022c00), %i4
4000bef0: c2 07 21 20 ld [ %i4 + 0x120 ], %g1 ! 40022d20 <_Scheduler_CBS_Maximum_servers>
4000bef4: 80 a0 60 00 cmp %g1, 0
4000bef8: 02 80 00 18 be 4000bf58 <_Scheduler_CBS_Cleanup+0x70> <== NEVER TAKEN
4000befc: 03 10 00 90 sethi %hi(0x40024000), %g1
4000bf00: 37 10 00 90 sethi %hi(0x40024000), %i3
4000bf04: c4 06 e0 28 ld [ %i3 + 0x28 ], %g2 ! 40024028 <_Scheduler_CBS_Server_list>
4000bf08: ba 10 20 00 clr %i5
4000bf0c: b8 17 21 20 or %i4, 0x120, %i4
if ( _Scheduler_CBS_Server_list[ i ] )
4000bf10: 83 2f 60 02 sll %i5, 2, %g1
4000bf14: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000bf18: 80 a0 60 00 cmp %g1, 0
4000bf1c: 02 80 00 05 be 4000bf30 <_Scheduler_CBS_Cleanup+0x48>
4000bf20: 90 10 00 1d mov %i5, %o0
_Scheduler_CBS_Destroy_server( i );
4000bf24: 40 00 00 46 call 4000c03c <_Scheduler_CBS_Destroy_server>
4000bf28: 01 00 00 00 nop
4000bf2c: c4 06 e0 28 ld [ %i3 + 0x28 ], %g2
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000bf30: c2 07 00 00 ld [ %i4 ], %g1
4000bf34: ba 07 60 01 inc %i5
4000bf38: 80 a0 40 1d cmp %g1, %i5
4000bf3c: 18 bf ff f6 bgu 4000bf14 <_Scheduler_CBS_Cleanup+0x2c>
4000bf40: 83 2f 60 02 sll %i5, 2, %g1
if ( _Scheduler_CBS_Server_list[ i ] )
_Scheduler_CBS_Destroy_server( i );
}
_Workspace_Free( _Scheduler_CBS_Server_list );
return SCHEDULER_CBS_OK;
}
4000bf44: b0 10 20 00 clr %i0
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( _Scheduler_CBS_Server_list[ i ] )
_Scheduler_CBS_Destroy_server( i );
}
_Workspace_Free( _Scheduler_CBS_Server_list );
4000bf48: 40 00 08 41 call 4000e04c <_Workspace_Free>
4000bf4c: 90 10 00 02 mov %g2, %o0
return SCHEDULER_CBS_OK;
}
4000bf50: 81 c7 e0 08 ret
4000bf54: 81 e8 00 00 restore
4000bf58: 10 bf ff fb b 4000bf44 <_Scheduler_CBS_Cleanup+0x5c> <== NOT EXECUTED
4000bf5c: c4 00 60 28 ld [ %g1 + 0x28 ], %g2 <== NOT EXECUTED
4000bf60 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
4000bf60: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
4000bf64: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000bf68: 80 a0 60 00 cmp %g1, 0
4000bf6c: 04 80 00 30 ble 4000c02c <_Scheduler_CBS_Create_server+0xcc>
4000bf70: b8 10 00 18 mov %i0, %i4
4000bf74: c2 06 00 00 ld [ %i0 ], %g1
4000bf78: 80 a0 60 00 cmp %g1, 0
4000bf7c: 04 80 00 2c ble 4000c02c <_Scheduler_CBS_Create_server+0xcc>
4000bf80: 03 10 00 8b sethi %hi(0x40022c00), %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++ ) {
4000bf84: c8 00 61 20 ld [ %g1 + 0x120 ], %g4 ! 40022d20 <_Scheduler_CBS_Maximum_servers>
4000bf88: 80 a1 20 00 cmp %g4, 0
4000bf8c: 02 80 00 11 be 4000bfd0 <_Scheduler_CBS_Create_server+0x70><== NEVER TAKEN
4000bf90: 37 10 00 90 sethi %hi(0x40024000), %i3
if ( !_Scheduler_CBS_Server_list[i] )
4000bf94: fa 06 e0 28 ld [ %i3 + 0x28 ], %i5 ! 40024028 <_Scheduler_CBS_Server_list>
4000bf98: c2 07 40 00 ld [ %i5 ], %g1
4000bf9c: 80 a0 60 00 cmp %g1, 0
4000bfa0: 02 80 00 21 be 4000c024 <_Scheduler_CBS_Create_server+0xc4>
4000bfa4: b0 10 20 00 clr %i0
4000bfa8: 10 80 00 06 b 4000bfc0 <_Scheduler_CBS_Create_server+0x60>
4000bfac: 82 10 20 00 clr %g1
4000bfb0: c6 07 40 02 ld [ %i5 + %g2 ], %g3
4000bfb4: 80 a0 e0 00 cmp %g3, 0
4000bfb8: 02 80 00 08 be 4000bfd8 <_Scheduler_CBS_Create_server+0x78>
4000bfbc: b0 10 00 02 mov %g2, %i0
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000bfc0: 82 00 60 01 inc %g1
4000bfc4: 80 a0 40 04 cmp %g1, %g4
4000bfc8: 12 bf ff fa bne 4000bfb0 <_Scheduler_CBS_Create_server+0x50>
4000bfcc: 85 28 60 02 sll %g1, 2, %g2
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
4000bfd0: 81 c7 e0 08 ret
4000bfd4: 91 e8 3f e6 restore %g0, -26, %o0
*server_id = i;
4000bfd8: c2 26 80 00 st %g1, [ %i2 ]
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
4000bfdc: 40 00 08 14 call 4000e02c <_Workspace_Allocate>
4000bfe0: 90 10 20 10 mov 0x10, %o0
the_server = _Scheduler_CBS_Server_list[*server_id];
4000bfe4: 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 *)
4000bfe8: d0 27 40 18 st %o0, [ %i5 + %i0 ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
4000bfec: c4 06 e0 28 ld [ %i3 + 0x28 ], %g2
4000bff0: 83 28 60 02 sll %g1, 2, %g1
4000bff4: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( !the_server )
4000bff8: 80 a0 60 00 cmp %g1, 0
4000bffc: 02 80 00 0e be 4000c034 <_Scheduler_CBS_Create_server+0xd4><== NEVER TAKEN
4000c000: 86 10 3f ff mov -1, %g3
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
4000c004: c4 07 00 00 ld [ %i4 ], %g2
4000c008: c4 20 60 04 st %g2, [ %g1 + 4 ]
4000c00c: c4 07 20 04 ld [ %i4 + 4 ], %g2
the_server->task_id = -1;
4000c010: c6 20 40 00 st %g3, [ %g1 ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
4000c014: c4 20 60 08 st %g2, [ %g1 + 8 ]
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
4000c018: f2 20 60 0c st %i1, [ %g1 + 0xc ]
return SCHEDULER_CBS_OK;
4000c01c: 81 c7 e0 08 ret
4000c020: 91 e8 20 00 restore %g0, 0, %o0
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( !_Scheduler_CBS_Server_list[i] )
4000c024: 10 bf ff ed b 4000bfd8 <_Scheduler_CBS_Create_server+0x78>
4000c028: 82 10 20 00 clr %g1
if ( params->budget <= 0 ||
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
4000c02c: 81 c7 e0 08 ret
4000c030: 91 e8 3f ee restore %g0, -18, %o0
the_server->parameters = *params;
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
}
4000c034: 81 c7 e0 08 ret <== NOT EXECUTED
4000c038: 91 e8 3f ef restore %g0, -17, %o0 <== NOT EXECUTED
4000c0bc <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
4000c0bc: 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);
4000c0c0: 92 07 bf fc add %fp, -4, %o1
4000c0c4: 40 00 03 95 call 4000cf18 <_Thread_Get>
4000c0c8: 90 10 00 19 mov %i1, %o0
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
4000c0cc: ba 92 20 00 orcc %o0, 0, %i5
4000c0d0: 02 80 00 1e be 4000c148 <_Scheduler_CBS_Detach_thread+0x8c>
4000c0d4: 01 00 00 00 nop
_Thread_Enable_dispatch();
4000c0d8: 40 00 03 84 call 4000cee8 <_Thread_Enable_dispatch>
4000c0dc: 01 00 00 00 nop
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
4000c0e0: 03 10 00 8b sethi %hi(0x40022c00), %g1
4000c0e4: c2 00 61 20 ld [ %g1 + 0x120 ], %g1 ! 40022d20 <_Scheduler_CBS_Maximum_servers>
4000c0e8: 80 a6 00 01 cmp %i0, %g1
4000c0ec: 1a 80 00 17 bcc 4000c148 <_Scheduler_CBS_Detach_thread+0x8c>
4000c0f0: 03 10 00 90 sethi %hi(0x40024000), %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
4000c0f4: c2 00 60 28 ld [ %g1 + 0x28 ], %g1 ! 40024028 <_Scheduler_CBS_Server_list>
4000c0f8: b1 2e 20 02 sll %i0, 2, %i0
4000c0fc: c2 00 40 18 ld [ %g1 + %i0 ], %g1
4000c100: 80 a0 60 00 cmp %g1, 0
4000c104: 02 80 00 13 be 4000c150 <_Scheduler_CBS_Detach_thread+0x94>
4000c108: 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 )
4000c10c: c4 00 40 00 ld [ %g1 ], %g2
4000c110: 80 a0 80 19 cmp %g2, %i1
4000c114: 12 80 00 0d bne 4000c148 <_Scheduler_CBS_Detach_thread+0x8c><== NEVER TAKEN
4000c118: 84 10 3f ff mov -1, %g2
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
4000c11c: c8 07 60 88 ld [ %i5 + 0x88 ], %g4
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4000c120: c6 07 60 a0 ld [ %i5 + 0xa0 ], %g3
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Thread and server are not attached. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
4000c124: c4 20 40 00 st %g2, [ %g1 ]
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
4000c128: c4 07 60 a4 ld [ %i5 + 0xa4 ], %g2
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4000c12c: c2 0f 60 9c ldub [ %i5 + 0x9c ], %g1
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
4000c130: c0 21 20 18 clr [ %g4 + 0x18 ]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4000c134: c6 27 60 78 st %g3, [ %i5 + 0x78 ]
the_thread->budget_callout = the_thread->Start.budget_callout;
4000c138: c4 27 60 7c st %g2, [ %i5 + 0x7c ]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4000c13c: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ]
return SCHEDULER_CBS_OK;
4000c140: 81 c7 e0 08 ret
4000c144: 91 e8 20 00 restore %g0, 0, %o0
if ( the_thread ) {
_Thread_Enable_dispatch();
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
4000c148: 81 c7 e0 08 ret
4000c14c: 91 e8 3f ee restore %g0, -18, %o0
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
return SCHEDULER_CBS_OK;
}
4000c150: 81 c7 e0 08 ret
4000c154: 91 e8 3f e7 restore %g0, -25, %o0
4000c330 <_Scheduler_CBS_Get_server_id>:
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000c330: 03 10 00 8b sethi %hi(0x40022c00), %g1
4000c334: c6 00 61 20 ld [ %g1 + 0x120 ], %g3 ! 40022d20 <_Scheduler_CBS_Maximum_servers>
4000c338: 80 a0 e0 00 cmp %g3, 0
4000c33c: 02 80 00 11 be 4000c380 <_Scheduler_CBS_Get_server_id+0x50><== NEVER TAKEN
4000c340: 03 10 00 90 sethi %hi(0x40024000), %g1
4000c344: c8 00 60 28 ld [ %g1 + 0x28 ], %g4 ! 40024028 <_Scheduler_CBS_Server_list>
4000c348: 82 10 20 00 clr %g1
#include <rtems/system.h>
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Get_server_id (
4000c34c: 85 28 60 02 sll %g1, 2, %g2
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( _Scheduler_CBS_Server_list[i] &&
4000c350: c4 01 00 02 ld [ %g4 + %g2 ], %g2
4000c354: 80 a0 a0 00 cmp %g2, 0
4000c358: 22 80 00 07 be,a 4000c374 <_Scheduler_CBS_Get_server_id+0x44>
4000c35c: 82 00 60 01 inc %g1
4000c360: c4 00 80 00 ld [ %g2 ], %g2
4000c364: 80 a0 80 08 cmp %g2, %o0
4000c368: 22 80 00 08 be,a 4000c388 <_Scheduler_CBS_Get_server_id+0x58>
4000c36c: c2 22 40 00 st %g1, [ %o1 ]
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
4000c370: 82 00 60 01 inc %g1
4000c374: 80 a0 40 03 cmp %g1, %g3
4000c378: 12 bf ff f6 bne 4000c350 <_Scheduler_CBS_Get_server_id+0x20>
4000c37c: 85 28 60 02 sll %g1, 2, %g2
*server_id = i;
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
}
4000c380: 81 c3 e0 08 retl
4000c384: 90 10 3f e7 mov -25, %o0
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( _Scheduler_CBS_Server_list[i] &&
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
return SCHEDULER_CBS_OK;
4000c388: 81 c3 e0 08 retl
4000c38c: 90 10 20 00 clr %o0
4000c3fc <_Scheduler_CBS_Initialize>:
}
}
int _Scheduler_CBS_Initialize(void)
{
4000c3fc: 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*) );
4000c400: 3b 10 00 8b sethi %hi(0x40022c00), %i5
4000c404: d0 07 61 20 ld [ %i5 + 0x120 ], %o0 ! 40022d20 <_Scheduler_CBS_Maximum_servers>
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
4000c408: 40 00 07 09 call 4000e02c <_Workspace_Allocate>
4000c40c: 91 2a 20 02 sll %o0, 2, %o0
4000c410: 09 10 00 90 sethi %hi(0x40024000), %g4
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
4000c414: 80 a2 20 00 cmp %o0, 0
4000c418: 02 80 00 10 be 4000c458 <_Scheduler_CBS_Initialize+0x5c> <== NEVER TAKEN
4000c41c: d0 21 20 28 st %o0, [ %g4 + 0x28 ]
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
4000c420: c6 07 61 20 ld [ %i5 + 0x120 ], %g3
4000c424: 80 a0 e0 00 cmp %g3, 0
4000c428: 12 80 00 05 bne 4000c43c <_Scheduler_CBS_Initialize+0x40> <== ALWAYS TAKEN
4000c42c: 82 10 20 00 clr %g1
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
4000c430: 81 c7 e0 08 ret <== NOT EXECUTED
4000c434: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
4000c438: d0 01 20 28 ld [ %g4 + 0x28 ], %o0
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
_Scheduler_CBS_Server_list[i] = NULL;
4000c43c: 85 28 60 02 sll %g1, 2, %g2
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
4000c440: 82 00 60 01 inc %g1
4000c444: 80 a0 40 03 cmp %g1, %g3
4000c448: 12 bf ff fc bne 4000c438 <_Scheduler_CBS_Initialize+0x3c>
4000c44c: c0 22 00 02 clr [ %o0 + %g2 ]
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
4000c450: 81 c7 e0 08 ret
4000c454: 91 e8 20 00 restore %g0, 0, %o0
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
4000c458: b0 10 3f ef mov -17, %i0 <== NOT EXECUTED
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
}
4000c45c: 81 c7 e0 08 ret <== NOT EXECUTED
4000c460: 81 e8 00 00 restore <== NOT EXECUTED
4000afec <_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;
4000afec: c2 02 20 88 ld [ %o0 + 0x88 ], %g1
if (deadline) {
4000aff0: 80 a2 60 00 cmp %o1, 0
4000aff4: 02 80 00 11 be 4000b038 <_Scheduler_CBS_Release_job+0x4c>
4000aff8: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
/* Initializing or shifting deadline. */
if (serv_info)
4000affc: 80 a0 60 00 cmp %g1, 0
4000b000: 02 80 00 13 be 4000b04c <_Scheduler_CBS_Release_job+0x60>
4000b004: 07 10 00 87 sethi %hi(0x40021c00), %g3
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
4000b008: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000b00c: d2 00 e3 f8 ld [ %g3 + 0x3f8 ], %o1
4000b010: 92 02 40 02 add %o1, %g2, %o1
4000b014: 05 20 00 00 sethi %hi(0x80000000), %g2
4000b018: 92 2a 40 02 andn %o1, %g2, %o1
new_priority = the_thread->Start.initial_priority;
}
/* Budget replenishment for the next job. */
if (serv_info)
the_thread->cpu_time_budget = serv_info->parameters.budget;
4000b01c: c2 00 60 08 ld [ %g1 + 8 ], %g1
4000b020: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
the_thread->real_priority = new_priority;
4000b024: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
_Thread_Change_priority(the_thread, new_priority, true);
4000b028: 94 10 20 01 mov 1, %o2
4000b02c: 82 13 c0 00 mov %o7, %g1
4000b030: 40 00 01 3a call 4000b518 <_Thread_Change_priority>
4000b034: 9e 10 40 00 mov %g1, %o7
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
}
/* Budget replenishment for the next job. */
if (serv_info)
4000b038: 80 a0 60 00 cmp %g1, 0
4000b03c: 12 bf ff f8 bne 4000b01c <_Scheduler_CBS_Release_job+0x30><== ALWAYS TAKEN
4000b040: d2 02 20 ac ld [ %o0 + 0xac ], %o1
the_thread->cpu_time_budget = serv_info->parameters.budget;
the_thread->real_priority = new_priority;
4000b044: 10 bf ff f9 b 4000b028 <_Scheduler_CBS_Release_job+0x3c> <== NOT EXECUTED
4000b048: d2 22 20 18 st %o1, [ %o0 + 0x18 ] <== NOT EXECUTED
/* Initializing or shifting deadline. */
if (serv_info)
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
& ~SCHEDULER_EDF_PRIO_MSB;
else
new_priority = (_Watchdog_Ticks_since_boot + deadline)
4000b04c: 03 10 00 87 sethi %hi(0x40021c00), %g1
4000b050: c2 00 63 f8 ld [ %g1 + 0x3f8 ], %g1 ! 40021ff8 <_Watchdog_Ticks_since_boot>
4000b054: 92 02 40 01 add %o1, %g1, %o1
4000b058: 03 20 00 00 sethi %hi(0x80000000), %g1
4000b05c: 10 bf ff f2 b 4000b024 <_Scheduler_CBS_Release_job+0x38>
4000b060: 92 2a 40 01 andn %o1, %g1, %o1
4000b064 <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
4000b064: 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);
4000b068: 40 00 00 50 call 4000b1a8 <_Scheduler_EDF_Enqueue>
4000b06c: 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;
4000b070: c2 06 20 88 ld [ %i0 + 0x88 ], %g1
4000b074: 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) {
4000b078: 80 a7 60 00 cmp %i5, 0
4000b07c: 02 80 00 19 be 4000b0e0 <_Scheduler_CBS_Unblock+0x7c>
4000b080: 03 10 00 87 sethi %hi(0x40021c00), %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 ) {
4000b084: 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 -
4000b088: d0 00 63 f8 ld [ %g1 + 0x3f8 ], %o0
4000b08c: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
4000b090: 40 00 40 c1 call 4001b394 <.umul>
4000b094: 90 27 00 08 sub %i4, %o0, %o0
4000b098: d2 06 20 74 ld [ %i0 + 0x74 ], %o1
4000b09c: b6 10 00 08 mov %o0, %i3
4000b0a0: 40 00 40 bd call 4001b394 <.umul>
4000b0a4: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000b0a8: 80 a6 c0 08 cmp %i3, %o0
4000b0ac: 24 80 00 0e ble,a 4000b0e4 <_Scheduler_CBS_Unblock+0x80>
4000b0b0: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
/* Put late unblocked task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
4000b0b4: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
4000b0b8: 80 a7 00 09 cmp %i4, %o1
4000b0bc: 32 80 00 02 bne,a 4000b0c4 <_Scheduler_CBS_Unblock+0x60>
4000b0c0: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
4000b0c4: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
4000b0c8: 80 a2 00 09 cmp %o0, %o1
4000b0cc: 02 80 00 07 be 4000b0e8 <_Scheduler_CBS_Unblock+0x84>
4000b0d0: 3b 10 00 89 sethi %hi(0x40022400), %i5
_Thread_Change_priority(the_thread, new_priority, true);
4000b0d4: 90 10 00 18 mov %i0, %o0
4000b0d8: 40 00 01 10 call 4000b518 <_Thread_Change_priority>
4000b0dc: 94 10 20 01 mov 1, %o2
4000b0e0: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
4000b0e4: 3b 10 00 89 sethi %hi(0x40022400), %i5
4000b0e8: ba 17 60 20 or %i5, 0x20, %i5 ! 40022420 <_Per_CPU_Information>
4000b0ec: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000b0f0: d2 00 60 14 ld [ %g1 + 0x14 ], %o1
4000b0f4: 03 10 00 84 sethi %hi(0x40021000), %g1
4000b0f8: c2 00 61 74 ld [ %g1 + 0x174 ], %g1 ! 40021174 <_Scheduler+0x30>
4000b0fc: 9f c0 40 00 call %g1
4000b100: 01 00 00 00 nop
4000b104: 80 a2 20 00 cmp %o0, 0
4000b108: 04 80 00 0a ble 4000b130 <_Scheduler_CBS_Unblock+0xcc>
4000b10c: 01 00 00 00 nop
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
4000b110: 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;
4000b114: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
if ( _Thread_Executing->is_preemptible ||
4000b118: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
4000b11c: 80 a0 60 00 cmp %g1, 0
4000b120: 22 80 00 06 be,a 4000b138 <_Scheduler_CBS_Unblock+0xd4>
4000b124: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
4000b128: 82 10 20 01 mov 1, %g1
4000b12c: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
4000b130: 81 c7 e0 08 ret
4000b134: 81 e8 00 00 restore
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
4000b138: 80 a0 60 00 cmp %g1, 0
4000b13c: 12 bf ff fd bne 4000b130 <_Scheduler_CBS_Unblock+0xcc> <== ALWAYS TAKEN
4000b140: 82 10 20 01 mov 1, %g1
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
4000b144: c2 2f 60 0c stb %g1, [ %i5 + 0xc ] <== NOT EXECUTED
4000b148: 30 bf ff fa b,a 4000b130 <_Scheduler_CBS_Unblock+0xcc> <== NOT EXECUTED
4000afbc <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
4000afbc: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
4000afc0: 40 00 06 e8 call 4000cb60 <_Workspace_Allocate>
4000afc4: 90 10 20 18 mov 0x18, %o0
if ( sched ) {
4000afc8: 80 a2 20 00 cmp %o0, 0
4000afcc: 02 80 00 05 be 4000afe0 <_Scheduler_EDF_Allocate+0x24> <== NEVER TAKEN
4000afd0: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
4000afd4: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
4000afd8: f0 22 00 00 st %i0, [ %o0 ]
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
4000afdc: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
}
return sched;
}
4000afe0: 81 c7 e0 08 ret
4000afe4: 91 e8 00 08 restore %g0, %o0, %o0
4000b1a0 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
4000b1a0: 9d e3 bf a0 save %sp, -96, %sp
_Scheduler_EDF_Enqueue(the_thread);
4000b1a4: 7f ff ff a8 call 4000b044 <_Scheduler_EDF_Enqueue>
4000b1a8: 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(
4000b1ac: 3b 10 00 88 sethi %hi(0x40022000), %i5
4000b1b0: ba 17 63 80 or %i5, 0x380, %i5 ! 40022380 <_Per_CPU_Information>
4000b1b4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000b1b8: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
4000b1bc: 03 10 00 84 sethi %hi(0x40021000), %g1
4000b1c0: c2 00 60 d4 ld [ %g1 + 0xd4 ], %g1 ! 400210d4 <_Scheduler+0x30>
4000b1c4: 9f c0 40 00 call %g1
4000b1c8: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
4000b1cc: 80 a2 20 00 cmp %o0, 0
4000b1d0: 26 80 00 04 bl,a 4000b1e0 <_Scheduler_EDF_Unblock+0x40>
4000b1d4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000b1d8: 81 c7 e0 08 ret
4000b1dc: 81 e8 00 00 restore
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
4000b1e0: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
if ( _Thread_Executing->is_preemptible ||
4000b1e4: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
4000b1e8: 80 a0 60 00 cmp %g1, 0
4000b1ec: 22 80 00 06 be,a 4000b204 <_Scheduler_EDF_Unblock+0x64>
4000b1f0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
4000b1f4: 82 10 20 01 mov 1, %g1
4000b1f8: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
4000b1fc: 81 c7 e0 08 ret
4000b200: 81 e8 00 00 restore
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
4000b204: 80 a0 60 00 cmp %g1, 0
4000b208: 12 bf ff f4 bne 4000b1d8 <_Scheduler_EDF_Unblock+0x38> <== ALWAYS TAKEN
4000b20c: 82 10 20 01 mov 1, %g1
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
4000b210: c2 2f 60 0c stb %g1, [ %i5 + 0xc ] <== NOT EXECUTED
4000b214: 30 bf ff fa b,a 4000b1fc <_Scheduler_EDF_Unblock+0x5c> <== NOT EXECUTED
4000a910 <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
4000a910: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *executing;
executing = _Thread_Executing;
4000a914: 03 10 00 81 sethi %hi(0x40020400), %g1
4000a918: d0 00 63 d0 ld [ %g1 + 0x3d0 ], %o0 ! 400207d0 <_Per_CPU_Information+0x10>
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
4000a91c: c2 0a 20 70 ldub [ %o0 + 0x70 ], %g1
4000a920: 80 a0 60 00 cmp %g1, 0
4000a924: 02 80 00 26 be 4000a9bc <_Scheduler_priority_Tick+0xac>
4000a928: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
4000a92c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4000a930: 80 a0 60 00 cmp %g1, 0
4000a934: 12 80 00 22 bne 4000a9bc <_Scheduler_priority_Tick+0xac>
4000a938: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
4000a93c: c2 02 20 78 ld [ %o0 + 0x78 ], %g1
4000a940: 80 a0 60 01 cmp %g1, 1
4000a944: 0a 80 00 07 bcs 4000a960 <_Scheduler_priority_Tick+0x50>
4000a948: 80 a0 60 02 cmp %g1, 2
4000a94c: 28 80 00 10 bleu,a 4000a98c <_Scheduler_priority_Tick+0x7c>
4000a950: c2 02 20 74 ld [ %o0 + 0x74 ], %g1
4000a954: 80 a0 60 03 cmp %g1, 3
4000a958: 22 80 00 04 be,a 4000a968 <_Scheduler_priority_Tick+0x58><== ALWAYS TAKEN
4000a95c: c2 02 20 74 ld [ %o0 + 0x74 ], %g1
4000a960: 81 c7 e0 08 ret
4000a964: 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 )
4000a968: 82 00 7f ff add %g1, -1, %g1
4000a96c: 80 a0 60 00 cmp %g1, 0
4000a970: 12 bf ff fc bne 4000a960 <_Scheduler_priority_Tick+0x50>
4000a974: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
(*executing->budget_callout)( executing );
4000a978: c2 02 20 7c ld [ %o0 + 0x7c ], %g1
4000a97c: 9f c0 40 00 call %g1
4000a980: 01 00 00 00 nop
4000a984: 81 c7 e0 08 ret
4000a988: 81 e8 00 00 restore
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
#endif
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
4000a98c: 82 00 7f ff add %g1, -1, %g1
4000a990: 80 a0 60 00 cmp %g1, 0
4000a994: 14 bf ff f3 bg 4000a960 <_Scheduler_priority_Tick+0x50>
4000a998: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
4000a99c: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000a9a0: c2 00 61 70 ld [ %g1 + 0x170 ], %g1 ! 4001f570 <_Scheduler+0xc>
4000a9a4: 9f c0 40 00 call %g1
4000a9a8: d0 27 bf fc st %o0, [ %fp + -4 ]
* executing thread's timeslice is reset. Otherwise, the
* currently executing thread is placed at the rear of the
* FIFO for this priority and a new heir is selected.
*/
_Scheduler_Yield();
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4000a9ac: 03 10 00 80 sethi %hi(0x40020000), %g1
4000a9b0: d0 07 bf fc ld [ %fp + -4 ], %o0
4000a9b4: c2 00 62 10 ld [ %g1 + 0x210 ], %g1
4000a9b8: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
4000a9bc: 81 c7 e0 08 ret
4000a9c0: 81 e8 00 00 restore
4000b1b8 <_Scheduler_simple_Ready_queue_enqueue_first>:
{
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
4000b1b8: 03 10 00 81 sethi %hi(0x40020400), %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000b1bc: c2 00 61 64 ld [ %g1 + 0x164 ], %g1 ! 40020564 <_Scheduler>
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
4000b1c0: c6 02 20 14 ld [ %o0 + 0x14 ], %g3
4000b1c4: c2 00 40 00 ld [ %g1 ], %g1
4000b1c8: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000b1cc: 80 a0 80 03 cmp %g2, %g3
4000b1d0: 3a 80 00 08 bcc,a 4000b1f0 <_Scheduler_simple_Ready_queue_enqueue_first+0x38>
4000b1d4: c2 00 60 04 ld [ %g1 + 4 ], %g1
* Do NOT need to check for end of chain because there is always
* at least one task on the ready chain -- the IDLE task. It can
* never block, should never attempt to obtain a semaphore or mutex,
* and thus will always be there.
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
4000b1d8: c2 00 40 00 ld [ %g1 ], %g1
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
4000b1dc: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000b1e0: 80 a0 80 03 cmp %g2, %g3
4000b1e4: 2a bf ff fe bcs,a 4000b1dc <_Scheduler_simple_Ready_queue_enqueue_first+0x24><== NEVER TAKEN
4000b1e8: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
current = (Thread_Control *)current->Object.Node.previous;
4000b1ec: c2 00 60 04 ld [ %g1 + 4 ], %g1
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000b1f0: c4 00 40 00 ld [ %g1 ], %g2
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000b1f4: c2 22 20 04 st %g1, [ %o0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000b1f8: d0 20 40 00 st %o0, [ %g1 ]
the_node->next = before_node;
4000b1fc: c4 22 00 00 st %g2, [ %o0 ]
before_node->previous = the_node;
4000b200: 81 c3 e0 08 retl
4000b204: d0 20 a0 04 st %o0, [ %g2 + 4 ]
40009234 <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
40009234: 9d e3 bf a0 save %sp, -96, %sp
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
40009238: 03 10 00 7e sethi %hi(0x4001f800), %g1
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
4000923c: d2 00 60 7c ld [ %g1 + 0x7c ], %o1 ! 4001f87c <Configuration+0xc>
40009240: 11 00 03 d0 sethi %hi(0xf4000), %o0
40009244: 40 00 4a 77 call 4001bc20 <.udiv>
40009248: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
4000924c: 80 a6 20 00 cmp %i0, 0
40009250: 02 80 00 2c be 40009300 <_TOD_Validate+0xcc> <== NEVER TAKEN
40009254: 82 10 20 00 clr %g1
40009258: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
4000925c: 80 a2 00 02 cmp %o0, %g2
40009260: 28 80 00 26 bleu,a 400092f8 <_TOD_Validate+0xc4>
40009264: b0 08 60 01 and %g1, 1, %i0
(the_tod->ticks >= ticks_per_second) ||
40009268: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
4000926c: 80 a0 a0 3b cmp %g2, 0x3b
40009270: 38 80 00 22 bgu,a 400092f8 <_TOD_Validate+0xc4>
40009274: b0 08 60 01 and %g1, 1, %i0
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
40009278: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
4000927c: 80 a0 a0 3b cmp %g2, 0x3b
40009280: 38 80 00 1e bgu,a 400092f8 <_TOD_Validate+0xc4>
40009284: b0 08 60 01 and %g1, 1, %i0
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
40009288: c4 06 20 0c ld [ %i0 + 0xc ], %g2
4000928c: 80 a0 a0 17 cmp %g2, 0x17
40009290: 38 80 00 1a bgu,a 400092f8 <_TOD_Validate+0xc4>
40009294: b0 08 60 01 and %g1, 1, %i0
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
40009298: c4 06 20 04 ld [ %i0 + 4 ], %g2
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
4000929c: 80 a0 a0 00 cmp %g2, 0
400092a0: 02 80 00 15 be 400092f4 <_TOD_Validate+0xc0> <== NEVER TAKEN
400092a4: 80 a0 a0 0c cmp %g2, 0xc
(the_tod->month == 0) ||
400092a8: 38 80 00 14 bgu,a 400092f8 <_TOD_Validate+0xc4>
400092ac: b0 08 60 01 and %g1, 1, %i0
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
400092b0: c6 06 00 00 ld [ %i0 ], %g3
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
400092b4: 80 a0 e7 c3 cmp %g3, 0x7c3
400092b8: 28 80 00 10 bleu,a 400092f8 <_TOD_Validate+0xc4>
400092bc: b0 08 60 01 and %g1, 1, %i0
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
400092c0: c8 06 20 08 ld [ %i0 + 8 ], %g4
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
400092c4: 80 a1 20 00 cmp %g4, 0
400092c8: 02 80 00 0b be 400092f4 <_TOD_Validate+0xc0> <== NEVER TAKEN
400092cc: 80 88 e0 03 btst 3, %g3
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
400092d0: 32 80 00 0f bne,a 4000930c <_TOD_Validate+0xd8>
400092d4: 85 28 a0 02 sll %g2, 2, %g2
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
400092d8: 82 00 a0 0d add %g2, 0xd, %g1
400092dc: 05 10 00 82 sethi %hi(0x40020800), %g2
400092e0: 83 28 60 02 sll %g1, 2, %g1
400092e4: 84 10 a1 68 or %g2, 0x168, %g2
400092e8: c2 00 80 01 ld [ %g2 + %g1 ], %g1
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
if ( the_tod->day > days_in_month )
400092ec: 80 a0 40 04 cmp %g1, %g4
400092f0: 82 60 3f ff subx %g0, -1, %g1
return false;
return true;
}
400092f4: b0 08 60 01 and %g1, 1, %i0
400092f8: 81 c7 e0 08 ret
400092fc: 81 e8 00 00 restore
40009300: b0 08 60 01 and %g1, 1, %i0 <== NOT EXECUTED
40009304: 81 c7 e0 08 ret <== NOT EXECUTED
40009308: 81 e8 00 00 restore <== NOT EXECUTED
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
4000930c: 03 10 00 82 sethi %hi(0x40020800), %g1
40009310: 82 10 61 68 or %g1, 0x168, %g1 ! 40020968 <_TOD_Days_per_month>
40009314: c2 00 40 02 ld [ %g1 + %g2 ], %g1
if ( the_tod->day > days_in_month )
40009318: 80 a0 40 04 cmp %g1, %g4
4000931c: 10 bf ff f6 b 400092f4 <_TOD_Validate+0xc0>
40009320: 82 60 3f ff subx %g0, -1, %g1
4000abe0 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
4000abe0: 9d e3 bf a0 save %sp, -96, %sp
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
4000abe4: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
/*
* Set a transient state for the thread so it is pulled off the Ready chains.
* This will prevent it from being scheduled no matter what happens in an
* ISR.
*/
_Thread_Set_transient( the_thread );
4000abe8: 40 00 03 9a call 4000ba50 <_Thread_Set_transient>
4000abec: 90 10 00 18 mov %i0, %o0
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
4000abf0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000abf4: 80 a0 40 19 cmp %g1, %i1
4000abf8: 02 80 00 05 be 4000ac0c <_Thread_Change_priority+0x2c>
4000abfc: ba 10 00 18 mov %i0, %i5
_Thread_Set_priority( the_thread, new_priority );
4000ac00: 90 10 00 18 mov %i0, %o0
4000ac04: 40 00 03 79 call 4000b9e8 <_Thread_Set_priority>
4000ac08: 92 10 00 19 mov %i1, %o1
_ISR_Disable( level );
4000ac0c: 7f ff de 31 call 400024d0 <sparc_disable_interrupts>
4000ac10: 01 00 00 00 nop
4000ac14: b2 10 00 08 mov %o0, %i1
/*
* If the thread has more than STATES_TRANSIENT set, then it is blocked,
* If it is blocked on a thread queue, then we need to requeue it.
*/
state = the_thread->current_state;
4000ac18: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
if ( state != STATES_TRANSIENT ) {
4000ac1c: 80 a7 20 04 cmp %i4, 4
4000ac20: 02 80 00 18 be 4000ac80 <_Thread_Change_priority+0xa0>
4000ac24: 80 8e e0 04 btst 4, %i3
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
4000ac28: 02 80 00 0b be 4000ac54 <_Thread_Change_priority+0x74> <== ALWAYS TAKEN
4000ac2c: 82 0f 3f fb and %i4, -5, %g1
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
4000ac30: 7f ff de 2c call 400024e0 <sparc_enable_interrupts> <== NOT EXECUTED
4000ac34: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
4000ac38: 03 00 00 ef sethi %hi(0x3bc00), %g1 <== NOT EXECUTED
4000ac3c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0><== NOT EXECUTED
if ( _States_Is_waiting_on_thread_queue( state ) ) {
4000ac40: 80 8f 00 01 btst %i4, %g1 <== NOT EXECUTED
4000ac44: 32 80 00 0d bne,a 4000ac78 <_Thread_Change_priority+0x98><== NOT EXECUTED
4000ac48: f0 07 60 44 ld [ %i5 + 0x44 ], %i0 <== NOT EXECUTED
4000ac4c: 81 c7 e0 08 ret
4000ac50: 81 e8 00 00 restore
*/
state = the_thread->current_state;
if ( state != STATES_TRANSIENT ) {
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
4000ac54: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
_ISR_Enable( level );
4000ac58: 7f ff de 22 call 400024e0 <sparc_enable_interrupts>
4000ac5c: 90 10 00 19 mov %i1, %o0
4000ac60: 03 00 00 ef sethi %hi(0x3bc00), %g1
4000ac64: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
if ( _States_Is_waiting_on_thread_queue( state ) ) {
4000ac68: 80 8f 00 01 btst %i4, %g1
4000ac6c: 02 bf ff f8 be 4000ac4c <_Thread_Change_priority+0x6c>
4000ac70: 01 00 00 00 nop
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
4000ac74: f0 07 60 44 ld [ %i5 + 0x44 ], %i0
4000ac78: 40 00 03 2c call 4000b928 <_Thread_queue_Requeue>
4000ac7c: 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 ) ) {
4000ac80: 22 80 00 19 be,a 4000ace4 <_Thread_Change_priority+0x104><== ALWAYS TAKEN
4000ac84: c0 27 60 10 clr [ %i5 + 0x10 ]
4000ac88: 39 10 00 7d sethi %hi(0x4001f400), %i4 <== NOT EXECUTED
4000ac8c: b8 17 21 64 or %i4, 0x164, %i4 ! 4001f564 <_Scheduler> <== NOT EXECUTED
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
4000ac90: 7f ff de 14 call 400024e0 <sparc_enable_interrupts>
4000ac94: 90 10 00 19 mov %i1, %o0
4000ac98: 7f ff de 0e call 400024d0 <sparc_disable_interrupts>
4000ac9c: 01 00 00 00 nop
4000aca0: 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();
4000aca4: c2 07 20 08 ld [ %i4 + 8 ], %g1
4000aca8: 9f c0 40 00 call %g1
4000acac: 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 );
4000acb0: 03 10 00 81 sethi %hi(0x40020400), %g1
4000acb4: 82 10 63 c0 or %g1, 0x3c0, %g1 ! 400207c0 <_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() &&
4000acb8: c4 18 60 10 ldd [ %g1 + 0x10 ], %g2
4000acbc: 80 a0 80 03 cmp %g2, %g3
4000acc0: 02 80 00 07 be 4000acdc <_Thread_Change_priority+0xfc>
4000acc4: 01 00 00 00 nop
4000acc8: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
4000accc: 80 a0 a0 00 cmp %g2, 0
4000acd0: 02 80 00 03 be 4000acdc <_Thread_Change_priority+0xfc>
4000acd4: 84 10 20 01 mov 1, %g2
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
4000acd8: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
_ISR_Enable( level );
4000acdc: 7f ff de 01 call 400024e0 <sparc_enable_interrupts>
4000ace0: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
4000ace4: 39 10 00 7d sethi %hi(0x4001f400), %i4
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
if ( prepend_it )
4000ace8: 80 a6 a0 00 cmp %i2, 0
4000acec: 02 80 00 06 be 4000ad04 <_Thread_Change_priority+0x124>
4000acf0: b8 17 21 64 or %i4, 0x164, %i4
4000acf4: c2 07 20 28 ld [ %i4 + 0x28 ], %g1
4000acf8: 9f c0 40 00 call %g1
4000acfc: 90 10 00 1d mov %i5, %o0
4000ad00: 30 bf ff e4 b,a 4000ac90 <_Thread_Change_priority+0xb0>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
4000ad04: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
4000ad08: 9f c0 40 00 call %g1
4000ad0c: 90 10 00 1d mov %i5, %o0
4000ad10: 30 bf ff e0 b,a 4000ac90 <_Thread_Change_priority+0xb0>
4000af00 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
4000af00: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
4000af04: 90 10 00 18 mov %i0, %o0
4000af08: 40 00 00 7c call 4000b0f8 <_Thread_Get>
4000af0c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000af10: c2 07 bf fc ld [ %fp + -4 ], %g1
4000af14: 80 a0 60 00 cmp %g1, 0
4000af18: 12 80 00 08 bne 4000af38 <_Thread_Delay_ended+0x38> <== NEVER TAKEN
4000af1c: 13 04 00 00 sethi %hi(0x10000000), %o1
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
4000af20: 7f ff ff 7d call 4000ad14 <_Thread_Clear_state>
4000af24: 92 12 60 18 or %o1, 0x18, %o1 ! 10000018 <RAM_SIZE+0xfc00018>
*
* 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;
4000af28: 03 10 00 80 sethi %hi(0x40020000), %g1
4000af2c: c4 00 62 b0 ld [ %g1 + 0x2b0 ], %g2 ! 400202b0 <_Thread_Dispatch_disable_level>
--level;
4000af30: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000af34: c4 20 62 b0 st %g2, [ %g1 + 0x2b0 ]
4000af38: 81 c7 e0 08 ret
4000af3c: 81 e8 00 00 restore
4000af40 <_Thread_Dispatch>:
#if defined(RTEMS_SMP)
#include <rtems/score/smp.h>
#endif
void _Thread_Dispatch( void )
{
4000af40: 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;
4000af44: 31 10 00 81 sethi %hi(0x40020400), %i0
4000af48: b0 16 23 c0 or %i0, 0x3c0, %i0 ! 400207c0 <_Per_CPU_Information>
_ISR_Disable( level );
4000af4c: 7f ff dd 61 call 400024d0 <sparc_disable_interrupts>
4000af50: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
while ( _Thread_Dispatch_necessary == true ) {
4000af54: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
4000af58: 80 a0 60 00 cmp %g1, 0
4000af5c: 02 80 00 46 be 4000b074 <_Thread_Dispatch+0x134>
4000af60: 21 10 00 80 sethi %hi(0x40020000), %l0
heir = _Thread_Heir;
4000af64: f4 06 20 14 ld [ %i0 + 0x14 ], %i2
* 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;
4000af68: 82 10 20 01 mov 1, %g1
4000af6c: c2 24 22 b0 st %g1, [ %l0 + 0x2b0 ]
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
4000af70: c0 2e 20 0c clrb [ %i0 + 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 )
4000af74: 80 a6 c0 1a cmp %i3, %i2
4000af78: 02 80 00 3f be 4000b074 <_Thread_Dispatch+0x134>
4000af7c: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
4000af80: 23 10 00 7d sethi %hi(0x4001f400), %l1
4000af84: 27 10 00 80 sethi %hi(0x40020000), %l3
4000af88: a2 14 62 90 or %l1, 0x290, %l1
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
4000af8c: 25 10 00 80 sethi %hi(0x40020000), %l2
4000af90: a6 14 e3 1c or %l3, 0x31c, %l3
4000af94: b2 04 60 04 add %l1, 4, %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;
4000af98: 2b 10 00 80 sethi %hi(0x40020000), %l5
4000af9c: a4 14 a2 00 or %l2, 0x200, %l2
4000afa0: a8 10 20 01 mov 1, %l4
*/
#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 )
4000afa4: c2 06 a0 78 ld [ %i2 + 0x78 ], %g1
4000afa8: 80 a0 60 01 cmp %g1, 1
4000afac: 02 80 00 45 be 4000b0c0 <_Thread_Dispatch+0x180>
4000afb0: c2 05 62 10 ld [ %l5 + 0x210 ], %g1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
_ISR_Enable( level );
4000afb4: 7f ff dd 4b call 400024e0 <sparc_enable_interrupts>
4000afb8: 01 00 00 00 nop
4000afbc: 90 07 bf f8 add %fp, -8, %o0
4000afc0: 7f ff f9 8b call 400095ec <_TOD_Get_with_nanoseconds>
4000afc4: 92 10 00 12 mov %l2, %o1
4000afc8: c4 1e e0 80 ldd [ %i3 + 0x80 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
4000afcc: f8 1e 20 20 ldd [ %i0 + 0x20 ], %i4
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
4000afd0: d8 1f bf f8 ldd [ %fp + -8 ], %o4
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
4000afd4: c2 04 c0 00 ld [ %l3 ], %g1
4000afd8: ba a3 40 1d subcc %o5, %i5, %i5
4000afdc: b8 63 00 1c subx %o4, %i4, %i4
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
4000afe0: 96 80 c0 1d addcc %g3, %i5, %o3
4000afe4: 94 40 80 1c addx %g2, %i4, %o2
4000afe8: d4 3e e0 80 std %o2, [ %i3 + 0x80 ]
4000afec: 80 a0 60 00 cmp %g1, 0
4000aff0: 02 80 00 06 be 4000b008 <_Thread_Dispatch+0xc8> <== NEVER TAKEN
4000aff4: d8 3e 20 20 std %o4, [ %i0 + 0x20 ]
executing->libc_reent = *_Thread_libc_reent;
4000aff8: c4 00 40 00 ld [ %g1 ], %g2
4000affc: c4 26 e1 48 st %g2, [ %i3 + 0x148 ]
*_Thread_libc_reent = heir->libc_reent;
4000b000: c4 06 a1 48 ld [ %i2 + 0x148 ], %g2
4000b004: c4 20 40 00 st %g2, [ %g1 ]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000b008: fa 04 40 00 ld [ %l1 ], %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 ) {
4000b00c: 80 a7 40 19 cmp %i5, %i1
4000b010: 02 80 00 0b be 4000b03c <_Thread_Dispatch+0xfc> <== NEVER TAKEN
4000b014: 90 06 e0 c0 add %i3, 0xc0, %o0
const User_extensions_Switch_control *extension =
(const User_extensions_Switch_control *) node;
(*extension->thread_switch)( executing, heir );
4000b018: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000b01c: 90 10 00 1b mov %i3, %o0
4000b020: 9f c0 40 00 call %g1
4000b024: 92 10 00 1a mov %i2, %o1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(
const Chain_Node *the_node
)
{
return the_node->next;
4000b028: 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 ) {
4000b02c: 80 a7 40 19 cmp %i5, %i1
4000b030: 32 bf ff fb bne,a 4000b01c <_Thread_Dispatch+0xdc>
4000b034: 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 );
4000b038: 90 06 e0 c0 add %i3, 0xc0, %o0
4000b03c: 40 00 04 91 call 4000c280 <_CPU_Context_switch>
4000b040: 92 06 a0 c0 add %i2, 0xc0, %o1
#endif
#endif
executing = _Thread_Executing;
_ISR_Disable( level );
4000b044: 7f ff dd 23 call 400024d0 <sparc_disable_interrupts>
4000b048: f6 06 20 10 ld [ %i0 + 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 ) {
4000b04c: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
4000b050: 80 a0 60 00 cmp %g1, 0
4000b054: 02 80 00 08 be 4000b074 <_Thread_Dispatch+0x134>
4000b058: 01 00 00 00 nop
heir = _Thread_Heir;
4000b05c: f4 06 20 14 ld [ %i0 + 0x14 ], %i2
4000b060: e8 24 22 b0 st %l4, [ %l0 + 0x2b0 ]
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
4000b064: c0 2e 20 0c clrb [ %i0 + 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 )
4000b068: 80 a6 80 1b cmp %i2, %i3
4000b06c: 12 bf ff ce bne 4000afa4 <_Thread_Dispatch+0x64> <== ALWAYS TAKEN
4000b070: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
4000b074: c0 24 22 b0 clr [ %l0 + 0x2b0 ]
post_switch:
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 0 );
#endif
_ISR_Enable( level );
4000b078: 7f ff dd 1a call 400024e0 <sparc_enable_interrupts>
4000b07c: 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;
4000b080: 03 10 00 80 sethi %hi(0x40020000), %g1
4000b084: fa 00 63 20 ld [ %g1 + 0x320 ], %i5 ! 40020320 <_API_extensions_Post_switch_list>
4000b088: 82 10 63 20 or %g1, 0x320, %g1
{
const Chain_Control *chain = &_API_extensions_Post_switch_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
4000b08c: b8 00 60 04 add %g1, 4, %i4
4000b090: 80 a7 40 1c cmp %i5, %i4
4000b094: 02 80 00 09 be 4000b0b8 <_Thread_Dispatch+0x178>
4000b098: 01 00 00 00 nop
const API_extensions_Post_switch_control *post_switch =
(const API_extensions_Post_switch_control *) node;
(*post_switch->hook)( executing );
4000b09c: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000b0a0: 9f c0 40 00 call %g1
4000b0a4: 90 10 00 1b mov %i3, %o0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(
const Chain_Node *the_node
)
{
return the_node->next;
4000b0a8: 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 ) {
4000b0ac: 80 a7 40 1c cmp %i5, %i4
4000b0b0: 32 bf ff fc bne,a 4000b0a0 <_Thread_Dispatch+0x160> <== NEVER TAKEN
4000b0b4: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
4000b0b8: 81 c7 e0 08 ret
4000b0bc: 81 e8 00 00 restore
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
4000b0c0: 10 bf ff bd b 4000afb4 <_Thread_Dispatch+0x74>
4000b0c4: c2 26 a0 74 st %g1, [ %i2 + 0x74 ]
40010704 <_Thread_Handler>:
#define INIT_NAME __main
#define EXECUTE_GLOBAL_CONSTRUCTORS
#endif
void _Thread_Handler( void )
{
40010704: 9d e3 bf a0 save %sp, -96, %sp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
40010708: 03 10 00 81 sethi %hi(0x40020400), %g1
4001070c: fa 00 63 d0 ld [ %g1 + 0x3d0 ], %i5 ! 400207d0 <_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();
40010710: 3f 10 00 41 sethi %hi(0x40010400), %i7
40010714: be 17 e3 04 or %i7, 0x304, %i7 ! 40010704 <_Thread_Handler>
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
40010718: d0 07 60 a8 ld [ %i5 + 0xa8 ], %o0
_ISR_Set_level(level);
4001071c: 7f ff c7 71 call 400024e0 <sparc_enable_interrupts>
40010720: 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;
40010724: 03 10 00 7f sethi %hi(0x4001fc00), %g1
doneConstructors = true;
40010728: 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;
4001072c: f8 08 62 40 ldub [ %g1 + 0x240 ], %i4
);
}
static inline void _User_extensions_Thread_begin( Thread_Control *executing )
{
_User_extensions_Iterate(
40010730: 90 10 00 1d mov %i5, %o0
40010734: 13 10 00 2f sethi %hi(0x4000bc00), %o1
40010738: 92 12 60 34 or %o1, 0x34, %o1 ! 4000bc34 <_User_extensions_Thread_begin_visitor>
4001073c: 7f ff ed 5b call 4000bca8 <_User_extensions_Iterate>
40010740: c4 28 62 40 stb %g2, [ %g1 + 0x240 ]
_User_extensions_Thread_begin( executing );
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
40010744: 7f ff ea 61 call 4000b0c8 <_Thread_Enable_dispatch>
40010748: 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) */ {
4001074c: 80 8f 20 ff btst 0xff, %i4
40010750: 02 80 00 10 be 40010790 <_Thread_Handler+0x8c>
40010754: 01 00 00 00 nop
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
40010758: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
4001075c: 80 a0 60 00 cmp %g1, 0
40010760: 02 80 00 10 be 400107a0 <_Thread_Handler+0x9c>
40010764: 80 a0 60 01 cmp %g1, 1
(*(Thread_Entry_numeric) executing->Start.entry_point)(
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
40010768: 22 80 00 13 be,a 400107b4 <_Thread_Handler+0xb0> <== ALWAYS TAKEN
4001076c: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
}
}
static inline void _User_extensions_Thread_exitted( Thread_Control *executing )
{
_User_extensions_Iterate(
40010770: 90 10 00 1d mov %i5, %o0
40010774: 13 10 00 2f sethi %hi(0x4000bc00), %o1
40010778: 7f ff ed 4c call 4000bca8 <_User_extensions_Iterate>
4001077c: 92 12 60 58 or %o1, 0x58, %o1 ! 4000bc58 <_User_extensions_Thread_exitted_visitor>
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
_Internal_error_Occurred(
40010780: 90 10 20 00 clr %o0
40010784: 92 10 20 01 mov 1, %o1
40010788: 7f ff e4 e1 call 40009b0c <_Internal_error_Occurred>
4001078c: 94 10 20 05 mov 5, %o2
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (doCons) /* && (volatile void *)_init) */ {
INIT_NAME ();
40010790: 40 00 3b 42 call 4001f498 <_init>
40010794: 01 00 00 00 nop
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
40010798: 10 bf ff f1 b 4001075c <_Thread_Handler+0x58>
4001079c: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
400107a0: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
400107a4: 9f c0 40 00 call %g1
400107a8: d0 07 60 98 ld [ %i5 + 0x98 ], %o0
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
400107ac: 10 bf ff f1 b 40010770 <_Thread_Handler+0x6c>
400107b0: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
400107b4: 9f c0 40 00 call %g1
400107b8: d0 07 60 94 ld [ %i5 + 0x94 ], %o0
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
400107bc: 10 bf ff ed b 40010770 <_Thread_Handler+0x6c>
400107c0: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
4000b380 <_Thread_Handler_initialization>:
#if defined(RTEMS_SMP)
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
4000b380: 9d e3 bf 98 save %sp, -104, %sp
uint32_t ticks_per_timeslice =
4000b384: 03 10 00 75 sethi %hi(0x4001d400), %g1
4000b388: 82 10 62 18 or %g1, 0x218, %g1 ! 4001d618 <Configuration>
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
4000b38c: c6 00 60 28 ld [ %g1 + 0x28 ], %g3
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
uint32_t ticks_per_timeslice =
4000b390: fa 00 60 14 ld [ %g1 + 0x14 ], %i5
rtems_configuration_get_ticks_per_timeslice();
uint32_t maximum_extensions =
4000b394: 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 ||
4000b398: 80 a0 e0 00 cmp %g3, 0
4000b39c: 02 80 00 1f be 4000b418 <_Thread_Handler_initialization+0x98><== NEVER TAKEN
4000b3a0: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
4000b3a4: c6 00 60 2c ld [ %g1 + 0x2c ], %g3
4000b3a8: 80 a0 e0 00 cmp %g3, 0
4000b3ac: 02 80 00 1b be 4000b418 <_Thread_Handler_initialization+0x98>
4000b3b0: 80 a0 a0 00 cmp %g2, 0
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
if ( stack_allocate_init_hook != NULL )
4000b3b4: 22 80 00 05 be,a 4000b3c8 <_Thread_Handler_initialization+0x48>
4000b3b8: 03 10 00 81 sethi %hi(0x40020400), %g1
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
4000b3bc: 9f c0 80 00 call %g2
4000b3c0: d0 00 60 04 ld [ %g1 + 4 ], %o0 ! 40020404 <_CPU_Null_fp_context+0x24>
_Thread_Dispatch_necessary = false;
4000b3c4: 03 10 00 81 sethi %hi(0x40020400), %g1
4000b3c8: 82 10 63 c0 or %g1, 0x3c0, %g1 ! 400207c0 <_Per_CPU_Information>
4000b3cc: c0 28 60 0c clrb [ %g1 + 0xc ]
_Thread_Executing = NULL;
4000b3d0: c0 20 60 10 clr [ %g1 + 0x10 ]
_Thread_Heir = NULL;
4000b3d4: c0 20 60 14 clr [ %g1 + 0x14 ]
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
#endif
_Thread_Maximum_extensions = maximum_extensions;
4000b3d8: 03 10 00 80 sethi %hi(0x40020000), %g1
4000b3dc: f8 20 63 2c st %i4, [ %g1 + 0x32c ] ! 4002032c <_Thread_Maximum_extensions>
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
4000b3e0: 03 10 00 80 sethi %hi(0x40020000), %g1
4000b3e4: fa 20 62 10 st %i5, [ %g1 + 0x210 ] ! 40020210 <_Thread_Ticks_per_timeslice>
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
4000b3e8: 82 10 20 08 mov 8, %g1
4000b3ec: 11 10 00 80 sethi %hi(0x40020000), %o0
4000b3f0: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000b3f4: 90 12 23 a0 or %o0, 0x3a0, %o0
4000b3f8: 92 10 20 01 mov 1, %o1
4000b3fc: 94 10 20 01 mov 1, %o2
4000b400: 96 10 20 01 mov 1, %o3
4000b404: 98 10 21 60 mov 0x160, %o4
4000b408: 7f ff fb 6a call 4000a1b0 <_Objects_Initialize_information>
4000b40c: 9a 10 20 00 clr %o5
4000b410: 81 c7 e0 08 ret
4000b414: 81 e8 00 00 restore
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
rtems_configuration_get_stack_free_hook() == NULL)
_Internal_error_Occurred(
4000b418: 90 10 20 00 clr %o0
4000b41c: 92 10 20 01 mov 1, %o1
4000b420: 7f ff f9 bb call 40009b0c <_Internal_error_Occurred>
4000b424: 94 10 20 0e mov 0xe, %o2
4000b1a4 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
4000b1a4: 9d e3 bf 98 save %sp, -104, %sp
4000b1a8: 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;
4000b1ac: c0 26 61 4c clr [ %i1 + 0x14c ]
4000b1b0: c0 26 61 50 clr [ %i1 + 0x150 ]
extensions_area = NULL;
the_thread->libc_reent = NULL;
4000b1b4: c0 26 61 48 clr [ %i1 + 0x148 ]
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
4000b1b8: f8 07 a0 60 ld [ %fp + 0x60 ], %i4
4000b1bc: e0 00 40 00 ld [ %g1 ], %l0
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
4000b1c0: 80 a6 a0 00 cmp %i2, 0
4000b1c4: 02 80 00 60 be 4000b344 <_Thread_Initialize+0x1a0>
4000b1c8: e2 0f a0 5f ldub [ %fp + 0x5f ], %l1
stack = the_thread->Start.stack;
the_thread->Start.core_allocated_stack = true;
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
4000b1cc: c0 2e 60 b0 clrb [ %i1 + 0xb0 ]
4000b1d0: 90 10 00 1b mov %i3, %o0
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
4000b1d4: 37 10 00 80 sethi %hi(0x40020000), %i3
4000b1d8: c2 06 e3 2c ld [ %i3 + 0x32c ], %g1 ! 4002032c <_Thread_Maximum_extensions>
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
4000b1dc: f4 26 60 b8 st %i2, [ %i1 + 0xb8 ]
the_stack->size = size;
4000b1e0: d0 26 60 b4 st %o0, [ %i1 + 0xb4 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
4000b1e4: c0 26 60 50 clr [ %i1 + 0x50 ]
the_watchdog->routine = routine;
4000b1e8: c0 26 60 64 clr [ %i1 + 0x64 ]
the_watchdog->id = id;
4000b1ec: c0 26 60 68 clr [ %i1 + 0x68 ]
4000b1f0: 80 a0 60 00 cmp %g1, 0
4000b1f4: 12 80 00 40 bne 4000b2f4 <_Thread_Initialize+0x150>
4000b1f8: c0 26 60 6c clr [ %i1 + 0x6c ]
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
4000b1fc: c0 26 61 54 clr [ %i1 + 0x154 ]
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
4000b200: b4 10 20 00 clr %i2
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
4000b204: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
4000b208: e2 2e 60 9c stb %l1, [ %i1 + 0x9c ]
the_thread->Start.budget_algorithm = budget_algorithm;
4000b20c: f8 26 60 a0 st %i4, [ %i1 + 0xa0 ]
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
4000b210: 80 a7 20 02 cmp %i4, 2
4000b214: 12 80 00 05 bne 4000b228 <_Thread_Initialize+0x84>
4000b218: 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;
4000b21c: 03 10 00 80 sethi %hi(0x40020000), %g1
4000b220: c2 00 62 10 ld [ %g1 + 0x210 ], %g1 ! 40020210 <_Thread_Ticks_per_timeslice>
4000b224: c2 26 60 74 st %g1, [ %i1 + 0x74 ]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
4000b228: c4 07 a0 68 ld [ %fp + 0x68 ], %g2
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
4000b22c: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000b230: c2 00 61 7c ld [ %g1 + 0x17c ], %g1 ! 4001f57c <_Scheduler+0x18>
4000b234: c4 26 60 a8 st %g2, [ %i1 + 0xa8 ]
the_thread->current_state = STATES_DORMANT;
4000b238: b6 10 20 01 mov 1, %i3
the_thread->Wait.queue = NULL;
4000b23c: c0 26 60 44 clr [ %i1 + 0x44 ]
#endif
}
the_thread->Start.isr_level = isr_level;
the_thread->current_state = STATES_DORMANT;
4000b240: f6 26 60 10 st %i3, [ %i1 + 0x10 ]
the_thread->Wait.queue = NULL;
the_thread->resource_count = 0;
4000b244: c0 26 60 1c clr [ %i1 + 0x1c ]
the_thread->real_priority = priority;
4000b248: fa 26 60 18 st %i5, [ %i1 + 0x18 ]
the_thread->Start.initial_priority = priority;
4000b24c: fa 26 60 ac st %i5, [ %i1 + 0xac ]
4000b250: 9f c0 40 00 call %g1
4000b254: 90 10 00 19 mov %i1, %o0
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
4000b258: b8 92 20 00 orcc %o0, 0, %i4
4000b25c: 22 80 00 17 be,a 4000b2b8 <_Thread_Initialize+0x114>
4000b260: d0 06 61 48 ld [ %i1 + 0x148 ], %o0
goto failed;
_Thread_Set_priority( the_thread, priority );
4000b264: 90 10 00 19 mov %i1, %o0
4000b268: 40 00 01 e0 call 4000b9e8 <_Thread_Set_priority>
4000b26c: 92 10 00 1d mov %i5, %o1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000b270: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
4000b274: c2 16 60 0a lduh [ %i1 + 0xa ], %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
4000b278: c0 26 60 80 clr [ %i1 + 0x80 ]
4000b27c: c0 26 60 84 clr [ %i1 + 0x84 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000b280: 83 28 60 02 sll %g1, 2, %g1
4000b284: f2 20 80 01 st %i1, [ %g2 + %g1 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
4000b288: e0 26 60 0c st %l0, [ %i1 + 0xc ]
* @{
*/
static inline bool _User_extensions_Thread_create( Thread_Control *created )
{
User_extensions_Thread_create_context ctx = { created, true };
4000b28c: f2 27 bf f8 st %i1, [ %fp + -8 ]
4000b290: f6 2f bf fc stb %i3, [ %fp + -4 ]
_User_extensions_Iterate( &ctx, _User_extensions_Thread_create_visitor );
4000b294: 90 07 bf f8 add %fp, -8, %o0
4000b298: 13 10 00 2e sethi %hi(0x4000b800), %o1
4000b29c: 40 00 02 83 call 4000bca8 <_User_extensions_Iterate>
4000b2a0: 92 12 63 80 or %o1, 0x380, %o1 ! 4000bb80 <_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 )
4000b2a4: c2 0f bf fc ldub [ %fp + -4 ], %g1
4000b2a8: 80 a0 60 00 cmp %g1, 0
4000b2ac: 12 80 00 0f bne 4000b2e8 <_Thread_Initialize+0x144>
4000b2b0: b0 10 20 01 mov 1, %i0
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
4000b2b4: d0 06 61 48 ld [ %i1 + 0x148 ], %o0
4000b2b8: 40 00 03 dd call 4000c22c <_Workspace_Free>
4000b2bc: b0 10 20 00 clr %i0
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
4000b2c0: 40 00 03 db call 4000c22c <_Workspace_Free>
4000b2c4: d0 06 61 4c ld [ %i1 + 0x14c ], %o0
4000b2c8: 40 00 03 d9 call 4000c22c <_Workspace_Free>
4000b2cc: d0 06 61 50 ld [ %i1 + 0x150 ], %o0
_Workspace_Free( extensions_area );
4000b2d0: 40 00 03 d7 call 4000c22c <_Workspace_Free>
4000b2d4: 90 10 00 1a mov %i2, %o0
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
#endif
_Workspace_Free( sched );
4000b2d8: 40 00 03 d5 call 4000c22c <_Workspace_Free>
4000b2dc: 90 10 00 1c mov %i4, %o0
_Thread_Stack_Free( the_thread );
4000b2e0: 40 00 01 fb call 4000bacc <_Thread_Stack_Free>
4000b2e4: 90 10 00 19 mov %i1, %o0
4000b2e8: b0 0e 20 ff and %i0, 0xff, %i0
4000b2ec: 81 c7 e0 08 ret
4000b2f0: 81 e8 00 00 restore
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
4000b2f4: 90 00 60 01 add %g1, 1, %o0
4000b2f8: 40 00 03 c5 call 4000c20c <_Workspace_Allocate>
4000b2fc: 91 2a 20 02 sll %o0, 2, %o0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
4000b300: b4 92 20 00 orcc %o0, 0, %i2
4000b304: 02 80 00 1d be 4000b378 <_Thread_Initialize+0x1d4>
4000b308: 86 10 00 1a mov %i2, %g3
goto failed;
}
the_thread->extensions = (void **) extensions_area;
4000b30c: f4 26 61 54 st %i2, [ %i1 + 0x154 ]
4000b310: c8 06 e3 2c ld [ %i3 + 0x32c ], %g4
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
4000b314: 84 10 20 00 clr %g2
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
4000b318: 10 80 00 03 b 4000b324 <_Thread_Initialize+0x180>
4000b31c: 82 10 20 00 clr %g1
4000b320: c6 06 61 54 ld [ %i1 + 0x154 ], %g3
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
the_thread->extensions[i] = NULL;
4000b324: 85 28 a0 02 sll %g2, 2, %g2
4000b328: c0 20 c0 02 clr [ %g3 + %g2 ]
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
4000b32c: 82 00 60 01 inc %g1
4000b330: 80 a0 40 04 cmp %g1, %g4
4000b334: 08 bf ff fb bleu 4000b320 <_Thread_Initialize+0x17c>
4000b338: 84 10 00 01 mov %g1, %g2
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
4000b33c: 10 bf ff b3 b 4000b208 <_Thread_Initialize+0x64>
4000b340: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
4000b344: 90 10 00 19 mov %i1, %o0
4000b348: 40 00 01 d1 call 4000ba8c <_Thread_Stack_Allocate>
4000b34c: 92 10 00 1b mov %i3, %o1
if ( !actual_stack_size || actual_stack_size < stack_size )
4000b350: 80 a2 00 1b cmp %o0, %i3
4000b354: 0a 80 00 07 bcs 4000b370 <_Thread_Initialize+0x1cc>
4000b358: 80 a2 20 00 cmp %o0, 0
4000b35c: 02 80 00 05 be 4000b370 <_Thread_Initialize+0x1cc> <== NEVER TAKEN
4000b360: 82 10 20 01 mov 1, %g1
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
4000b364: f4 06 60 bc ld [ %i1 + 0xbc ], %i2
the_thread->Start.core_allocated_stack = true;
4000b368: 10 bf ff 9b b 4000b1d4 <_Thread_Initialize+0x30>
4000b36c: c2 2e 60 b0 stb %g1, [ %i1 + 0xb0 ]
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
4000b370: 10 bf ff de b 4000b2e8 <_Thread_Initialize+0x144>
4000b374: b0 10 20 00 clr %i0
size_t actual_stack_size = 0;
void *stack = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
void *fp_area;
#endif
void *sched = NULL;
4000b378: 10 bf ff cf b 4000b2b4 <_Thread_Initialize+0x110>
4000b37c: b8 10 20 00 clr %i4
4000bacc <_Thread_Stack_Free>:
#include <rtems/config.h>
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
4000bacc: 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 )
4000bad0: c2 0e 20 b0 ldub [ %i0 + 0xb0 ], %g1
4000bad4: 80 a0 60 00 cmp %g1, 0
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
rtems_stack_free_hook stack_free_hook =
4000bad8: 03 10 00 75 sethi %hi(0x4001d400), %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 )
4000badc: 02 80 00 04 be 4000baec <_Thread_Stack_Free+0x20> <== NEVER TAKEN
4000bae0: c2 00 62 44 ld [ %g1 + 0x244 ], %g1 ! 4001d644 <Configuration+0x2c>
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
(*stack_free_hook)( the_thread->Start.Initial_stack.area );
4000bae4: 9f c0 40 00 call %g1
4000bae8: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
4000baec: 81 c7 e0 08 ret
4000baf0: 81 e8 00 00 restore
400107c4 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
400107c4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
ISR_Level level;
_ISR_Disable( level );
400107c8: 7f ff c7 42 call 400024d0 <sparc_disable_interrupts> <== NOT EXECUTED
400107cc: 01 00 00 00 nop <== NOT EXECUTED
400107d0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
400107d4: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 <== NOT EXECUTED
400107d8: 03 00 00 ef sethi %hi(0x3bc00), %g1 <== NOT EXECUTED
400107dc: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0><== NOT EXECUTED
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
400107e0: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED
400107e4: 02 80 00 1a be 4001084c <_Thread_queue_Extract_fifo+0x88> <== NOT EXECUTED
400107e8: 01 00 00 00 nop <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
400107ec: c4 06 40 00 ld [ %i1 ], %g2 <== NOT EXECUTED
previous = the_node->previous;
400107f0: c2 06 60 04 ld [ %i1 + 4 ], %g1 <== NOT EXECUTED
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
400107f4: c6 06 60 50 ld [ %i1 + 0x50 ], %g3 <== NOT EXECUTED
next->previous = previous;
400107f8: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
previous->next = next;
400107fc: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED
40010800: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED
40010804: 02 80 00 08 be 40010824 <_Thread_queue_Extract_fifo+0x60> <== NOT EXECUTED
40010808: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED
_ISR_Enable( level );
4001080c: 7f ff c7 35 call 400024e0 <sparc_enable_interrupts> <== NOT EXECUTED
40010810: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
40010814: 33 04 01 ff sethi %hi(0x1007fc00), %i1 <== NOT EXECUTED
40010818: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1007fff8 <RAM_SIZE+0xfc7fff8><== NOT EXECUTED
4001081c: 7f ff e9 3e call 4000ad14 <_Thread_Clear_state> <== NOT EXECUTED
40010820: 81 e8 00 00 restore <== NOT EXECUTED
40010824: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED
40010828: c2 26 60 50 st %g1, [ %i1 + 0x50 ] <== NOT EXECUTED
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4001082c: 7f ff c7 2d call 400024e0 <sparc_enable_interrupts> <== NOT EXECUTED
40010830: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
40010834: 7f ff ed c0 call 4000bf34 <_Watchdog_Remove> <== NOT EXECUTED
40010838: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED
4001083c: 33 04 01 ff sethi %hi(0x1007fc00), %i1 <== NOT EXECUTED
40010840: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1007fff8 <RAM_SIZE+0xfc7fff8><== NOT EXECUTED
40010844: 7f ff e9 34 call 4000ad14 <_Thread_Clear_state> <== NOT EXECUTED
40010848: 81 e8 00 00 restore <== NOT EXECUTED
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_ISR_Enable( level );
4001084c: 7f ff c7 25 call 400024e0 <sparc_enable_interrupts> <== NOT EXECUTED
40010850: 81 e8 00 00 restore <== NOT EXECUTED
4000b928 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
4000b928: 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 )
4000b92c: 80 a6 20 00 cmp %i0, 0
4000b930: 02 80 00 13 be 4000b97c <_Thread_queue_Requeue+0x54> <== NEVER TAKEN
4000b934: 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 ) {
4000b938: fa 06 20 34 ld [ %i0 + 0x34 ], %i5
4000b93c: 80 a7 60 01 cmp %i5, 1
4000b940: 02 80 00 04 be 4000b950 <_Thread_queue_Requeue+0x28> <== ALWAYS TAKEN
4000b944: 01 00 00 00 nop
4000b948: 81 c7 e0 08 ret <== NOT EXECUTED
4000b94c: 81 e8 00 00 restore <== NOT EXECUTED
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
4000b950: 7f ff da e0 call 400024d0 <sparc_disable_interrupts>
4000b954: 01 00 00 00 nop
4000b958: b8 10 00 08 mov %o0, %i4
4000b95c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
4000b960: 03 00 00 ef sethi %hi(0x3bc00), %g1
4000b964: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000b968: 80 88 80 01 btst %g2, %g1
4000b96c: 12 80 00 06 bne 4000b984 <_Thread_queue_Requeue+0x5c> <== ALWAYS TAKEN
4000b970: 90 10 00 18 mov %i0, %o0
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
4000b974: 7f ff da db call 400024e0 <sparc_enable_interrupts>
4000b978: 90 10 00 1c mov %i4, %o0
4000b97c: 81 c7 e0 08 ret
4000b980: 81 e8 00 00 restore
ISR_Level level_ignored;
_ISR_Disable( level );
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
4000b984: 92 10 00 19 mov %i1, %o1
4000b988: 94 10 20 01 mov 1, %o2
4000b98c: 40 00 0c c8 call 4000ecac <_Thread_queue_Extract_priority_helper>
4000b990: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
4000b994: 90 10 00 18 mov %i0, %o0
4000b998: 92 10 00 19 mov %i1, %o1
4000b99c: 7f ff ff 35 call 4000b670 <_Thread_queue_Enqueue_priority>
4000b9a0: 94 07 bf fc add %fp, -4, %o2
4000b9a4: 30 bf ff f4 b,a 4000b974 <_Thread_queue_Requeue+0x4c>
4000b9a8 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
4000b9a8: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
4000b9ac: 90 10 00 18 mov %i0, %o0
4000b9b0: 7f ff fd d2 call 4000b0f8 <_Thread_Get>
4000b9b4: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000b9b8: c2 07 bf fc ld [ %fp + -4 ], %g1
4000b9bc: 80 a0 60 00 cmp %g1, 0
4000b9c0: 12 80 00 08 bne 4000b9e0 <_Thread_queue_Timeout+0x38> <== NEVER TAKEN
4000b9c4: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
4000b9c8: 40 00 0c f2 call 4000ed90 <_Thread_queue_Process_timeout>
4000b9cc: 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;
4000b9d0: 03 10 00 80 sethi %hi(0x40020000), %g1
4000b9d4: c4 00 62 b0 ld [ %g1 + 0x2b0 ], %g2 ! 400202b0 <_Thread_Dispatch_disable_level>
--level;
4000b9d8: 84 00 bf ff add %g2, -1, %g2
_Thread_Dispatch_disable_level = level;
4000b9dc: c4 20 62 b0 st %g2, [ %g1 + 0x2b0 ]
4000b9e0: 81 c7 e0 08 ret
4000b9e4: 81 e8 00 00 restore
40018af0 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
40018af0: 9d e3 bf 88 save %sp, -120, %sp
40018af4: 21 10 00 fa sethi %hi(0x4003e800), %l0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
40018af8: a4 07 bf e8 add %fp, -24, %l2
40018afc: b4 07 bf ec add %fp, -20, %i2
40018b00: b8 07 bf f4 add %fp, -12, %i4
40018b04: a2 07 bf f8 add %fp, -8, %l1
40018b08: 33 10 00 f9 sethi %hi(0x4003e400), %i1
40018b0c: 27 10 00 fa sethi %hi(0x4003e800), %l3
40018b10: f4 27 bf e8 st %i2, [ %fp + -24 ]
head->previous = NULL;
40018b14: c0 27 bf ec clr [ %fp + -20 ]
tail->previous = head;
40018b18: 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;
40018b1c: e2 27 bf f4 st %l1, [ %fp + -12 ]
head->previous = NULL;
40018b20: c0 27 bf f8 clr [ %fp + -8 ]
tail->previous = head;
40018b24: f8 27 bf fc st %i4, [ %fp + -4 ]
40018b28: a0 14 21 48 or %l0, 0x148, %l0
40018b2c: b6 06 20 30 add %i0, 0x30, %i3
40018b30: b2 16 63 a8 or %i1, 0x3a8, %i1
40018b34: ba 06 20 68 add %i0, 0x68, %i5
40018b38: a6 14 e0 60 or %l3, 0x60, %l3
40018b3c: ac 06 20 08 add %i0, 8, %l6
40018b40: aa 06 20 40 add %i0, 0x40, %l5
_Thread_Set_state( ts->thread, STATES_DELAYING );
_Timer_server_Reset_interval_system_watchdog( ts );
_Timer_server_Reset_tod_system_watchdog( ts );
_Thread_Enable_dispatch();
ts->active = true;
40018b44: a8 10 20 01 mov 1, %l4
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
40018b48: 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;
40018b4c: c2 04 00 00 ld [ %l0 ], %g1
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
40018b50: d2 06 20 3c ld [ %i0 + 0x3c ], %o1
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
40018b54: 90 10 00 1b mov %i3, %o0
40018b58: 92 20 40 09 sub %g1, %o1, %o1
40018b5c: 94 10 00 1c mov %i4, %o2
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
40018b60: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
40018b64: 40 00 12 35 call 4001d438 <_Watchdog_Adjust_to_chain>
40018b68: 01 00 00 00 nop
40018b6c: d0 1e 40 00 ldd [ %i1 ], %o0
40018b70: 94 10 20 00 clr %o2
40018b74: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40018b78: 40 00 51 6b call 4002d124 <__divdi3>
40018b7c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
40018b80: 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 ) {
40018b84: 80 a2 40 0a cmp %o1, %o2
40018b88: 18 80 00 2b bgu 40018c34 <_Timer_server_Body+0x144>
40018b8c: ae 10 00 09 mov %o1, %l7
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
40018b90: 80 a2 40 0a cmp %o1, %o2
40018b94: 0a 80 00 20 bcs 40018c14 <_Timer_server_Body+0x124>
40018b98: 90 10 00 1d mov %i5, %o0
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
40018b9c: ee 26 20 74 st %l7, [ %i0 + 0x74 ]
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
40018ba0: d0 06 20 78 ld [ %i0 + 0x78 ], %o0
40018ba4: 40 00 02 c2 call 400196ac <_Chain_Get>
40018ba8: 01 00 00 00 nop
if ( timer == NULL ) {
40018bac: 92 92 20 00 orcc %o0, 0, %o1
40018bb0: 02 80 00 10 be 40018bf0 <_Timer_server_Body+0x100>
40018bb4: 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 ) {
40018bb8: c2 02 60 38 ld [ %o1 + 0x38 ], %g1
40018bbc: 80 a0 60 01 cmp %g1, 1
40018bc0: 02 80 00 19 be 40018c24 <_Timer_server_Body+0x134>
40018bc4: 80 a0 60 03 cmp %g1, 3
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
40018bc8: 12 bf ff f6 bne 40018ba0 <_Timer_server_Body+0xb0> <== NEVER TAKEN
40018bcc: 92 02 60 10 add %o1, 0x10, %o1
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
40018bd0: 40 00 12 46 call 4001d4e8 <_Watchdog_Insert>
40018bd4: 90 10 00 1d mov %i5, %o0
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
40018bd8: d0 06 20 78 ld [ %i0 + 0x78 ], %o0
40018bdc: 40 00 02 b4 call 400196ac <_Chain_Get>
40018be0: 01 00 00 00 nop
if ( timer == NULL ) {
40018be4: 92 92 20 00 orcc %o0, 0, %o1
40018be8: 32 bf ff f5 bne,a 40018bbc <_Timer_server_Body+0xcc> <== NEVER TAKEN
40018bec: c2 02 60 38 ld [ %o1 + 0x38 ], %g1 <== NOT EXECUTED
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
40018bf0: 7f ff da 73 call 4000f5bc <sparc_disable_interrupts>
40018bf4: 01 00 00 00 nop
if ( _Chain_Is_empty( insert_chain ) ) {
40018bf8: c2 07 bf e8 ld [ %fp + -24 ], %g1
40018bfc: 80 a0 40 1a cmp %g1, %i2
40018c00: 02 80 00 12 be 40018c48 <_Timer_server_Body+0x158> <== ALWAYS TAKEN
40018c04: 01 00 00 00 nop
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
40018c08: 7f ff da 71 call 4000f5cc <sparc_enable_interrupts> <== NOT EXECUTED
40018c0c: 01 00 00 00 nop <== NOT EXECUTED
40018c10: 30 bf ff cf b,a 40018b4c <_Timer_server_Body+0x5c> <== NOT EXECUTED
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
40018c14: 92 10 20 01 mov 1, %o1 ! 1 <PROM_START+0x1>
40018c18: 40 00 11 d8 call 4001d378 <_Watchdog_Adjust>
40018c1c: 94 22 80 17 sub %o2, %l7, %o2
40018c20: 30 bf ff df b,a 40018b9c <_Timer_server_Body+0xac>
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
40018c24: 90 10 00 1b mov %i3, %o0
40018c28: 40 00 12 30 call 4001d4e8 <_Watchdog_Insert>
40018c2c: 92 02 60 10 add %o1, 0x10, %o1
40018c30: 30 bf ff dc b,a 40018ba0 <_Timer_server_Body+0xb0>
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
40018c34: 92 22 40 0a sub %o1, %o2, %o1
40018c38: 90 10 00 1d mov %i5, %o0
40018c3c: 40 00 11 ff call 4001d438 <_Watchdog_Adjust_to_chain>
40018c40: 94 10 00 1c mov %i4, %o2
40018c44: 30 bf ff d6 b,a 40018b9c <_Timer_server_Body+0xac>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
40018c48: c0 26 20 78 clr [ %i0 + 0x78 ]
_ISR_Enable( level );
40018c4c: 7f ff da 60 call 4000f5cc <sparc_enable_interrupts>
40018c50: 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 ) ) {
40018c54: c2 07 bf f4 ld [ %fp + -12 ], %g1
40018c58: 80 a0 40 11 cmp %g1, %l1
40018c5c: 12 80 00 0c bne 40018c8c <_Timer_server_Body+0x19c>
40018c60: 01 00 00 00 nop
40018c64: 30 80 00 13 b,a 40018cb0 <_Timer_server_Body+0x1c0>
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
new_first->previous = head;
40018c68: 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;
40018c6c: c2 27 bf f4 st %g1, [ %fp + -12 ]
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
40018c70: c0 25 e0 08 clr [ %l7 + 8 ]
_ISR_Enable( level );
40018c74: 7f ff da 56 call 4000f5cc <sparc_enable_interrupts>
40018c78: 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 );
40018c7c: d0 05 e0 20 ld [ %l7 + 0x20 ], %o0
40018c80: c2 05 e0 1c ld [ %l7 + 0x1c ], %g1
40018c84: 9f c0 40 00 call %g1
40018c88: d2 05 e0 24 ld [ %l7 + 0x24 ], %o1
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
40018c8c: 7f ff da 4c call 4000f5bc <sparc_disable_interrupts>
40018c90: 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;
40018c94: ee 07 bf f4 ld [ %fp + -12 ], %l7
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
40018c98: 80 a5 c0 11 cmp %l7, %l1
40018c9c: 32 bf ff f3 bne,a 40018c68 <_Timer_server_Body+0x178>
40018ca0: c2 05 c0 00 ld [ %l7 ], %g1
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
40018ca4: 7f ff da 4a call 4000f5cc <sparc_enable_interrupts>
40018ca8: 01 00 00 00 nop
40018cac: 30 bf ff a7 b,a 40018b48 <_Timer_server_Body+0x58>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
40018cb0: 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;
40018cb4: c2 04 c0 00 ld [ %l3 ], %g1
++level;
40018cb8: 82 00 60 01 inc %g1
_Thread_Dispatch_disable_level = level;
40018cbc: c2 24 c0 00 st %g1, [ %l3 ]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
40018cc0: d0 06 00 00 ld [ %i0 ], %o0
40018cc4: 40 00 10 c1 call 4001cfc8 <_Thread_Set_state>
40018cc8: 92 10 20 08 mov 8, %o1
_Timer_server_Reset_interval_system_watchdog( ts );
40018ccc: 7f ff ff 07 call 400188e8 <_Timer_server_Reset_interval_system_watchdog>
40018cd0: 90 10 00 18 mov %i0, %o0
_Timer_server_Reset_tod_system_watchdog( ts );
40018cd4: 7f ff ff 19 call 40018938 <_Timer_server_Reset_tod_system_watchdog>
40018cd8: 90 10 00 18 mov %i0, %o0
_Thread_Enable_dispatch();
40018cdc: 40 00 0e 4d call 4001c610 <_Thread_Enable_dispatch>
40018ce0: 01 00 00 00 nop
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
40018ce4: 90 10 00 16 mov %l6, %o0
_Thread_Set_state( ts->thread, STATES_DELAYING );
_Timer_server_Reset_interval_system_watchdog( ts );
_Timer_server_Reset_tod_system_watchdog( ts );
_Thread_Enable_dispatch();
ts->active = true;
40018ce8: e8 2e 20 7c stb %l4, [ %i0 + 0x7c ]
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
40018cec: 40 00 12 5e call 4001d664 <_Watchdog_Remove>
40018cf0: 01 00 00 00 nop
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
40018cf4: 40 00 12 5c call 4001d664 <_Watchdog_Remove>
40018cf8: 90 10 00 15 mov %l5, %o0
40018cfc: 30 bf ff 93 b,a 40018b48 <_Timer_server_Body+0x58>
40018988 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
40018988: 9d e3 bf a0 save %sp, -96, %sp
if ( ts->insert_chain == NULL ) {
4001898c: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
40018990: 80 a0 60 00 cmp %g1, 0
40018994: 02 80 00 05 be 400189a8 <_Timer_server_Schedule_operation_method+0x20>
40018998: ba 10 00 19 mov %i1, %i5
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
4001899c: f0 06 20 78 ld [ %i0 + 0x78 ], %i0
400189a0: 40 00 03 38 call 40019680 <_Chain_Append>
400189a4: 81 e8 00 00 restore
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
400189a8: 03 10 00 fa sethi %hi(0x4003e800), %g1
400189ac: c4 00 60 60 ld [ %g1 + 0x60 ], %g2 ! 4003e860 <_Thread_Dispatch_disable_level>
++level;
400189b0: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400189b4: c4 20 60 60 st %g2, [ %g1 + 0x60 ]
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
400189b8: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
400189bc: 80 a0 60 01 cmp %g1, 1
400189c0: 02 80 00 2b be 40018a6c <_Timer_server_Schedule_operation_method+0xe4>
400189c4: 80 a0 60 03 cmp %g1, 3
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
if ( !ts->active ) {
_Timer_server_Reset_interval_system_watchdog( ts );
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
400189c8: 02 80 00 04 be 400189d8 <_Timer_server_Schedule_operation_method+0x50>
400189cc: 01 00 00 00 nop
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
400189d0: 40 00 0f 10 call 4001c610 <_Thread_Enable_dispatch>
400189d4: 81 e8 00 00 restore
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
400189d8: 7f ff da f9 call 4000f5bc <sparc_disable_interrupts>
400189dc: 01 00 00 00 nop
400189e0: b8 10 00 08 mov %o0, %i4
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
400189e4: 03 10 00 f9 sethi %hi(0x4003e400), %g1
400189e8: d0 18 63 a8 ldd [ %g1 + 0x3a8 ], %o0 ! 4003e7a8 <_TOD>
400189ec: 94 10 20 00 clr %o2
400189f0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400189f4: 40 00 51 cc call 4002d124 <__divdi3>
400189f8: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
400189fc: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
last_snapshot = ts->TOD_watchdogs.last_snapshot;
40018a00: 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 );
40018a04: 86 06 20 6c add %i0, 0x6c, %g3
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
40018a08: 80 a0 40 03 cmp %g1, %g3
40018a0c: 02 80 00 0a be 40018a34 <_Timer_server_Schedule_operation_method+0xac>
40018a10: 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 ) {
40018a14: 08 80 00 34 bleu 40018ae4 <_Timer_server_Schedule_operation_method+0x15c>
40018a18: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
40018a1c: 84 22 40 02 sub %o1, %g2, %g2
if (delta_interval > delta) {
40018a20: 80 a1 00 02 cmp %g4, %g2
40018a24: 08 80 00 03 bleu 40018a30 <_Timer_server_Schedule_operation_method+0xa8><== NEVER TAKEN
40018a28: 86 10 20 00 clr %g3
delta_interval -= delta;
40018a2c: 86 21 00 02 sub %g4, %g2, %g3
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
40018a30: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
}
ts->TOD_watchdogs.last_snapshot = snapshot;
40018a34: d2 26 20 74 st %o1, [ %i0 + 0x74 ]
_ISR_Enable( level );
40018a38: 7f ff da e5 call 4000f5cc <sparc_enable_interrupts>
40018a3c: 90 10 00 1c mov %i4, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
40018a40: 90 06 20 68 add %i0, 0x68, %o0
40018a44: 40 00 12 a9 call 4001d4e8 <_Watchdog_Insert>
40018a48: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
40018a4c: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
40018a50: 80 a0 60 00 cmp %g1, 0
40018a54: 12 bf ff df bne 400189d0 <_Timer_server_Schedule_operation_method+0x48>
40018a58: 01 00 00 00 nop
_Timer_server_Reset_tod_system_watchdog( ts );
40018a5c: 7f ff ff b7 call 40018938 <_Timer_server_Reset_tod_system_watchdog>
40018a60: 90 10 00 18 mov %i0, %o0
}
}
_Thread_Enable_dispatch();
40018a64: 40 00 0e eb call 4001c610 <_Thread_Enable_dispatch>
40018a68: 81 e8 00 00 restore
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
40018a6c: 7f ff da d4 call 4000f5bc <sparc_disable_interrupts>
40018a70: 01 00 00 00 nop
snapshot = _Watchdog_Ticks_since_boot;
40018a74: 05 10 00 fa sethi %hi(0x4003e800), %g2
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
40018a78: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
40018a7c: c4 00 a1 48 ld [ %g2 + 0x148 ], %g2
last_snapshot = ts->Interval_watchdogs.last_snapshot;
40018a80: 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 );
40018a84: 86 06 20 34 add %i0, 0x34, %g3
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
40018a88: 80 a0 40 03 cmp %g1, %g3
40018a8c: 02 80 00 08 be 40018aac <_Timer_server_Schedule_operation_method+0x124>
40018a90: 88 20 80 04 sub %g2, %g4, %g4
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
40018a94: f8 00 60 10 ld [ %g1 + 0x10 ], %i4
if (delta_interval > delta) {
40018a98: 80 a1 00 1c cmp %g4, %i4
40018a9c: 1a 80 00 03 bcc 40018aa8 <_Timer_server_Schedule_operation_method+0x120>
40018aa0: 86 10 20 00 clr %g3
delta_interval -= delta;
40018aa4: 86 27 00 04 sub %i4, %g4, %g3
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
40018aa8: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
}
ts->Interval_watchdogs.last_snapshot = snapshot;
40018aac: c4 26 20 3c st %g2, [ %i0 + 0x3c ]
_ISR_Enable( level );
40018ab0: 7f ff da c7 call 4000f5cc <sparc_enable_interrupts>
40018ab4: 01 00 00 00 nop
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
40018ab8: 90 06 20 30 add %i0, 0x30, %o0
40018abc: 40 00 12 8b call 4001d4e8 <_Watchdog_Insert>
40018ac0: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
40018ac4: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
40018ac8: 80 a0 60 00 cmp %g1, 0
40018acc: 12 bf ff c1 bne 400189d0 <_Timer_server_Schedule_operation_method+0x48>
40018ad0: 01 00 00 00 nop
_Timer_server_Reset_interval_system_watchdog( ts );
40018ad4: 7f ff ff 85 call 400188e8 <_Timer_server_Reset_interval_system_watchdog>
40018ad8: 90 10 00 18 mov %i0, %o0
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
40018adc: 40 00 0e cd call 4001c610 <_Thread_Enable_dispatch>
40018ae0: 81 e8 00 00 restore
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
40018ae4: 84 01 00 02 add %g4, %g2, %g2
delta_interval += delta;
40018ae8: 10 bf ff d2 b 40018a30 <_Timer_server_Schedule_operation_method+0xa8>
40018aec: 86 20 80 09 sub %g2, %o1, %g3
4000d698 <_Timespec_Add_to>:
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
4000d698: d8 02 00 00 ld [ %o0 ], %o4
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
uint32_t seconds = add->tv_sec;
4000d69c: c4 02 40 00 ld [ %o1 ], %g2
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
4000d6a0: c6 02 20 04 ld [ %o0 + 4 ], %g3
4000d6a4: c2 02 60 04 ld [ %o1 + 4 ], %g1
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
4000d6a8: 98 03 00 02 add %o4, %g2, %o4
time->tv_nsec += add->tv_nsec;
4000d6ac: 82 00 c0 01 add %g3, %g1, %g1
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
4000d6b0: d8 22 00 00 st %o4, [ %o0 ]
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
4000d6b4: 09 0e e6 b2 sethi %hi(0x3b9ac800), %g4
4000d6b8: 88 11 21 ff or %g4, 0x1ff, %g4 ! 3b9ac9ff <RAM_SIZE+0x3b5ac9ff>
4000d6bc: 80 a0 40 04 cmp %g1, %g4
4000d6c0: 08 80 00 0d bleu 4000d6f4 <_Timespec_Add_to+0x5c>
4000d6c4: c2 22 20 04 st %g1, [ %o0 + 4 ]
4000d6c8: 98 03 20 01 inc %o4
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
4000d6cc: 1b 31 19 4d sethi %hi(0xc4653400), %o5
#include <sys/types.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
uint32_t _Timespec_Add_to(
4000d6d0: 98 23 00 02 sub %o4, %g2, %o4
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
4000d6d4: 9a 13 62 00 or %o5, 0x200, %o5
4000d6d8: 82 00 40 0d add %g1, %o5, %g1
#include <sys/types.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
uint32_t _Timespec_Add_to(
4000d6dc: 86 03 00 02 add %o4, %g2, %g3
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
4000d6e0: 80 a0 40 04 cmp %g1, %g4
4000d6e4: 18 bf ff fd bgu 4000d6d8 <_Timespec_Add_to+0x40> <== NEVER TAKEN
4000d6e8: 84 00 a0 01 inc %g2
4000d6ec: c2 22 20 04 st %g1, [ %o0 + 4 ]
4000d6f0: c6 22 00 00 st %g3, [ %o0 ]
time->tv_sec++;
seconds++;
}
return seconds;
}
4000d6f4: 81 c3 e0 08 retl
4000d6f8: 90 10 00 02 mov %g2, %o0
4000d430 <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
4000d430: 9d e3 bf a0 save %sp, -96, %sp
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
4000d434: d4 1e 40 00 ldd [ %i1 ], %o2
4000d438: 80 92 80 0b orcc %o2, %o3, %g0
4000d43c: 22 80 00 2f be,a 4000d4f8 <_Timestamp64_Divide+0xc8> <== NEVER TAKEN
4000d440: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
* This looks odd but gives the results the proper precision.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
4000d444: e0 1e 00 00 ldd [ %i0 ], %l0
4000d448: 83 2c 20 02 sll %l0, 2, %g1
4000d44c: 89 34 60 1e srl %l1, 0x1e, %g4
4000d450: 87 2c 60 02 sll %l1, 2, %g3
4000d454: 84 11 00 01 or %g4, %g1, %g2
4000d458: 83 30 e0 1b srl %g3, 0x1b, %g1
4000d45c: 9b 28 e0 05 sll %g3, 5, %o5
4000d460: 99 28 a0 05 sll %g2, 5, %o4
4000d464: 86 a3 40 03 subcc %o5, %g3, %g3
4000d468: 98 10 40 0c or %g1, %o4, %o4
4000d46c: 84 63 00 02 subx %o4, %g2, %g2
4000d470: 92 80 c0 11 addcc %g3, %l1, %o1
4000d474: 83 32 60 1e srl %o1, 0x1e, %g1
4000d478: 90 40 80 10 addx %g2, %l0, %o0
4000d47c: b3 2a 60 02 sll %o1, 2, %i1
4000d480: b1 2a 20 02 sll %o0, 2, %i0
4000d484: 86 82 40 19 addcc %o1, %i1, %g3
4000d488: b0 10 40 18 or %g1, %i0, %i0
4000d48c: 83 30 e0 1e srl %g3, 0x1e, %g1
4000d490: 84 42 00 18 addx %o0, %i0, %g2
4000d494: bb 28 e0 02 sll %g3, 2, %i5
4000d498: b9 28 a0 02 sll %g2, 2, %i4
4000d49c: 92 80 c0 1d addcc %g3, %i5, %o1
4000d4a0: b8 10 40 1c or %g1, %i4, %i4
4000d4a4: 87 32 60 1b srl %o1, 0x1b, %g3
4000d4a8: 90 40 80 1c addx %g2, %i4, %o0
4000d4ac: 83 2a 60 05 sll %o1, 5, %g1
4000d4b0: 85 2a 20 05 sll %o0, 5, %g2
4000d4b4: 92 10 00 01 mov %g1, %o1
4000d4b8: 40 00 3b 32 call 4001c180 <__divdi3>
4000d4bc: 90 10 c0 02 or %g3, %g2, %o0
*_ival_percentage = answer / 1000;
4000d4c0: 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;
4000d4c4: b8 10 00 08 mov %o0, %i4
4000d4c8: ba 10 00 09 mov %o1, %i5
*_ival_percentage = answer / 1000;
4000d4cc: 40 00 3b 2d call 4001c180 <__divdi3>
4000d4d0: 96 10 23 e8 mov 0x3e8, %o3
*_fval_percentage = answer % 1000;
4000d4d4: 90 10 00 1c mov %i4, %o0
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
4000d4d8: d2 26 80 00 st %o1, [ %i2 ]
*_fval_percentage = answer % 1000;
4000d4dc: 94 10 20 00 clr %o2
4000d4e0: 96 10 23 e8 mov 0x3e8, %o3
4000d4e4: 40 00 3c 12 call 4001c52c <__moddi3>
4000d4e8: 92 10 00 1d mov %i5, %o1
4000d4ec: d2 26 c0 00 st %o1, [ %i3 ]
4000d4f0: 81 c7 e0 08 ret
4000d4f4: 81 e8 00 00 restore
{
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
*_ival_percentage = 0;
*_fval_percentage = 0;
4000d4f8: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
return;
4000d4fc: 81 c7 e0 08 ret <== NOT EXECUTED
4000d500: 81 e8 00 00 restore <== NOT EXECUTED
4000bd78 <_User_extensions_Handler_initialization>:
}
}
void _User_extensions_Handler_initialization(void)
{
4000bd78: 9d e3 bf 98 save %sp, -104, %sp
uint32_t number_of_initial_extensions =
4000bd7c: 03 10 00 75 sethi %hi(0x4001d400), %g1
4000bd80: c2 00 62 58 ld [ %g1 + 0x258 ], %g1 ! 4001d658 <Configuration+0x40>
rtems_configuration_get_number_of_initial_extensions();
if ( number_of_initial_extensions > 0 ) {
4000bd84: 80 a0 60 00 cmp %g1, 0
4000bd88: 02 80 00 0a be 4000bdb0 <_User_extensions_Handler_initialization+0x38><== NEVER TAKEN
4000bd8c: 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 )
4000bd90: 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 =
4000bd94: 40 00 01 2c call 4000c244 <_Workspace_Allocate_or_fatal_error>
4000bd98: 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 );
4000bd9c: 13 10 00 2f sethi %hi(0x4000bc00), %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 };
4000bda0: d0 27 bf fc st %o0, [ %fp + -4 ]
_User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
4000bda4: 92 12 61 34 or %o1, 0x134, %o1
4000bda8: 7f ff ff c0 call 4000bca8 <_User_extensions_Iterate>
4000bdac: 90 07 bf fc add %fp, -4, %o0
4000bdb0: 81 c7 e0 08 ret
4000bdb4: 81 e8 00 00 restore
4000bca8 <_User_extensions_Iterate>:
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor
)
{
4000bca8: 9d e3 bf a0 save %sp, -96, %sp
Thread_Control *executing = _Thread_Executing;
const User_extensions_Table *callouts_current =
4000bcac: 03 10 00 75 sethi %hi(0x4001d400), %g1
4000bcb0: 82 10 62 18 or %g1, 0x218, %g1 ! 4001d618 <Configuration>
4000bcb4: fa 00 60 44 ld [ %g1 + 0x44 ], %i5
rtems_configuration_get_user_extension_table();
const User_extensions_Table *callouts_end =
callouts_current + rtems_configuration_get_number_of_initial_extensions();
4000bcb8: f6 00 60 40 ld [ %g1 + 0x40 ], %i3
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor
)
{
Thread_Control *executing = _Thread_Executing;
4000bcbc: 03 10 00 81 sethi %hi(0x40020400), %g1
const User_extensions_Table *callouts_current =
rtems_configuration_get_user_extension_table();
const User_extensions_Table *callouts_end =
callouts_current + rtems_configuration_get_number_of_initial_extensions();
4000bcc0: b7 2e e0 05 sll %i3, 5, %i3
)
{
Thread_Control *executing = _Thread_Executing;
const User_extensions_Table *callouts_current =
rtems_configuration_get_user_extension_table();
const User_extensions_Table *callouts_end =
4000bcc4: b6 07 40 1b add %i5, %i3, %i3
callouts_current + rtems_configuration_get_number_of_initial_extensions();
const Chain_Node *node;
const Chain_Node *tail;
while ( callouts_current != callouts_end ) {
4000bcc8: 80 a7 40 1b cmp %i5, %i3
4000bccc: 02 80 00 0a be 4000bcf4 <_User_extensions_Iterate+0x4c> <== NEVER TAKEN
4000bcd0: f8 00 63 d0 ld [ %g1 + 0x3d0 ], %i4
(*visitor)( executing, arg, callouts_current );
4000bcd4: 94 10 00 1d mov %i5, %o2
4000bcd8: 90 10 00 1c mov %i4, %o0
4000bcdc: 9f c6 40 00 call %i1
4000bce0: 92 10 00 18 mov %i0, %o1
++callouts_current;
4000bce4: ba 07 60 20 add %i5, 0x20, %i5
const User_extensions_Table *callouts_end =
callouts_current + rtems_configuration_get_number_of_initial_extensions();
const Chain_Node *node;
const Chain_Node *tail;
while ( callouts_current != callouts_end ) {
4000bce8: 80 a6 c0 1d cmp %i3, %i5
4000bcec: 12 bf ff fb bne 4000bcd8 <_User_extensions_Iterate+0x30>
4000bcf0: 94 10 00 1d mov %i5, %o2
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000bcf4: 37 10 00 7d sethi %hi(0x4001f400), %i3
4000bcf8: fa 06 e2 84 ld [ %i3 + 0x284 ], %i5 ! 4001f684 <_User_extensions_List>
4000bcfc: b6 16 e2 84 or %i3, 0x284, %i3
++callouts_current;
}
node = _Chain_Immutable_first( &_User_extensions_List );
tail = _Chain_Immutable_tail( &_User_extensions_List );
while ( node != tail ) {
4000bd00: b6 06 e0 04 add %i3, 4, %i3
4000bd04: 80 a7 40 1b cmp %i5, %i3
4000bd08: 02 80 00 09 be 4000bd2c <_User_extensions_Iterate+0x84>
4000bd0c: 94 07 60 14 add %i5, 0x14, %o2
const User_extensions_Control *extension =
(const User_extensions_Control *) node;
(*visitor)( executing, arg, &extension->Callouts );
4000bd10: 90 10 00 1c mov %i4, %o0
4000bd14: 9f c6 40 00 call %i1
4000bd18: 92 10 00 18 mov %i0, %o1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(
const Chain_Node *the_node
)
{
return the_node->next;
4000bd1c: fa 07 40 00 ld [ %i5 ], %i5
++callouts_current;
}
node = _Chain_Immutable_first( &_User_extensions_List );
tail = _Chain_Immutable_tail( &_User_extensions_List );
while ( node != tail ) {
4000bd20: 80 a7 40 1b cmp %i5, %i3
4000bd24: 12 bf ff fb bne 4000bd10 <_User_extensions_Iterate+0x68>
4000bd28: 94 07 60 14 add %i5, 0x14, %o2
4000bd2c: 81 c7 e0 08 ret
4000bd30: 81 e8 00 00 restore
4000d77c <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
4000d77c: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
_ISR_Disable( level );
4000d780: 7f ff d6 a2 call 40003208 <sparc_disable_interrupts>
4000d784: 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;
4000d788: 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 );
4000d78c: 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 ) ) {
4000d790: 80 a0 40 1c cmp %g1, %i4
4000d794: 02 80 00 1f be 4000d810 <_Watchdog_Adjust+0x94>
4000d798: 80 a6 60 00 cmp %i1, 0
switch ( direction ) {
4000d79c: 12 80 00 1f bne 4000d818 <_Watchdog_Adjust+0x9c>
4000d7a0: 80 a6 60 01 cmp %i1, 1
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
4000d7a4: 80 a6 a0 00 cmp %i2, 0
4000d7a8: 02 80 00 1a be 4000d810 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
4000d7ac: 01 00 00 00 nop
if ( units < _Watchdog_First( header )->delta_interval ) {
4000d7b0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000d7b4: 80 a6 80 02 cmp %i2, %g2
4000d7b8: 1a 80 00 0a bcc 4000d7e0 <_Watchdog_Adjust+0x64> <== ALWAYS TAKEN
4000d7bc: b6 10 20 01 mov 1, %i3
_Watchdog_First( header )->delta_interval -= units;
4000d7c0: 10 80 00 1d b 4000d834 <_Watchdog_Adjust+0xb8> <== NOT EXECUTED
4000d7c4: 84 20 80 1a sub %g2, %i2, %g2 <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
4000d7c8: 02 80 00 12 be 4000d810 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
4000d7cc: 01 00 00 00 nop
if ( units < _Watchdog_First( header )->delta_interval ) {
4000d7d0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000d7d4: 80 a0 80 1a cmp %g2, %i2
4000d7d8: 38 80 00 17 bgu,a 4000d834 <_Watchdog_Adjust+0xb8>
4000d7dc: 84 20 80 1a sub %g2, %i2, %g2
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
4000d7e0: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
4000d7e4: b4 26 80 02 sub %i2, %g2, %i2
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
4000d7e8: 7f ff d6 8c call 40003218 <sparc_enable_interrupts>
4000d7ec: 01 00 00 00 nop
_Watchdog_Tickle( header );
4000d7f0: 40 00 00 a8 call 4000da90 <_Watchdog_Tickle>
4000d7f4: 90 10 00 18 mov %i0, %o0
_ISR_Disable( level );
4000d7f8: 7f ff d6 84 call 40003208 <sparc_disable_interrupts>
4000d7fc: 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;
4000d800: c2 06 00 00 ld [ %i0 ], %g1
if ( _Chain_Is_empty( header ) )
4000d804: 80 a7 00 01 cmp %i4, %g1
4000d808: 12 bf ff f0 bne 4000d7c8 <_Watchdog_Adjust+0x4c>
4000d80c: 80 a6 a0 00 cmp %i2, 0
}
break;
}
}
_ISR_Enable( level );
4000d810: 7f ff d6 82 call 40003218 <sparc_enable_interrupts>
4000d814: 91 e8 00 08 restore %g0, %o0, %o0
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
4000d818: 12 bf ff fe bne 4000d810 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
4000d81c: 01 00 00 00 nop
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
4000d820: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000d824: b4 00 80 1a add %g2, %i2, %i2
4000d828: f4 20 60 10 st %i2, [ %g1 + 0x10 ]
}
break;
}
}
_ISR_Enable( level );
4000d82c: 7f ff d6 7b call 40003218 <sparc_enable_interrupts>
4000d830: 91 e8 00 08 restore %g0, %o0, %o0
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
4000d834: 10 bf ff f7 b 4000d810 <_Watchdog_Adjust+0x94>
4000d838: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
4001d438 <_Watchdog_Adjust_to_chain>:
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
4001d438: 9d e3 bf a0 save %sp, -96, %sp
Watchdog_Interval units = units_arg;
ISR_Level level;
Watchdog_Control *first;
_ISR_Disable( level );
4001d43c: 7f ff c8 60 call 4000f5bc <sparc_disable_interrupts>
4001d440: 01 00 00 00 nop
4001d444: c2 06 00 00 ld [ %i0 ], %g1
4001d448: ba 06 20 04 add %i0, 4, %i5
4001d44c: b8 06 a0 04 add %i2, 4, %i4
while ( 1 ) {
if ( _Chain_Is_empty( header ) ) {
4001d450: 80 a7 40 01 cmp %i5, %g1
4001d454: 02 80 00 20 be 4001d4d4 <_Watchdog_Adjust_to_chain+0x9c>
4001d458: 01 00 00 00 nop
/*
* If it is longer than "units" until the first element on the chain
* fires, then bump it and quit.
*/
if ( units < first->delta_interval ) {
4001d45c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001d460: 80 a6 40 02 cmp %i1, %g2
4001d464: 2a 80 00 1e bcs,a 4001d4dc <_Watchdog_Adjust_to_chain+0xa4>
4001d468: 84 20 80 19 sub %g2, %i1, %g2
/*
* The first set happens in less than units, so take all of them
* off the chain and adjust units to reflect this.
*/
units -= first->delta_interval;
4001d46c: b2 26 40 02 sub %i1, %g2, %i1
first->delta_interval = 0;
4001d470: c0 20 60 10 clr [ %g1 + 0x10 ]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4001d474: c4 00 60 04 ld [ %g1 + 4 ], %g2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4001d478: c6 00 40 00 ld [ %g1 ], %g3
previous = the_node->previous;
next->previous = previous;
4001d47c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4001d480: c6 20 80 00 st %g3, [ %g2 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4001d484: c4 06 a0 08 ld [ %i2 + 8 ], %g2
the_node->next = tail;
4001d488: f8 20 40 00 st %i4, [ %g1 ]
tail->previous = the_node;
4001d48c: c2 26 a0 08 st %g1, [ %i2 + 8 ]
old_last->next = the_node;
4001d490: c2 20 80 00 st %g1, [ %g2 ]
the_node->previous = old_last;
4001d494: c4 20 60 04 st %g2, [ %g1 + 4 ]
while ( 1 ) {
_Chain_Extract_unprotected( &first->Node );
_Chain_Append_unprotected( to_fire, &first->Node );
_ISR_Flash( level );
4001d498: 7f ff c8 4d call 4000f5cc <sparc_enable_interrupts>
4001d49c: 01 00 00 00 nop
4001d4a0: 7f ff c8 47 call 4000f5bc <sparc_disable_interrupts>
4001d4a4: 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;
4001d4a8: c2 06 00 00 ld [ %i0 ], %g1
if ( _Chain_Is_empty( header ) )
4001d4ac: 80 a7 40 01 cmp %i5, %g1
4001d4b0: 02 bf ff e9 be 4001d454 <_Watchdog_Adjust_to_chain+0x1c>
4001d4b4: 01 00 00 00 nop
break;
first = _Watchdog_First( header );
if ( first->delta_interval != 0 )
4001d4b8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001d4bc: 80 a0 a0 00 cmp %g2, 0
4001d4c0: 22 bf ff ee be,a 4001d478 <_Watchdog_Adjust_to_chain+0x40>
4001d4c4: c4 00 60 04 ld [ %g1 + 4 ], %g2
Watchdog_Control *first;
_ISR_Disable( level );
while ( 1 ) {
if ( _Chain_Is_empty( header ) ) {
4001d4c8: 80 a7 40 01 cmp %i5, %g1
4001d4cc: 12 bf ff e6 bne 4001d464 <_Watchdog_Adjust_to_chain+0x2c> <== ALWAYS TAKEN
4001d4d0: 80 a6 40 02 cmp %i1, %g2
if ( first->delta_interval != 0 )
break;
}
}
_ISR_Enable( level );
4001d4d4: 7f ff c8 3e call 4000f5cc <sparc_enable_interrupts>
4001d4d8: 91 e8 00 08 restore %g0, %o0, %o0
/*
* If it is longer than "units" until the first element on the chain
* fires, then bump it and quit.
*/
if ( units < first->delta_interval ) {
first->delta_interval -= units;
4001d4dc: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if ( first->delta_interval != 0 )
break;
}
}
_ISR_Enable( level );
4001d4e0: 7f ff c8 3b call 4000f5cc <sparc_enable_interrupts>
4001d4e4: 91 e8 00 08 restore %g0, %o0, %o0
4000bf34 <_Watchdog_Remove>:
#include <rtems/score/watchdog.h>
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
4000bf34: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
4000bf38: 7f ff d9 66 call 400024d0 <sparc_disable_interrupts>
4000bf3c: 01 00 00 00 nop
previous_state = the_watchdog->state;
4000bf40: fa 06 20 08 ld [ %i0 + 8 ], %i5
switch ( previous_state ) {
4000bf44: 80 a7 60 01 cmp %i5, 1
4000bf48: 02 80 00 2a be 4000bff0 <_Watchdog_Remove+0xbc>
4000bf4c: 03 10 00 80 sethi %hi(0x40020000), %g1
4000bf50: 1a 80 00 09 bcc 4000bf74 <_Watchdog_Remove+0x40>
4000bf54: 80 a7 60 03 cmp %i5, 3
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
4000bf58: 03 10 00 80 sethi %hi(0x40020000), %g1
4000bf5c: c2 00 63 98 ld [ %g1 + 0x398 ], %g1 ! 40020398 <_Watchdog_Ticks_since_boot>
4000bf60: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
_ISR_Enable( level );
4000bf64: 7f ff d9 5f call 400024e0 <sparc_enable_interrupts>
4000bf68: b0 10 00 1d mov %i5, %i0
return( previous_state );
}
4000bf6c: 81 c7 e0 08 ret
4000bf70: 81 e8 00 00 restore
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
4000bf74: 18 bf ff fa bgu 4000bf5c <_Watchdog_Remove+0x28> <== NEVER TAKEN
4000bf78: 03 10 00 80 sethi %hi(0x40020000), %g1
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
Watchdog_Control *the_watchdog
)
{
return ( (Watchdog_Control *) the_watchdog->Node.next );
4000bf7c: c2 06 00 00 ld [ %i0 ], %g1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
4000bf80: c0 26 20 08 clr [ %i0 + 8 ]
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
4000bf84: c4 00 40 00 ld [ %g1 ], %g2
4000bf88: 80 a0 a0 00 cmp %g2, 0
4000bf8c: 02 80 00 07 be 4000bfa8 <_Watchdog_Remove+0x74>
4000bf90: 05 10 00 80 sethi %hi(0x40020000), %g2
next_watchdog->delta_interval += the_watchdog->delta_interval;
4000bf94: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
4000bf98: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
4000bf9c: 84 00 c0 02 add %g3, %g2, %g2
4000bfa0: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if ( _Watchdog_Sync_count )
4000bfa4: 05 10 00 80 sethi %hi(0x40020000), %g2
4000bfa8: c4 00 a3 94 ld [ %g2 + 0x394 ], %g2 ! 40020394 <_Watchdog_Sync_count>
4000bfac: 80 a0 a0 00 cmp %g2, 0
4000bfb0: 22 80 00 07 be,a 4000bfcc <_Watchdog_Remove+0x98>
4000bfb4: c4 06 20 04 ld [ %i0 + 4 ], %g2
_Watchdog_Sync_level = _ISR_Nest_level;
4000bfb8: 05 10 00 81 sethi %hi(0x40020400), %g2
4000bfbc: c6 00 a3 c8 ld [ %g2 + 0x3c8 ], %g3 ! 400207c8 <_Per_CPU_Information+0x8>
4000bfc0: 05 10 00 80 sethi %hi(0x40020000), %g2
4000bfc4: c6 20 a3 34 st %g3, [ %g2 + 0x334 ] ! 40020334 <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000bfc8: c4 06 20 04 ld [ %i0 + 4 ], %g2
next->previous = previous;
4000bfcc: c4 20 60 04 st %g2, [ %g1 + 4 ]
previous->next = next;
4000bfd0: c2 20 80 00 st %g1, [ %g2 ]
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
4000bfd4: 03 10 00 80 sethi %hi(0x40020000), %g1
4000bfd8: c2 00 63 98 ld [ %g1 + 0x398 ], %g1 ! 40020398 <_Watchdog_Ticks_since_boot>
4000bfdc: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
_ISR_Enable( level );
4000bfe0: 7f ff d9 40 call 400024e0 <sparc_enable_interrupts>
4000bfe4: b0 10 00 1d mov %i5, %i0
return( previous_state );
}
4000bfe8: 81 c7 e0 08 ret
4000bfec: 81 e8 00 00 restore
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
4000bff0: c2 00 63 98 ld [ %g1 + 0x398 ], %g1
/*
* It is not actually on the chain so just change the state and
* the Insert operation we interrupted will be aborted.
*/
the_watchdog->state = WATCHDOG_INACTIVE;
4000bff4: c0 26 20 08 clr [ %i0 + 8 ]
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
4000bff8: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
_ISR_Enable( level );
4000bffc: 7f ff d9 39 call 400024e0 <sparc_enable_interrupts>
4000c000: b0 10 00 1d mov %i5, %i0
return( previous_state );
}
4000c004: 81 c7 e0 08 ret
4000c008: 81 e8 00 00 restore
4000d1bc <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
4000d1bc: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
4000d1c0: 7f ff d7 10 call 40002e00 <sparc_disable_interrupts>
4000d1c4: 01 00 00 00 nop
4000d1c8: b6 10 00 08 mov %o0, %i3
printk( "Watchdog Chain: %s %p\n", name, header );
4000d1cc: 11 10 00 80 sethi %hi(0x40020000), %o0
4000d1d0: 94 10 00 19 mov %i1, %o2
4000d1d4: 92 10 00 18 mov %i0, %o1
4000d1d8: 7f ff e1 fa call 400059c0 <printk>
4000d1dc: 90 12 22 38 or %o0, 0x238, %o0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000d1e0: 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 );
4000d1e4: b2 06 60 04 add %i1, 4, %i1
if ( !_Chain_Is_empty( header ) ) {
4000d1e8: 80 a7 40 19 cmp %i5, %i1
4000d1ec: 02 80 00 0f be 4000d228 <_Watchdog_Report_chain+0x6c>
4000d1f0: 11 10 00 80 sethi %hi(0x40020000), %o0
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
4000d1f4: 92 10 00 1d mov %i5, %o1
4000d1f8: 40 00 00 0f call 4000d234 <_Watchdog_Report>
4000d1fc: 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 )
4000d200: 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 ) ;
4000d204: 80 a7 40 19 cmp %i5, %i1
4000d208: 12 bf ff fc bne 4000d1f8 <_Watchdog_Report_chain+0x3c> <== NEVER TAKEN
4000d20c: 92 10 00 1d mov %i5, %o1
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
4000d210: 11 10 00 80 sethi %hi(0x40020000), %o0
4000d214: 92 10 00 18 mov %i0, %o1
4000d218: 7f ff e1 ea call 400059c0 <printk>
4000d21c: 90 12 22 50 or %o0, 0x250, %o0
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
4000d220: 7f ff d6 fc call 40002e10 <sparc_enable_interrupts>
4000d224: 91 e8 00 1b restore %g0, %i3, %o0
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
4000d228: 7f ff e1 e6 call 400059c0 <printk>
4000d22c: 90 12 22 60 or %o0, 0x260, %o0
4000d230: 30 bf ff fc b,a 4000d220 <_Watchdog_Report_chain+0x64>
4000c00c <_Watchdog_Tickle>:
#include <rtems/score/watchdog.h>
void _Watchdog_Tickle(
Chain_Control *header
)
{
4000c00c: 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 );
4000c010: 7f ff d9 30 call 400024d0 <sparc_disable_interrupts>
4000c014: 01 00 00 00 nop
4000c018: b8 10 00 08 mov %o0, %i4
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000c01c: 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 );
4000c020: b4 06 20 04 add %i0, 4, %i2
if ( _Chain_Is_empty( header ) )
4000c024: 80 a7 40 1a cmp %i5, %i2
4000c028: 02 80 00 09 be 4000c04c <_Watchdog_Tickle+0x40>
4000c02c: 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) {
4000c030: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000c034: 80 a0 60 00 cmp %g1, 0
4000c038: 02 80 00 15 be 4000c08c <_Watchdog_Tickle+0x80> <== NEVER TAKEN
4000c03c: 82 00 7f ff add %g1, -1, %g1
the_watchdog->delta_interval--;
if ( the_watchdog->delta_interval != 0 )
4000c040: 80 a0 60 00 cmp %g1, 0
4000c044: 02 80 00 12 be 4000c08c <_Watchdog_Tickle+0x80>
4000c048: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
4000c04c: 7f ff d9 25 call 400024e0 <sparc_enable_interrupts>
4000c050: 91 e8 00 1c restore %g0, %i4, %o0
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
4000c054: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000c058: 9f c0 40 00 call %g1
4000c05c: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
4000c060: 7f ff d9 1c call 400024d0 <sparc_disable_interrupts>
4000c064: 01 00 00 00 nop
4000c068: b8 10 00 08 mov %o0, %i4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000c06c: fa 06 00 00 ld [ %i0 ], %i5
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
4000c070: 80 a6 80 1d cmp %i2, %i5
4000c074: 02 bf ff f6 be 4000c04c <_Watchdog_Tickle+0x40>
4000c078: 01 00 00 00 nop
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
4000c07c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000c080: 80 a0 60 00 cmp %g1, 0
4000c084: 12 bf ff f2 bne 4000c04c <_Watchdog_Tickle+0x40>
4000c088: 01 00 00 00 nop
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
4000c08c: 7f ff ff aa call 4000bf34 <_Watchdog_Remove>
4000c090: 90 10 00 1d mov %i5, %o0
4000c094: b6 10 00 08 mov %o0, %i3
_ISR_Enable( level );
4000c098: 7f ff d9 12 call 400024e0 <sparc_enable_interrupts>
4000c09c: 90 10 00 1c mov %i4, %o0
switch( watchdog_state ) {
4000c0a0: 80 a6 e0 02 cmp %i3, 2
4000c0a4: 12 bf ff ef bne 4000c060 <_Watchdog_Tickle+0x54>
4000c0a8: 01 00 00 00 nop
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
4000c0ac: 10 bf ff ea b 4000c054 <_Watchdog_Tickle+0x48>
4000c0b0: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
4000c0b4 <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
4000c0b4: 9d e3 bf 98 save %sp, -104, %sp
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t remaining = rtems_configuration_get_work_space_size();
4000c0b8: 05 10 00 75 sethi %hi(0x4001d400), %g2
4000c0bc: 82 10 a2 18 or %g2, 0x218, %g1 ! 4001d618 <Configuration>
4000c0c0: c6 08 60 32 ldub [ %g1 + 0x32 ], %g3
4000c0c4: f6 00 a2 18 ld [ %g2 + 0x218 ], %i3
4000c0c8: 80 a0 e0 00 cmp %g3, 0
4000c0cc: 12 80 00 03 bne 4000c0d8 <_Workspace_Handler_initialization+0x24>
4000c0d0: 84 10 20 00 clr %g2
4000c0d4: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000c0d8: b6 00 80 1b add %g2, %i3, %i3
bool do_zero = rtems_configuration_get_do_zero_of_workspace();
4000c0dc: c4 08 60 30 ldub [ %g1 + 0x30 ], %g2
bool unified = rtems_configuration_get_unified_work_area();
4000c0e0: c2 08 60 31 ldub [ %g1 + 0x31 ], %g1
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t remaining = rtems_configuration_get_work_space_size();
bool do_zero = rtems_configuration_get_do_zero_of_workspace();
4000c0e4: c4 2f bf ff stb %g2, [ %fp + -1 ]
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
4000c0e8: 80 a6 60 00 cmp %i1, 0
4000c0ec: 02 80 00 3c be 4000c1dc <_Workspace_Handler_initialization+0x128><== NEVER TAKEN
4000c0f0: c2 2f bf fe stb %g1, [ %fp + -2 ]
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
4000c0f4: 23 10 00 26 sethi %hi(0x40009800), %l1
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000c0f8: 27 10 00 80 sethi %hi(0x40020000), %l3
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
4000c0fc: b8 10 20 00 clr %i4
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
4000c100: a2 14 60 98 or %l1, 0x98, %l1
4000c104: a0 08 a0 ff and %g2, 0xff, %l0
if ( area->size > overhead ) {
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
4000c108: a4 08 60 ff and %g1, 0xff, %l2
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000c10c: 10 80 00 22 b 4000c194 <_Workspace_Handler_initialization+0xe0>
4000c110: a6 14 e2 c0 or %l3, 0x2c0, %l3
if ( do_zero ) {
memset( area->begin, 0, area->size );
}
if ( area->size > overhead ) {
4000c114: 80 a7 60 16 cmp %i5, 0x16
4000c118: 28 80 00 1c bleu,a 4000c188 <_Workspace_Handler_initialization+0xd4>
4000c11c: b8 07 20 01 inc %i4
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
4000c120: 80 a4 a0 00 cmp %l2, 0
4000c124: 32 80 00 0a bne,a 4000c14c <_Workspace_Handler_initialization+0x98>
4000c128: d2 06 00 00 ld [ %i0 ], %o1
size = area->size;
} else {
if ( remaining > 0 ) {
4000c12c: 80 a6 e0 00 cmp %i3, 0
4000c130: 22 80 00 22 be,a 4000c1b8 <_Workspace_Handler_initialization+0x104><== NEVER TAKEN
4000c134: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
size = remaining < area->size - overhead ?
4000c138: 82 07 7f ea add %i5, -22, %g1
remaining + overhead : area->size;
4000c13c: 80 a0 40 1b cmp %g1, %i3
4000c140: 38 80 00 02 bgu,a 4000c148 <_Workspace_Handler_initialization+0x94><== ALWAYS TAKEN
4000c144: ba 06 e0 16 add %i3, 0x16, %i5
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000c148: d2 06 00 00 ld [ %i0 ], %o1
4000c14c: 94 10 00 1d mov %i5, %o2
4000c150: 90 10 00 13 mov %l3, %o0
4000c154: 9f c4 40 00 call %l1
4000c158: 96 10 20 08 mov 8, %o3
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
4000c15c: c2 06 00 00 ld [ %i0 ], %g1
area->size -= size;
4000c160: c4 06 20 04 ld [ %i0 + 4 ], %g2
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
4000c164: 82 00 40 1d add %g1, %i5, %g1
area->size -= size;
4000c168: ba 20 80 1d sub %g2, %i5, %i5
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
4000c16c: c2 26 00 00 st %g1, [ %i0 ]
area->size -= size;
if ( space_available < remaining ) {
4000c170: 80 a2 00 1b cmp %o0, %i3
4000c174: 1a 80 00 1f bcc 4000c1f0 <_Workspace_Handler_initialization+0x13c><== ALWAYS TAKEN
4000c178: fa 26 20 04 st %i5, [ %i0 + 4 ]
remaining -= space_available;
4000c17c: b6 26 c0 08 sub %i3, %o0, %i3 <== NOT EXECUTED
} else {
remaining = 0;
}
init_or_extend = extend;
4000c180: a2 10 00 1a mov %i2, %l1 <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
4000c184: b8 07 20 01 inc %i4
4000c188: 80 a7 00 19 cmp %i4, %i1
4000c18c: 02 80 00 14 be 4000c1dc <_Workspace_Handler_initialization+0x128><== ALWAYS TAKEN
4000c190: b0 06 20 08 add %i0, 8, %i0
Heap_Area *area = &areas [i];
if ( do_zero ) {
4000c194: 80 a4 20 00 cmp %l0, 0
4000c198: 22 bf ff df be,a 4000c114 <_Workspace_Handler_initialization+0x60>
4000c19c: fa 06 20 04 ld [ %i0 + 4 ], %i5
memset( area->begin, 0, area->size );
4000c1a0: d0 06 00 00 ld [ %i0 ], %o0
4000c1a4: d4 06 20 04 ld [ %i0 + 4 ], %o2
4000c1a8: 40 00 14 74 call 40011378 <memset>
4000c1ac: 92 10 20 00 clr %o1
}
if ( area->size > overhead ) {
4000c1b0: 10 bf ff d9 b 4000c114 <_Workspace_Handler_initialization+0x60>
4000c1b4: fa 06 20 04 ld [ %i0 + 4 ], %i5
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
4000c1b8: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
4000c1bc: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000c1c0: 9f c4 40 00 call %l1 <== NOT EXECUTED
4000c1c4: 96 10 20 08 mov 8, %o3 <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
4000c1c8: b8 07 20 01 inc %i4 <== NOT EXECUTED
remaining -= space_available;
} else {
remaining = 0;
}
init_or_extend = extend;
4000c1cc: a2 10 00 1a mov %i2, %l1 <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
4000c1d0: 80 a7 00 19 cmp %i4, %i1 <== NOT EXECUTED
4000c1d4: 12 bf ff f0 bne 4000c194 <_Workspace_Handler_initialization+0xe0><== NOT EXECUTED
4000c1d8: b0 06 20 08 add %i0, 8, %i0 <== NOT EXECUTED
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
4000c1dc: 80 a6 e0 00 cmp %i3, 0
4000c1e0: 12 80 00 07 bne 4000c1fc <_Workspace_Handler_initialization+0x148>
4000c1e4: 90 10 20 00 clr %o0
4000c1e8: 81 c7 e0 08 ret
4000c1ec: 81 e8 00 00 restore
remaining -= space_available;
} else {
remaining = 0;
}
init_or_extend = extend;
4000c1f0: a2 10 00 1a mov %i2, %l1
area->size -= size;
if ( space_available < remaining ) {
remaining -= space_available;
} else {
remaining = 0;
4000c1f4: 10 bf ff e4 b 4000c184 <_Workspace_Handler_initialization+0xd0>
4000c1f8: b6 10 20 00 clr %i3
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
_Internal_error_Occurred(
4000c1fc: 92 10 20 01 mov 1, %o1
4000c200: 7f ff f6 43 call 40009b0c <_Internal_error_Occurred>
4000c204: 94 10 20 02 mov 2, %o2
4001c6a0 <_calloc_r>:
struct _reent *ignored __attribute__((unused)),
size_t elements,
size_t size
)
{
return calloc( elements, size );
4001c6a0: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
4001c6a4: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
4001c6a8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001c6ac: 7f ff 9e 28 call 40003f4c <calloc> <== NOT EXECUTED
4001c6b0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4001c72c <_close_r>:
int _close_r(
struct _reent *ptr __attribute__((unused)),
int fd
)
{
return close( fd );
4001c72c: 90 10 00 09 mov %o1, %o0
4001c730: 82 13 c0 00 mov %o7, %g1
4001c734: 7f ff ff e0 call 4001c6b4 <close>
4001c738: 9e 10 40 00 mov %g1, %o7
400146d8 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
400146d8: 9d e3 bf 98 save %sp, -104, %sp
400146dc: a0 10 00 18 mov %i0, %l0
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
400146e0: 80 a6 e0 00 cmp %i3, 0
400146e4: 12 80 00 11 bne 40014728 <_fat_block_read+0x50> <== ALWAYS TAKEN
400146e8: b0 10 20 00 clr %i0
400146ec: 30 80 00 19 b,a 40014750 <_fat_block_read+0x78> <== NOT EXECUTED
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
400146f0: fa 14 00 00 lduh [ %l0 ], %i5
memcpy((buff + cmpltd), (sec_buf + ofs), c);
400146f4: d2 07 bf fc ld [ %fp + -4 ], %o1
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
400146f8: ba 27 40 1a sub %i5, %i2, %i5
400146fc: 80 a7 40 1b cmp %i5, %i3
40014700: 08 80 00 03 bleu 4001470c <_fat_block_read+0x34>
40014704: 92 02 40 1a add %o1, %i2, %o1
40014708: ba 10 00 1b mov %i3, %i5
memcpy((buff + cmpltd), (sec_buf + ofs), c);
4001470c: 40 00 26 46 call 4001e024 <memcpy>
40014710: 94 10 00 1d mov %i5, %o2
count -= c;
cmpltd += c;
40014714: b0 07 40 18 add %i5, %i0, %i0
sec_num++;
40014718: b2 06 60 01 inc %i1
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
4001471c: b6 a6 c0 1d subcc %i3, %i5, %i3
40014720: 02 80 00 0c be 40014750 <_fat_block_read+0x78>
40014724: b4 10 20 00 clr %i2
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
40014728: 92 10 00 19 mov %i1, %o1
4001472c: 94 10 20 01 mov 1, %o2
40014730: 96 07 bf fc add %fp, -4, %o3
40014734: 7f ff ff bb call 40014620 <fat_buf_access>
40014738: 90 10 00 10 mov %l0, %o0
if (rc != RC_OK)
4001473c: 80 a2 20 00 cmp %o0, 0
40014740: 02 bf ff ec be 400146f0 <_fat_block_read+0x18> <== ALWAYS TAKEN
40014744: 90 07 00 18 add %i4, %i0, %o0
cmpltd += c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
40014748: 81 c7 e0 08 ret <== NOT EXECUTED
4001474c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
40014750: 81 c7 e0 08 ret
40014754: 81 e8 00 00 restore
40004d24 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
40004d24: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
40004d28: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
40004d2c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40004d30: 7f ff ff e9 call 40004cd4 <lstat> <== NOT EXECUTED
40004d34: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40005118 <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
40005118: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
4000511c: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
40005120: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40005124: 7f ff ff e9 call 400050c8 <stat> <== NOT EXECUTED
40005128: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400080c0 <adjtime>:
*/
int adjtime(
const struct timeval *delta,
struct timeval *olddelta
)
{
400080c0: 9d e3 bf 98 save %sp, -104, %sp
long adjustment;
/*
* Simple validations
*/
if ( !delta )
400080c4: 80 a6 20 00 cmp %i0, 0
400080c8: 02 80 00 8e be 40008300 <adjtime+0x240>
400080cc: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
400080d0: c4 06 20 04 ld [ %i0 + 4 ], %g2
400080d4: 03 00 03 d0 sethi %hi(0xf4000), %g1
400080d8: 82 10 62 3f or %g1, 0x23f, %g1 ! f423f <PROM_START+0xf423f>
400080dc: 80 a0 80 01 cmp %g2, %g1
400080e0: 18 80 00 88 bgu 40008300 <adjtime+0x240>
400080e4: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
400080e8: 22 80 00 06 be,a 40008100 <adjtime+0x40>
400080ec: c2 06 00 00 ld [ %i0 ], %g1
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
400080f0: c0 26 60 04 clr [ %i1 + 4 ]
400080f4: c4 06 20 04 ld [ %i0 + 4 ], %g2
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
olddelta->tv_sec = 0;
400080f8: c0 26 40 00 clr [ %i1 ]
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
400080fc: c2 06 00 00 ld [ %i0 ], %g1
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
40008100: 07 10 00 61 sethi %hi(0x40018400), %g3
40008104: c8 00 e3 4c ld [ %g3 + 0x34c ], %g4 ! 4001874c <Configuration+0xc>
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
40008108: bb 28 60 08 sll %g1, 8, %i5
4000810c: 87 28 60 03 sll %g1, 3, %g3
40008110: 86 27 40 03 sub %i5, %g3, %g3
40008114: bb 28 e0 06 sll %g3, 6, %i5
40008118: 86 27 40 03 sub %i5, %g3, %g3
4000811c: 82 00 c0 01 add %g3, %g1, %g1
40008120: 83 28 60 06 sll %g1, 6, %g1
adjustment += delta->tv_usec;
40008124: 84 00 40 02 add %g1, %g2, %g2
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
40008128: 80 a0 80 04 cmp %g2, %g4
4000812c: 1a 80 00 05 bcc 40008140 <adjtime+0x80>
40008130: 03 10 00 6a sethi %hi(0x4001a800), %g1
return 0;
40008134: 82 10 20 00 clr %g1
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
}
40008138: 81 c7 e0 08 ret
4000813c: 91 e8 00 01 restore %g0, %g1, %o0
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
40008140: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2
++level;
40008144: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40008148: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ]
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
4000814c: 13 10 00 6a sethi %hi(0x4001a800), %o1
40008150: 90 07 bf f8 add %fp, -8, %o0
40008154: 40 00 07 1c call 40009dc4 <_TOD_Get_with_nanoseconds>
40008158: 92 12 63 28 or %o1, 0x328, %o1
4000815c: 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);
40008160: 94 10 20 00 clr %o2
40008164: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40008168: 90 10 00 1c mov %i4, %o0
4000816c: 96 12 e2 00 or %o3, 0x200, %o3
40008170: 40 00 3a 42 call 40016a78 <__divdi3>
40008174: 92 10 00 1d mov %i5, %o1
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
40008178: f6 06 00 00 ld [ %i0 ], %i3
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
4000817c: 94 10 20 00 clr %o2
40008180: b6 06 c0 09 add %i3, %o1, %i3
40008184: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40008188: 90 10 00 1c mov %i4, %o0
4000818c: 96 12 e2 00 or %o3, 0x200, %o3
40008190: 40 00 3b 25 call 40016e24 <__moddi3>
40008194: 92 10 00 1d mov %i5, %o1
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
40008198: c2 06 20 04 ld [ %i0 + 4 ], %g1
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
4000819c: 09 31 19 4d sethi %hi(0xc4653400), %g4
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
400081a0: 87 28 60 07 sll %g1, 7, %g3
400081a4: 85 28 60 02 sll %g1, 2, %g2
400081a8: 84 20 c0 02 sub %g3, %g2, %g2
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
400081ac: 88 11 22 00 or %g4, 0x200, %g4
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
400081b0: 82 00 80 01 add %g2, %g1, %g1
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
400081b4: 07 0e e6 b2 sethi %hi(0x3b9ac800), %g3
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
400081b8: 83 28 60 03 sll %g1, 3, %g1
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
400081bc: 86 10 e1 ff or %g3, 0x1ff, %g3
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
400081c0: 92 02 40 01 add %o1, %g1, %o1
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
400081c4: 80 a2 40 03 cmp %o1, %g3
400081c8: 08 80 00 07 bleu 400081e4 <adjtime+0x124>
400081cc: 84 06 e0 01 add %i3, 1, %g2
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
400081d0: 92 02 40 04 add %o1, %g4, %o1
ts.tv_sec++;
400081d4: b6 10 00 02 mov %g2, %i3
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
400081d8: 80 a2 40 03 cmp %o1, %g3
400081dc: 18 bf ff fd bgu 400081d0 <adjtime+0x110> <== NEVER TAKEN
400081e0: 84 00 a0 01 inc %g2
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
400081e4: 3b 0e e6 b2 sethi %hi(0x3b9ac800), %i5
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
400081e8: 07 31 19 4d sethi %hi(0xc4653400), %g3
400081ec: 82 10 00 09 mov %o1, %g1
int _EXFUN(setitimer, (int __which, const struct itimerval *__value,
struct itimerval *__ovalue));
#if defined(__rtems__)
/* BSD function used by RTEMS code */
int _EXFUN(adjtime,(const struct timeval *, struct timeval *));
400081f0: 84 06 ff ff add %i3, -1, %g2
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
400081f4: ba 17 62 00 or %i5, 0x200, %i5
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
400081f8: 86 10 e2 00 or %g3, 0x200, %g3
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
400081fc: 82 00 40 1d add %g1, %i5, %g1
ts.tv_sec--;
40008200: 88 10 00 02 mov %g2, %g4
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
40008204: 80 a0 40 03 cmp %g1, %g3
40008208: 08 bf ff fd bleu 400081fc <adjtime+0x13c>
4000820c: 84 00 bf ff add %g2, -1, %g2
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
40008210: 85 39 20 1f sra %g4, 0x1f, %g2
40008214: a6 10 00 01 mov %g1, %l3
40008218: a5 38 60 1f sra %g1, 0x1f, %l2
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
4000821c: 83 28 a0 03 sll %g2, 3, %g1
40008220: 86 10 00 04 mov %g4, %g3
40008224: 89 31 20 1d srl %g4, 0x1d, %g4
40008228: bb 28 e0 03 sll %g3, 3, %i5
4000822c: b8 11 00 01 or %g4, %g1, %i4
40008230: 83 37 60 1b srl %i5, 0x1b, %g1
40008234: a9 2f 20 05 sll %i4, 5, %l4
40008238: ab 2f 60 05 sll %i5, 5, %l5
4000823c: a8 10 40 14 or %g1, %l4, %l4
40008240: ba a5 40 1d subcc %l5, %i5, %i5
40008244: 83 37 60 1a srl %i5, 0x1a, %g1
40008248: b8 65 00 1c subx %l4, %i4, %i4
4000824c: a3 2f 60 06 sll %i5, 6, %l1
40008250: a1 2f 20 06 sll %i4, 6, %l0
40008254: ba a4 40 1d subcc %l1, %i5, %i5
40008258: a0 10 40 10 or %g1, %l0, %l0
4000825c: b8 64 00 1c subx %l0, %i4, %i4
40008260: ae 87 40 03 addcc %i5, %g3, %l7
40008264: 83 35 e0 1e srl %l7, 0x1e, %g1
40008268: ac 47 00 02 addx %i4, %g2, %l6
4000826c: 97 2d e0 02 sll %l7, 2, %o3
40008270: 95 2d a0 02 sll %l6, 2, %o2
40008274: 86 85 c0 0b addcc %l7, %o3, %g3
40008278: 94 10 40 0a or %g1, %o2, %o2
4000827c: 9b 28 e0 02 sll %g3, 2, %o5
40008280: 84 45 80 0a addx %l6, %o2, %g2
40008284: 83 30 e0 1e srl %g3, 0x1e, %g1
40008288: ba 80 c0 0d addcc %g3, %o5, %i5
4000828c: 99 28 a0 02 sll %g2, 2, %o4
40008290: b7 2f 60 02 sll %i5, 2, %i3
40008294: 98 10 40 0c or %g1, %o4, %o4
40008298: 83 37 60 1e srl %i5, 0x1e, %g1
4000829c: b8 40 80 0c addx %g2, %o4, %i4
400082a0: 86 87 40 1b addcc %i5, %i3, %g3
400082a4: b5 2f 20 02 sll %i4, 2, %i2
400082a8: bb 30 e0 17 srl %g3, 0x17, %i5
400082ac: b4 10 40 1a or %g1, %i2, %i2
400082b0: 84 47 00 1a addx %i4, %i2, %g2
400082b4: 83 28 e0 09 sll %g3, 9, %g1
400082b8: 89 28 a0 09 sll %g2, 9, %g4
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
400082bc: 90 07 bf f8 add %fp, -8, %o0
400082c0: 84 17 40 04 or %i5, %g4, %g2
400082c4: ba 84 c0 01 addcc %l3, %g1, %i5
400082c8: b8 44 80 02 addx %l2, %g2, %i4
400082cc: 40 00 06 d9 call 40009e30 <_TOD_Set_with_timestamp>
400082d0: f8 3f bf f8 std %i4, [ %fp + -8 ]
ts.tv_sec--;
}
_TOD_Set( &ts );
_Thread_Enable_dispatch();
400082d4: 40 00 0d 7e call 4000b8cc <_Thread_Enable_dispatch>
400082d8: 01 00 00 00 nop
/* set the user's output */
if ( olddelta )
400082dc: 80 a6 60 00 cmp %i1, 0
400082e0: 02 bf ff 95 be 40008134 <adjtime+0x74>
400082e4: 82 10 20 00 clr %g1
*olddelta = *delta;
400082e8: c4 06 00 00 ld [ %i0 ], %g2
400082ec: c4 26 40 00 st %g2, [ %i1 ]
400082f0: c4 06 20 04 ld [ %i0 + 4 ], %g2
400082f4: c4 26 60 04 st %g2, [ %i1 + 4 ]
return 0;
}
400082f8: 81 c7 e0 08 ret
400082fc: 91 e8 00 01 restore %g0, %g1, %o0
*/
if ( !delta )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
40008300: 40 00 23 b0 call 400111c0 <__errno>
40008304: 01 00 00 00 nop
40008308: 84 10 20 16 mov 0x16, %g2 ! 16 <PROM_START+0x16>
4000830c: 82 10 3f ff mov -1, %g1
40008310: 10 bf ff 8a b 40008138 <adjtime+0x78>
40008314: c4 22 00 00 st %g2, [ %o0 ]
400082cc <aio_cancel>:
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
400082cc: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
400082d0: 3b 10 00 68 sethi %hi(0x4001a000), %i5
400082d4: 40 00 04 85 call 400094e8 <pthread_mutex_lock>
400082d8: 90 17 63 cc or %i5, 0x3cc, %o0 ! 4001a3cc <aio_request_queue>
if (fcntl (fildes, F_GETFD) < 0) {
400082dc: 90 10 00 18 mov %i0, %o0
400082e0: 40 00 1b af call 4000f19c <fcntl>
400082e4: 92 10 20 01 mov 1, %o1
400082e8: 80 a2 20 00 cmp %o0, 0
400082ec: 06 80 00 6c bl 4000849c <aio_cancel+0x1d0>
400082f0: 80 a6 60 00 cmp %i1, 0
pthread_mutex_unlock(&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EBADF);
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
400082f4: 02 80 00 3b be 400083e0 <aio_cancel+0x114>
400082f8: 92 10 00 18 mov %i0, %o1
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
400082fc: f8 06 40 00 ld [ %i1 ], %i4
40008300: 80 a7 00 18 cmp %i4, %i0
40008304: 12 80 00 2f bne 400083c0 <aio_cancel+0xf4>
40008308: 90 17 63 cc or %i5, 0x3cc, %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);
4000830c: 92 10 00 1c mov %i4, %o1
40008310: 11 10 00 69 sethi %hi(0x4001a400), %o0
40008314: 94 10 20 00 clr %o2
40008318: 40 00 01 92 call 40008960 <rtems_aio_search_fd>
4000831c: 90 12 20 14 or %o0, 0x14, %o0
if (r_chain == NULL) {
40008320: b6 92 20 00 orcc %o0, 0, %i3
40008324: 22 80 00 0f be,a 40008360 <aio_cancel+0x94>
40008328: b6 17 63 cc or %i5, 0x3cc, %i3
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
4000832c: b8 06 e0 1c add %i3, 0x1c, %i4
40008330: 40 00 04 6e call 400094e8 <pthread_mutex_lock>
40008334: 90 10 00 1c mov %i4, %o0
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
40008338: 92 10 00 19 mov %i1, %o1
4000833c: 40 00 01 d2 call 40008a84 <rtems_aio_remove_req>
40008340: 90 06 e0 08 add %i3, 8, %o0
40008344: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&r_chain->mutex);
40008348: 40 00 04 88 call 40009568 <pthread_mutex_unlock>
4000834c: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40008350: 40 00 04 86 call 40009568 <pthread_mutex_unlock>
40008354: 90 17 63 cc or %i5, 0x3cc, %o0
return result;
}
return AIO_ALLDONE;
}
40008358: 81 c7 e0 08 ret
4000835c: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
40008360: c4 06 e0 54 ld [ %i3 + 0x54 ], %g2
40008364: 82 06 e0 58 add %i3, 0x58, %g1
40008368: 80 a0 80 01 cmp %g2, %g1
4000836c: 02 80 00 0f be 400083a8 <aio_cancel+0xdc> <== NEVER TAKEN
40008370: 90 06 e0 54 add %i3, 0x54, %o0
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
40008374: 92 10 00 1c mov %i4, %o1
40008378: 40 00 01 7a call 40008960 <rtems_aio_search_fd>
4000837c: 94 10 20 00 clr %o2
if (r_chain == NULL) {
40008380: 80 a2 20 00 cmp %o0, 0
40008384: 02 80 00 0e be 400083bc <aio_cancel+0xf0>
40008388: 92 10 00 19 mov %i1, %o1
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
4000838c: 40 00 01 be call 40008a84 <rtems_aio_remove_req>
40008390: 90 02 20 08 add %o0, 8, %o0
40008394: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&aio_request_queue.mutex);
40008398: 40 00 04 74 call 40009568 <pthread_mutex_unlock>
4000839c: 90 10 00 1b mov %i3, %o0
return result;
400083a0: 81 c7 e0 08 ret
400083a4: 81 e8 00 00 restore
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock(&aio_request_queue.mutex);
return AIO_ALLDONE;
400083a8: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock(&aio_request_queue.mutex);
400083ac: 40 00 04 6f call 40009568 <pthread_mutex_unlock>
400083b0: 90 17 63 cc or %i5, 0x3cc, %o0
return AIO_ALLDONE;
400083b4: 81 c7 e0 08 ret
400083b8: 81 e8 00 00 restore
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock (&aio_request_queue.mutex);
400083bc: 90 10 00 1b mov %i3, %o0
400083c0: 40 00 04 6a call 40009568 <pthread_mutex_unlock>
400083c4: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one (EINVAL);
400083c8: 40 00 29 9e call 40012a40 <__errno>
400083cc: 01 00 00 00 nop
400083d0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
400083d4: c2 22 00 00 st %g1, [ %o0 ]
400083d8: 81 c7 e0 08 ret
400083dc: 81 e8 00 00 restore
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
400083e0: 11 10 00 69 sethi %hi(0x4001a400), %o0
400083e4: 94 10 20 00 clr %o2
400083e8: 40 00 01 5e call 40008960 <rtems_aio_search_fd>
400083ec: 90 12 20 14 or %o0, 0x14, %o0
if (r_chain == NULL) {
400083f0: b8 92 20 00 orcc %o0, 0, %i4
400083f4: 02 80 00 0f be 40008430 <aio_cancel+0x164>
400083f8: b6 07 20 1c add %i4, 0x1c, %i3
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
400083fc: 40 00 04 3b call 400094e8 <pthread_mutex_lock>
40008400: 90 10 00 1b mov %i3, %o0
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
40008404: 40 00 0b 28 call 4000b0a4 <_Chain_Extract>
40008408: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
4000840c: 40 00 01 8a call 40008a34 <rtems_aio_remove_fd>
40008410: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&r_chain->mutex);
40008414: 40 00 04 55 call 40009568 <pthread_mutex_unlock>
40008418: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
4000841c: b0 10 20 00 clr %i0
pthread_mutex_lock (&r_chain->mutex);
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
40008420: 40 00 04 52 call 40009568 <pthread_mutex_unlock>
40008424: 90 17 63 cc or %i5, 0x3cc, %o0
return AIO_CANCELED;
40008428: 81 c7 e0 08 ret
4000842c: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
40008430: b8 17 63 cc or %i5, 0x3cc, %i4
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
40008434: c4 07 20 54 ld [ %i4 + 0x54 ], %g2
40008438: 82 07 20 58 add %i4, 0x58, %g1
4000843c: 80 a0 80 01 cmp %g2, %g1
40008440: 02 bf ff da be 400083a8 <aio_cancel+0xdc> <== NEVER TAKEN
40008444: 90 07 20 54 add %i4, 0x54, %o0
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
40008448: 92 10 00 18 mov %i0, %o1
4000844c: 40 00 01 45 call 40008960 <rtems_aio_search_fd>
40008450: 94 10 20 00 clr %o2
if (r_chain == NULL) {
40008454: b6 92 20 00 orcc %o0, 0, %i3
40008458: 22 bf ff d5 be,a 400083ac <aio_cancel+0xe0>
4000845c: b0 10 20 02 mov 2, %i0
40008460: 40 00 0b 11 call 4000b0a4 <_Chain_Extract>
40008464: ba 06 e0 1c add %i3, 0x1c, %i5
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
40008468: 40 00 01 73 call 40008a34 <rtems_aio_remove_fd>
4000846c: 90 10 00 1b mov %i3, %o0
pthread_mutex_destroy (&r_chain->mutex);
40008470: 40 00 03 72 call 40009238 <pthread_mutex_destroy>
40008474: 90 10 00 1d mov %i5, %o0
pthread_cond_destroy (&r_chain->mutex);
40008478: 40 00 02 94 call 40008ec8 <pthread_cond_destroy>
4000847c: 90 10 00 1d mov %i5, %o0
free (r_chain);
40008480: 7f ff f0 17 call 400044dc <free>
40008484: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
40008488: b0 10 20 00 clr %i0
rtems_aio_remove_fd (r_chain);
pthread_mutex_destroy (&r_chain->mutex);
pthread_cond_destroy (&r_chain->mutex);
free (r_chain);
pthread_mutex_unlock (&aio_request_queue.mutex);
4000848c: 40 00 04 37 call 40009568 <pthread_mutex_unlock>
40008490: 90 10 00 1c mov %i4, %o0
return AIO_CANCELED;
40008494: 81 c7 e0 08 ret
40008498: 81 e8 00 00 restore
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
if (fcntl (fildes, F_GETFD) < 0) {
pthread_mutex_unlock(&aio_request_queue.mutex);
4000849c: 40 00 04 33 call 40009568 <pthread_mutex_unlock>
400084a0: 90 17 63 cc or %i5, 0x3cc, %o0
rtems_set_errno_and_return_minus_one (EBADF);
400084a4: 40 00 29 67 call 40012a40 <__errno>
400084a8: b0 10 3f ff mov -1, %i0
400084ac: 82 10 20 09 mov 9, %g1
400084b0: c2 22 00 00 st %g1, [ %o0 ]
400084b4: 81 c7 e0 08 ret
400084b8: 81 e8 00 00 restore
400084c4 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
400084c4: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
400084c8: 03 00 00 08 sethi %hi(0x2000), %g1
400084cc: 80 a6 00 01 cmp %i0, %g1
400084d0: 12 80 00 14 bne 40008520 <aio_fsync+0x5c>
400084d4: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
400084d8: d0 06 40 00 ld [ %i1 ], %o0
400084dc: 40 00 1b 30 call 4000f19c <fcntl>
400084e0: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
400084e4: 90 0a 20 03 and %o0, 3, %o0
400084e8: 90 02 3f ff add %o0, -1, %o0
400084ec: 80 a2 20 01 cmp %o0, 1
400084f0: 18 80 00 0c bgu 40008520 <aio_fsync+0x5c>
400084f4: ba 10 20 09 mov 9, %i5
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
400084f8: 7f ff f1 20 call 40004978 <malloc>
400084fc: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
40008500: 80 a2 20 00 cmp %o0, 0
40008504: 02 80 00 06 be 4000851c <aio_fsync+0x58> <== NEVER TAKEN
40008508: 82 10 20 03 mov 3, %g1
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
4000850c: f2 22 20 14 st %i1, [ %o0 + 0x14 ]
req->aiocbp->aio_lio_opcode = LIO_SYNC;
40008510: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
return rtems_aio_enqueue (req);
40008514: 40 00 01 78 call 40008af4 <rtems_aio_enqueue>
40008518: 91 e8 00 08 restore %g0, %o0, %o0
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
4000851c: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
40008520: 82 10 3f ff mov -1, %g1
40008524: fa 26 60 34 st %i5, [ %i1 + 0x34 ]
40008528: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
4000852c: 40 00 29 45 call 40012a40 <__errno>
40008530: b0 10 3f ff mov -1, %i0
40008534: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
40008538: 81 c7 e0 08 ret
4000853c: 81 e8 00 00 restore
40008cd8 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
40008cd8: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
40008cdc: d0 06 00 00 ld [ %i0 ], %o0
40008ce0: 92 10 20 03 mov 3, %o1
40008ce4: 40 00 19 2e call 4000f19c <fcntl>
40008ce8: ba 10 20 09 mov 9, %i5
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40008cec: 80 8a 20 01 btst 1, %o0
40008cf0: 12 80 00 0b bne 40008d1c <aio_read+0x44>
40008cf4: 82 10 3f ff mov -1, %g1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
40008cf8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40008cfc: 80 a0 60 00 cmp %g1, 0
40008d00: 12 80 00 06 bne 40008d18 <aio_read+0x40>
40008d04: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
40008d08: c2 06 20 08 ld [ %i0 + 8 ], %g1
40008d0c: 80 a0 60 00 cmp %g1, 0
40008d10: 16 80 00 0a bge 40008d38 <aio_read+0x60>
40008d14: 01 00 00 00 nop
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40008d18: 82 10 3f ff mov -1, %g1 ! ffffffff <LEON_REG+0x7fffffff>
40008d1c: fa 26 20 34 st %i5, [ %i0 + 0x34 ]
40008d20: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
40008d24: 40 00 27 47 call 40012a40 <__errno>
40008d28: b0 10 3f ff mov -1, %i0
40008d2c: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
40008d30: 81 c7 e0 08 ret
40008d34: 81 e8 00 00 restore
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
40008d38: 7f ff ef 10 call 40004978 <malloc>
40008d3c: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
40008d40: 80 a2 20 00 cmp %o0, 0
40008d44: 02 80 00 06 be 40008d5c <aio_read+0x84> <== NEVER TAKEN
40008d48: 82 10 20 01 mov 1, %g1
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
40008d4c: f0 22 20 14 st %i0, [ %o0 + 0x14 ]
req->aiocbp->aio_lio_opcode = LIO_READ;
40008d50: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
return rtems_aio_enqueue (req);
40008d54: 7f ff ff 68 call 40008af4 <rtems_aio_enqueue>
40008d58: 91 e8 00 08 restore %g0, %o0, %o0
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40008d5c: 10 bf ff ef b 40008d18 <aio_read+0x40> <== NOT EXECUTED
40008d60: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
40008d6c <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
40008d6c: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
40008d70: d0 06 00 00 ld [ %i0 ], %o0
40008d74: 40 00 19 0a call 4000f19c <fcntl>
40008d78: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40008d7c: 90 0a 20 03 and %o0, 3, %o0
40008d80: 90 02 3f ff add %o0, -1, %o0
40008d84: 80 a2 20 01 cmp %o0, 1
40008d88: 18 80 00 0a bgu 40008db0 <aio_write+0x44>
40008d8c: ba 10 20 09 mov 9, %i5
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
40008d90: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40008d94: 80 a0 60 00 cmp %g1, 0
40008d98: 12 80 00 06 bne 40008db0 <aio_write+0x44>
40008d9c: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
40008da0: c2 06 20 08 ld [ %i0 + 8 ], %g1
40008da4: 80 a0 60 00 cmp %g1, 0
40008da8: 16 80 00 0a bge 40008dd0 <aio_write+0x64>
40008dac: 01 00 00 00 nop
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40008db0: 82 10 3f ff mov -1, %g1 ! ffffffff <LEON_REG+0x7fffffff>
40008db4: fa 26 20 34 st %i5, [ %i0 + 0x34 ]
40008db8: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
40008dbc: 40 00 27 21 call 40012a40 <__errno>
40008dc0: b0 10 3f ff mov -1, %i0
40008dc4: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
40008dc8: 81 c7 e0 08 ret
40008dcc: 81 e8 00 00 restore
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
40008dd0: 7f ff ee ea call 40004978 <malloc>
40008dd4: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
40008dd8: 80 a2 20 00 cmp %o0, 0
40008ddc: 02 80 00 06 be 40008df4 <aio_write+0x88> <== NEVER TAKEN
40008de0: 82 10 20 02 mov 2, %g1
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
40008de4: f0 22 20 14 st %i0, [ %o0 + 0x14 ]
req->aiocbp->aio_lio_opcode = LIO_WRITE;
40008de8: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
return rtems_aio_enqueue (req);
40008dec: 7f ff ff 42 call 40008af4 <rtems_aio_enqueue>
40008df0: 91 e8 00 08 restore %g0, %o0, %o0
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40008df4: 10 bf ff ef b 40008db0 <aio_write+0x44> <== NOT EXECUTED
40008df8: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
4000932c <check_and_merge>:
rtems_rbtree_control *chunk_tree,
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
4000932c: 80 a2 ff f8 cmp %o3, -8
40009330: 02 80 00 23 be 400093bc <check_and_merge+0x90>
40009334: 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);
40009338: c2 02 c0 00 ld [ %o3 ], %g1
4000933c: 80 a0 60 00 cmp %g1, 0
40009340: 22 80 00 1c be,a 400093b0 <check_and_merge+0x84>
40009344: c4 02 e0 04 ld [ %o3 + 4 ], %g2
if (b->begin < a->begin) {
40009348: c6 02 e0 18 ld [ %o3 + 0x18 ], %g3
4000934c: c4 02 a0 18 ld [ %o2 + 0x18 ], %g2
40009350: 80 a0 c0 02 cmp %g3, %g2
40009354: 3a 80 00 07 bcc,a 40009370 <check_and_merge+0x44>
40009358: c8 02 a0 1c ld [ %o2 + 0x1c ], %g4
4000935c: 84 10 00 0a mov %o2, %g2
40009360: c2 02 80 00 ld [ %o2 ], %g1
40009364: 94 10 00 0b mov %o3, %o2
40009368: 96 10 00 02 mov %g2, %o3
a = b;
b = t;
}
a->size += b->size;
4000936c: c8 02 a0 1c ld [ %o2 + 0x1c ], %g4
40009370: c6 02 e0 1c ld [ %o3 + 0x1c ], %g3
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
40009374: c4 02 e0 04 ld [ %o3 + 4 ], %g2
40009378: 86 01 00 03 add %g4, %g3, %g3
4000937c: c6 22 a0 1c st %g3, [ %o2 + 0x1c ]
next->previous = previous;
previous->next = next;
40009380: c2 20 80 00 st %g1, [ %g2 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
40009384: c4 20 60 04 st %g2, [ %g1 + 4 ]
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
40009388: c2 02 00 00 ld [ %o0 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000938c: d0 22 e0 04 st %o0, [ %o3 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
40009390: d6 22 00 00 st %o3, [ %o0 ]
the_node->next = before_node;
40009394: c2 22 c0 00 st %g1, [ %o3 ]
rtems_chain_extract_unprotected(&b->chain_node);
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
40009398: 90 10 00 09 mov %o1, %o0
before_node->previous = the_node;
4000939c: d6 20 60 04 st %o3, [ %g1 + 4 ]
400093a0: 92 02 e0 08 add %o3, 8, %o1
400093a4: 82 13 c0 00 mov %o7, %g1
400093a8: 40 00 07 13 call 4000aff4 <_RBTree_Extract_unprotected>
400093ac: 9e 10 40 00 mov %g1, %o7
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
400093b0: 80 a0 a0 00 cmp %g2, 0
400093b4: 32 bf ff e6 bne,a 4000934c <check_and_merge+0x20> <== NEVER TAKEN
400093b8: c6 02 e0 18 ld [ %o3 + 0x18 ], %g3 <== NOT EXECUTED
400093bc: 81 c3 e0 08 retl
40004950 <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
40004950: 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(
40004954: 94 10 20 19 mov 0x19, %o2
40004958: 92 10 00 18 mov %i0, %o1
4000495c: 90 07 bf c8 add %fp, -56, %o0
40004960: 17 10 00 4d sethi %hi(0x40013400), %o3
40004964: 96 12 e2 10 or %o3, 0x210, %o3 ! 40013610 <rtems_global_user_env+0x4>
40004968: 40 00 04 f3 call 40005d34 <rtems_filesystem_eval_path_start_with_root_and_current>
4000496c: 98 02 ff fc add %o3, -4, %o4
40004970: 92 07 bf e0 add %fp, -32, %o1
40004974: 40 00 06 0b call 400061a0 <rtems_filesystem_location_copy_and_detach>
40004978: 90 07 bf b0 add %fp, -80, %o0
&rtems_global_user_env.root_directory,
&rtems_global_user_env.current_directory
);
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
4000497c: 40 00 06 98 call 400063dc <rtems_filesystem_location_transform_to_global>
40004980: 90 07 bf b0 add %fp, -80, %o0
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
40004984: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40004988: 39 10 00 4b sethi %hi(0x40012c00), %i4
4000498c: b8 17 22 d4 or %i4, 0x2d4, %i4 ! 40012ed4 <rtems_filesystem_null_handlers>
40004990: 80 a0 40 1c cmp %g1, %i4
40004994: 02 80 00 16 be 400049ec <chroot+0x9c>
40004998: d0 27 bf ac st %o0, [ %fp + -84 ]
rtems_filesystem_global_location_t *new_root_loc =
4000499c: 40 00 06 56 call 400062f4 <rtems_filesystem_global_location_obtain>
400049a0: 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)(
400049a4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
400049a8: 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 =
400049ac: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
400049b0: 9f c0 40 00 call %g1
400049b4: 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 ) {
400049b8: 80 a2 20 00 cmp %o0, 0
400049bc: 02 80 00 13 be 40004a08 <chroot+0xb8>
400049c0: 01 00 00 00 nop
static inline void rtems_filesystem_location_error(
const rtems_filesystem_location_info_t *loc,
int eno
)
{
if ( !rtems_filesystem_location_is_null( loc ) ) {
400049c4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
400049c8: 80 a0 40 1c cmp %g1, %i4
400049cc: 02 80 00 06 be 400049e4 <chroot+0x94> <== NEVER TAKEN
400049d0: 01 00 00 00 nop
errno = eno;
400049d4: 40 00 21 ac call 4000d084 <__errno>
400049d8: 01 00 00 00 nop
400049dc: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
400049e0: c2 22 00 00 st %g1, [ %o0 ]
rtems_filesystem_location_error( &new_root_loc->location, ENOTDIR );
rv = -1;
}
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_root_loc );
400049e4: 40 00 06 24 call 40006274 <rtems_filesystem_global_location_release>
400049e8: 90 10 00 1d mov %i5, %o0
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
400049ec: 40 00 05 1c call 40005e5c <rtems_filesystem_eval_path_cleanup>
400049f0: 90 07 bf c8 add %fp, -56, %o0
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc );
400049f4: d0 07 bf ac ld [ %fp + -84 ], %o0
400049f8: 40 00 06 1f call 40006274 <rtems_filesystem_global_location_release>
400049fc: b0 10 3f ff mov -1, %i0
}
return rv;
}
40004a00: 81 c7 e0 08 ret
40004a04: 81 e8 00 00 restore
(*new_root_loc->location.mt_entry->ops->node_type_h)(
&new_root_loc->location
);
if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {
sc = rtems_libio_set_private_env();
40004a08: 40 00 03 11 call 4000564c <rtems_libio_set_private_env>
40004a0c: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
40004a10: 80 a2 20 00 cmp %o0, 0
40004a14: 02 80 00 09 be 40004a38 <chroot+0xe8>
40004a18: 80 a2 20 0d cmp %o0, 0xd
rtems_filesystem_global_location_assign(
&rtems_filesystem_current,
new_current_loc
);
} else {
if (sc != RTEMS_UNSATISFIED) {
40004a1c: 02 bf ff f2 be 400049e4 <chroot+0x94> <== NEVER TAKEN
40004a20: 01 00 00 00 nop
errno = ENOMEM;
40004a24: 40 00 21 98 call 4000d084 <__errno>
40004a28: 01 00 00 00 nop
40004a2c: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
40004a30: 10 bf ff ed b 400049e4 <chroot+0x94>
40004a34: c2 22 00 00 st %g1, [ %o0 ]
);
if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {
sc = rtems_libio_set_private_env();
if (sc == RTEMS_SUCCESSFUL) {
rtems_filesystem_global_location_assign(
40004a38: 39 10 00 4d sethi %hi(0x40013400), %i4
40004a3c: d0 07 22 08 ld [ %i4 + 0x208 ], %o0 ! 40013608 <rtems_current_user_env>
40004a40: 92 10 00 1d mov %i5, %o1
40004a44: 40 00 06 22 call 400062cc <rtems_filesystem_global_location_assign>
40004a48: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_root_loc
);
rtems_filesystem_global_location_assign(
40004a4c: d2 07 bf ac ld [ %fp + -84 ], %o1
40004a50: d0 07 22 08 ld [ %i4 + 0x208 ], %o0
40004a54: 40 00 06 1e call 400062cc <rtems_filesystem_global_location_assign>
40004a58: b0 10 20 00 clr %i0
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40004a5c: 40 00 05 00 call 40005e5c <rtems_filesystem_eval_path_cleanup>
40004a60: 90 07 bf c8 add %fp, -56, %o0
40004a64: 81 c7 e0 08 ret
40004a68: 81 e8 00 00 restore
40007f2c <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
40007f2c: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
40007f30: 80 a6 60 00 cmp %i1, 0
40007f34: 02 80 00 0a be 40007f5c <clock_gettime+0x30>
40007f38: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
40007f3c: 02 80 00 19 be 40007fa0 <clock_gettime+0x74>
40007f40: 80 a6 20 04 cmp %i0, 4
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
40007f44: 02 80 00 12 be 40007f8c <clock_gettime+0x60> <== NEVER TAKEN
40007f48: 80 a6 20 02 cmp %i0, 2
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
40007f4c: 02 80 00 10 be 40007f8c <clock_gettime+0x60>
40007f50: 80 a6 20 03 cmp %i0, 3
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
40007f54: 02 80 00 08 be 40007f74 <clock_gettime+0x48>
40007f58: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
40007f5c: 40 00 25 fa call 40011744 <__errno>
40007f60: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff>
40007f64: 82 10 20 16 mov 0x16, %g1
40007f68: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
40007f6c: 81 c7 e0 08 ret
40007f70: 81 e8 00 00 restore
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
40007f74: 40 00 25 f4 call 40011744 <__errno>
40007f78: b0 10 3f ff mov -1, %i0
40007f7c: 82 10 20 58 mov 0x58, %g1
40007f80: c2 22 00 00 st %g1, [ %o0 ]
40007f84: 81 c7 e0 08 ret
40007f88: 81 e8 00 00 restore
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
_TOD_Get_uptime_as_timespec( tp );
40007f8c: 90 10 00 19 mov %i1, %o0
40007f90: 40 00 08 a4 call 4000a220 <_TOD_Get_uptime_as_timespec>
40007f94: b0 10 20 00 clr %i0
return 0;
40007f98: 81 c7 e0 08 ret
40007f9c: 81 e8 00 00 restore
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
40007fa0: 90 07 bf f8 add %fp, -8, %o0
40007fa4: 13 10 00 6d sethi %hi(0x4001b400), %o1
40007fa8: 40 00 08 8d call 4000a1dc <_TOD_Get_with_nanoseconds>
40007fac: 92 12 63 38 or %o1, 0x338, %o1 ! 4001b738 <_TOD>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
40007fb0: 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);
40007fb4: 94 10 20 00 clr %o2
40007fb8: 90 10 00 1c mov %i4, %o0
40007fbc: 92 10 00 1d mov %i5, %o1
40007fc0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40007fc4: 40 00 3e 50 call 40017904 <__divdi3>
40007fc8: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40007fcc: 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);
40007fd0: d2 26 40 00 st %o1, [ %i1 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40007fd4: 90 10 00 1c mov %i4, %o0
40007fd8: 92 10 00 1d mov %i5, %o1
40007fdc: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
return 0;
40007fe0: b0 10 20 00 clr %i0
40007fe4: 40 00 3f 33 call 40017cb0 <__moddi3>
40007fe8: 96 12 e2 00 or %o3, 0x200, %o3
40007fec: d2 26 60 04 st %o1, [ %i1 + 4 ]
40007ff0: 81 c7 e0 08 ret
40007ff4: 81 e8 00 00 restore
40029a84 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
40029a84: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
40029a88: 80 a6 60 00 cmp %i1, 0
40029a8c: 02 80 00 08 be 40029aac <clock_settime+0x28> <== NEVER TAKEN
40029a90: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
40029a94: 02 80 00 0c be 40029ac4 <clock_settime+0x40>
40029a98: 80 a6 20 02 cmp %i0, 2
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
40029a9c: 02 80 00 49 be 40029bc0 <clock_settime+0x13c>
40029aa0: 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 )
40029aa4: 02 80 00 47 be 40029bc0 <clock_settime+0x13c>
40029aa8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
40029aac: 40 00 4b 2f call 4003c768 <__errno>
40029ab0: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff>
40029ab4: 82 10 20 16 mov 0x16, %g1
40029ab8: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
40029abc: 81 c7 e0 08 ret
40029ac0: 81 e8 00 00 restore
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
40029ac4: c4 06 40 00 ld [ %i1 ], %g2
40029ac8: 03 08 76 b9 sethi %hi(0x21dae400), %g1
40029acc: 82 10 60 ff or %g1, 0xff, %g1 ! 21dae4ff <RAM_SIZE+0x219ae4ff>
40029ad0: 80 a0 80 01 cmp %g2, %g1
40029ad4: 08 bf ff f6 bleu 40029aac <clock_settime+0x28>
40029ad8: 03 10 01 a6 sethi %hi(0x40069800), %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;
40029adc: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 40069890 <_Thread_Dispatch_disable_level>
++level;
40029ae0: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40029ae4: c4 20 60 90 st %g2, [ %g1 + 0x90 ]
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
40029ae8: c6 06 40 00 ld [ %i1 ], %g3
40029aec: e2 06 60 04 ld [ %i1 + 4 ], %l1
40029af0: 85 38 e0 1f sra %g3, 0x1f, %g2
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
40029af4: 83 28 a0 03 sll %g2, 3, %g1
40029af8: bb 28 e0 03 sll %g3, 3, %i5
40029afc: 89 30 e0 1d srl %g3, 0x1d, %g4
40029b00: b8 11 00 01 or %g4, %g1, %i4
40029b04: 83 37 60 1b srl %i5, 0x1b, %g1
40029b08: a5 2f 20 05 sll %i4, 5, %l2
40029b0c: a7 2f 60 05 sll %i5, 5, %l3
40029b10: a4 10 40 12 or %g1, %l2, %l2
40029b14: ba a4 c0 1d subcc %l3, %i5, %i5
40029b18: 83 37 60 1a srl %i5, 0x1a, %g1
40029b1c: b8 64 80 1c subx %l2, %i4, %i4
40029b20: 97 2f 60 06 sll %i5, 6, %o3
40029b24: 95 2f 20 06 sll %i4, 6, %o2
40029b28: ba a2 c0 1d subcc %o3, %i5, %i5
40029b2c: 94 10 40 0a or %g1, %o2, %o2
40029b30: b8 62 80 1c subx %o2, %i4, %i4
40029b34: aa 87 40 03 addcc %i5, %g3, %l5
40029b38: 83 35 60 1e srl %l5, 0x1e, %g1
40029b3c: a8 47 00 02 addx %i4, %g2, %l4
40029b40: 9b 2d 60 02 sll %l5, 2, %o5
40029b44: 99 2d 20 02 sll %l4, 2, %o4
40029b48: 86 85 40 0d addcc %l5, %o5, %g3
40029b4c: 98 10 40 0c or %g1, %o4, %o4
40029b50: b3 28 e0 02 sll %g3, 2, %i1
40029b54: 84 45 00 0c addx %l4, %o4, %g2
40029b58: 83 30 e0 1e srl %g3, 0x1e, %g1
40029b5c: ba 80 c0 19 addcc %g3, %i1, %i5
40029b60: b1 28 a0 02 sll %g2, 2, %i0
40029b64: b7 2f 60 02 sll %i5, 2, %i3
40029b68: b0 10 40 18 or %g1, %i0, %i0
40029b6c: 83 37 60 1e srl %i5, 0x1e, %g1
40029b70: b8 40 80 18 addx %g2, %i0, %i4
40029b74: 86 87 40 1b addcc %i5, %i3, %g3
40029b78: b5 2f 20 02 sll %i4, 2, %i2
40029b7c: bb 30 e0 17 srl %g3, 0x17, %i5
40029b80: b4 10 40 1a or %g1, %i2, %i2
40029b84: 84 47 00 1a addx %i4, %i2, %g2
40029b88: 83 28 e0 09 sll %g3, 9, %g1
40029b8c: 89 28 a0 09 sll %g2, 9, %g4
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
40029b90: 90 07 bf f8 add %fp, -8, %o0
40029b94: 84 17 40 04 or %i5, %g4, %g2
40029b98: ba 84 40 01 addcc %l1, %g1, %i5
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
40029b9c: a1 3c 60 1f sra %l1, 0x1f, %l0
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
40029ba0: b0 10 20 00 clr %i0
40029ba4: b8 44 00 02 addx %l0, %g2, %i4
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
40029ba8: 40 00 04 92 call 4002adf0 <_TOD_Set_with_timestamp>
40029bac: f8 3f bf f8 std %i4, [ %fp + -8 ]
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
40029bb0: 7f ff 83 a7 call 4000aa4c <_Thread_Enable_dispatch>
40029bb4: 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;
40029bb8: 81 c7 e0 08 ret
40029bbc: 81 e8 00 00 restore
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
40029bc0: 40 00 4a ea call 4003c768 <__errno>
40029bc4: b0 10 3f ff mov -1, %i0
40029bc8: 82 10 20 58 mov 0x58, %g1
40029bcc: c2 22 00 00 st %g1, [ %o0 ]
40029bd0: 81 c7 e0 08 ret
40029bd4: 81 e8 00 00 restore
40004264 <create_disk>:
dev_t dev,
const char *name,
rtems_disk_device **dd_ptr,
char **alloc_name_ptr
)
{
40004264: 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) {
40004268: 25 10 00 71 sethi %hi(0x4001c400), %l2
4000426c: fa 04 a0 70 ld [ %l2 + 0x70 ], %i5 ! 4001c470 <disktab_size>
40004270: 80 a6 00 1d cmp %i0, %i5
40004274: 1a 80 00 30 bcc 40004334 <create_disk+0xd0>
40004278: a2 10 00 18 mov %i0, %l1
4000427c: 03 10 00 71 sethi %hi(0x4001c400), %g1
40004280: e0 00 60 74 ld [ %g1 + 0x74 ], %l0 ! 4001c474 <disktab>
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab = table;
disktab_size = new_size;
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
40004284: 83 2c 60 03 sll %l1, 3, %g1
40004288: fa 04 00 01 ld [ %l0 + %g1 ], %i5
4000428c: a0 04 00 01 add %l0, %g1, %l0
40004290: 80 a7 60 00 cmp %i5, 0
40004294: 02 80 00 0f be 400042d0 <create_disk+0x6c>
40004298: f0 04 20 04 ld [ %l0 + 4 ], %i0
4000429c: 80 a6 40 18 cmp %i1, %i0
400042a0: 1a 80 00 0d bcc 400042d4 <create_disk+0x70>
400042a4: 80 a6 20 00 cmp %i0, 0
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab [major].minor = table;
disktab [major].size = new_size;
}
return disktab [major].minor + minor;
400042a8: 83 2e 60 02 sll %i1, 2, %g1
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
400042ac: a0 87 40 01 addcc %i5, %g1, %l0
400042b0: 02 80 00 1f be 4000432c <create_disk+0xc8> <== NEVER TAKEN
400042b4: 01 00 00 00 nop
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
400042b8: c2 07 40 01 ld [ %i5 + %g1 ], %g1
400042bc: 80 a0 60 00 cmp %g1, 0
400042c0: 02 80 00 36 be 40004398 <create_disk+0x134>
400042c4: b0 10 20 0c mov 0xc, %i0
*dd_entry = dd;
*dd_ptr = dd;
*alloc_name_ptr = alloc_name;
return RTEMS_SUCCESSFUL;
}
400042c8: 81 c7 e0 08 ret
400042cc: 81 e8 00 00 restore
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
400042d0: 80 a6 20 00 cmp %i0, 0
400042d4: 12 80 00 2b bne 40004380 <create_disk+0x11c>
400042d8: a4 10 20 08 mov 8, %l2
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
}
if (minor >= new_size) {
400042dc: 80 a6 40 12 cmp %i1, %l2
400042e0: 3a 80 00 02 bcc,a 400042e8 <create_disk+0x84>
400042e4: a4 06 60 01 add %i1, 1, %l2
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
400042e8: 90 10 00 1d mov %i5, %o0
400042ec: 40 00 08 12 call 40006334 <realloc>
400042f0: 93 2c a0 02 sll %l2, 2, %o1
if (table == NULL) {
400042f4: ba 92 20 00 orcc %o0, 0, %i5
400042f8: 02 80 00 0d be 4000432c <create_disk+0xc8>
400042fc: 94 24 80 18 sub %l2, %i0, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
40004300: 91 2e 20 02 sll %i0, 2, %o0
40004304: 92 10 20 00 clr %o1
40004308: 90 07 40 08 add %i5, %o0, %o0
4000430c: 40 00 46 6f call 40015cc8 <memset>
40004310: 95 2a a0 02 sll %o2, 2, %o2
disktab [major].minor = table;
40004314: fa 24 00 00 st %i5, [ %l0 ]
disktab [major].size = new_size;
40004318: e4 24 20 04 st %l2, [ %l0 + 4 ]
}
return disktab [major].minor + minor;
4000431c: 83 2e 60 02 sll %i1, 2, %g1
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
40004320: a0 87 40 01 addcc %i5, %g1, %l0
40004324: 32 bf ff e6 bne,a 400042bc <create_disk+0x58> <== ALWAYS TAKEN
40004328: c2 07 40 01 ld [ %i5 + %g1 ], %g1
alloc_name = strdup(name);
if (alloc_name == NULL) {
free(dd);
return RTEMS_NO_MEMORY;
4000432c: 81 c7 e0 08 ret
40004330: 91 e8 20 1a restore %g0, 0x1a, %o0
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
rtems_disk_device_table *table = disktab;
40004334: 27 10 00 71 sethi %hi(0x4001c400), %l3
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
40004338: b1 2f 60 01 sll %i5, 1, %i0
if (major >= new_size) {
4000433c: 80 a4 40 18 cmp %l1, %i0
40004340: 0a 80 00 03 bcs 4000434c <create_disk+0xe8> <== NEVER TAKEN
40004344: d0 04 e0 74 ld [ %l3 + 0x74 ], %o0
new_size = major + 1;
40004348: b0 04 60 01 add %l1, 1, %i0
}
table = realloc(table, new_size * sizeof(*table));
4000434c: 40 00 07 fa call 40006334 <realloc>
40004350: 93 2e 20 03 sll %i0, 3, %o1
if (table == NULL) {
40004354: a0 92 20 00 orcc %o0, 0, %l0
40004358: 02 bf ff f5 be 4000432c <create_disk+0xc8> <== ALWAYS TAKEN
4000435c: 94 26 00 1d sub %i0, %i5, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
40004360: 91 2f 60 03 sll %i5, 3, %o0 <== NOT EXECUTED
40004364: 92 10 20 00 clr %o1 <== NOT EXECUTED
40004368: 90 04 00 08 add %l0, %o0, %o0 <== NOT EXECUTED
4000436c: 40 00 46 57 call 40015cc8 <memset> <== NOT EXECUTED
40004370: 95 2a a0 03 sll %o2, 3, %o2 <== NOT EXECUTED
disktab = table;
40004374: e0 24 e0 74 st %l0, [ %l3 + 0x74 ] <== NOT EXECUTED
disktab_size = new_size;
40004378: 10 bf ff c3 b 40004284 <create_disk+0x20> <== NOT EXECUTED
4000437c: f0 24 a0 70 st %i0, [ %l2 + 0x70 ] <== NOT EXECUTED
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
40004380: a5 2e 20 01 sll %i0, 1, %l2
}
if (minor >= new_size) {
40004384: 80 a6 40 12 cmp %i1, %l2
40004388: 0a bf ff d9 bcs 400042ec <create_disk+0x88> <== ALWAYS TAKEN
4000438c: 90 10 00 1d mov %i5, %o0
40004390: 10 bf ff d7 b 400042ec <create_disk+0x88> <== NOT EXECUTED
40004394: a4 06 60 01 add %i1, 1, %l2 <== NOT EXECUTED
if (*dd_entry != NULL) {
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
40004398: 40 00 05 35 call 4000586c <malloc>
4000439c: 90 10 20 78 mov 0x78, %o0
if (dd == NULL) {
400043a0: ba 92 20 00 orcc %o0, 0, %i5
400043a4: 02 bf ff e2 be 4000432c <create_disk+0xc8> <== NEVER TAKEN
400043a8: 80 a6 a0 00 cmp %i2, 0
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
400043ac: 02 80 00 0f be 400043e8 <create_disk+0x184>
400043b0: b0 10 20 00 clr %i0
alloc_name = strdup(name);
400043b4: 40 00 46 fd call 40015fa8 <strdup>
400043b8: 90 10 00 1a mov %i2, %o0
if (alloc_name == NULL) {
400043bc: b0 92 20 00 orcc %o0, 0, %i0
400043c0: 02 80 00 16 be 40004418 <create_disk+0x1b4> <== NEVER TAKEN
400043c4: b4 10 00 08 mov %o0, %i2
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
400043c8: 94 10 00 11 mov %l1, %o2
400043cc: 13 00 00 18 sethi %hi(0x6000), %o1
400043d0: 96 10 00 19 mov %i1, %o3
400043d4: 40 00 05 95 call 40005a28 <mknod>
400043d8: 92 12 61 ff or %o1, 0x1ff, %o1
400043dc: 80 a2 20 00 cmp %o0, 0
400043e0: 06 80 00 07 bl 400043fc <create_disk+0x198> <== NEVER TAKEN
400043e4: 01 00 00 00 nop
free(dd);
return RTEMS_UNSATISFIED;
}
}
*dd_entry = dd;
400043e8: fa 24 00 00 st %i5, [ %l0 ]
*dd_ptr = dd;
400043ec: fa 26 c0 00 st %i5, [ %i3 ]
*alloc_name_ptr = alloc_name;
400043f0: f0 27 00 00 st %i0, [ %i4 ]
return RTEMS_SUCCESSFUL;
400043f4: 81 c7 e0 08 ret
400043f8: 91 e8 20 00 restore %g0, 0, %o0
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
400043fc: 40 00 03 d4 call 4000534c <free> <== NOT EXECUTED
40004400: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
free(dd);
40004404: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40004408: 40 00 03 d1 call 4000534c <free> <== NOT EXECUTED
4000440c: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
40004410: 81 c7 e0 08 ret <== NOT EXECUTED
40004414: 81 e8 00 00 restore <== NOT EXECUTED
if (name != NULL) {
alloc_name = strdup(name);
if (alloc_name == NULL) {
free(dd);
40004418: 40 00 03 cd call 4000534c <free> <== NOT EXECUTED
4000441c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40004420: 30 bf ff c3 b,a 4000432c <create_disk+0xc8> <== NOT EXECUTED
40005720 <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)
40005720: 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)
40005724: 90 10 20 01 mov 1, %o0
if (new_part_desc == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
*new_part_desc = NULL;
40005728: c0 26 40 00 clr [ %i1 ]
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
4000572c: 40 00 03 54 call 4000647c <calloc>
40005730: 92 10 20 28 mov 0x28, %o1
* RTEMS_SUCCESSFUL, if success;
* RTEMS_NO_MEMOTY, if cannot allocate memory for part_desc_t strucure;
* RTEMS_INTERNAL_ERROR, if other error occurs.
*/
static rtems_status_code
data_to_part_desc(uint8_t *data, rtems_part_desc_t **new_part_desc)
40005734: 82 10 00 18 mov %i0, %g1
return RTEMS_INTERNAL_ERROR;
}
*new_part_desc = NULL;
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
40005738: ba 10 00 08 mov %o0, %i5
4000573c: 80 a2 20 00 cmp %o0, 0
40005740: 02 80 00 40 be 40005840 <data_to_part_desc.part.1+0x120> <== NEVER TAKEN
40005744: b0 10 20 1a mov 0x1a, %i0
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
40005748: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
4000574c: da 08 60 08 ldub [ %g1 + 8 ], %o5
40005750: de 08 60 09 ldub [ %g1 + 9 ], %o7
40005754: f0 08 60 0a ldub [ %g1 + 0xa ], %i0
part_desc->start = LE_TO_CPU_U32(temp);
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
40005758: f6 08 60 0d ldub [ %g1 + 0xd ], %i3
4000575c: f8 08 60 0e ldub [ %g1 + 0xe ], %i4
40005760: c8 08 60 0f ldub [ %g1 + 0xf ], %g4
40005764: f4 08 60 0c ldub [ %g1 + 0xc ], %i2
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
40005768: c6 2f bf ff stb %g3, [ %fp + -1 ]
4000576c: da 2f bf fc stb %o5, [ %fp + -4 ]
40005770: de 2f bf fd stb %o7, [ %fp + -3 ]
40005774: f0 2f bf fe stb %i0, [ %fp + -2 ]
part_desc->start = LE_TO_CPU_U32(temp);
40005778: c4 07 bf fc ld [ %fp + -4 ], %g2
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
4000577c: d2 08 60 04 ldub [ %g1 + 4 ], %o1
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
40005780: c6 08 40 00 ldub [ %g1 ], %g3
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
part_desc->start = LE_TO_CPU_U32(temp);
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
40005784: f6 2f bf fd stb %i3, [ %fp + -3 ]
40005788: f8 2f bf fe stb %i4, [ %fp + -2 ]
4000578c: c8 2f bf ff stb %g4, [ %fp + -1 ]
40005790: f4 2f bf fc stb %i2, [ %fp + -4 ]
part_desc->size = LE_TO_CPU_U32(temp);
40005794: c2 07 bf fc ld [ %fp + -4 ], %g1
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40005798: b7 28 a0 18 sll %g2, 0x18, %i3
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
4000579c: 89 30 a0 18 srl %g2, 0x18, %g4
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
400057a0: b9 30 a0 08 srl %g2, 8, %i4
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400057a4: 88 16 c0 04 or %i3, %g4, %g4
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
400057a8: b8 0f 20 ff and %i4, 0xff, %i4
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400057ac: b9 2f 20 10 sll %i4, 0x10, %i4
400057b0: 88 11 00 1c or %g4, %i4, %g4
400057b4: b7 28 60 18 sll %g1, 0x18, %i3
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
400057b8: b9 30 60 18 srl %g1, 0x18, %i4
byte3 = (value >> 16) & 0xff;
400057bc: 85 30 a0 10 srl %g2, 0x10, %g2
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400057c0: b8 16 c0 1c or %i3, %i4, %i4
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
400057c4: 84 08 a0 ff and %g2, 0xff, %g2
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
400057c8: c6 2a 00 00 stb %g3, [ %o0 ]
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400057cc: 85 28 a0 08 sll %g2, 8, %g2
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
400057d0: d2 2a 20 01 stb %o1, [ %o0 + 1 ]
400057d4: 84 11 00 02 or %g4, %g2, %g2
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
400057d8: 89 30 60 08 srl %g1, 8, %g4
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
part_desc->start = LE_TO_CPU_U32(temp);
400057dc: c4 22 20 04 st %g2, [ %o0 + 4 ]
400057e0: 88 09 20 ff and %g4, 0xff, %g4
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
400057e4: 83 30 60 10 srl %g1, 0x10, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400057e8: 89 29 20 10 sll %g4, 0x10, %g4
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
400057ec: 82 08 60 ff and %g1, 0xff, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400057f0: b8 17 00 04 or %i4, %g4, %i4
400057f4: 83 28 60 08 sll %g1, 8, %g1
400057f8: b8 17 00 01 or %i4, %g1, %i4
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
400057fc: 82 0a 60 7f and %o1, 0x7f, %g1
40005800: 80 a0 60 05 cmp %g1, 5
40005804: 02 80 00 11 be 40005848 <data_to_part_desc.part.1+0x128>
40005808: f8 22 20 08 st %i4, [ %o0 + 8 ]
DOS_P32MB_PARTITION,
FAT32_PARTITION ,FAT32_LBA_PARTITION,
FAT16_LBA_PARTITION
};
return (NULL != memchr(fat_part_types,type,sizeof(fat_part_types)));
4000580c: 92 0a 60 ff and %o1, 0xff, %o1
40005810: 11 10 00 99 sethi %hi(0x40026400), %o0
40005814: 94 10 20 06 mov 6, %o2
40005818: 40 00 45 60 call 40016d98 <memchr>
4000581c: 90 12 22 d0 or %o0, 0x2d0, %o0
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
40005820: 80 a2 20 00 cmp %o0, 0
40005824: 02 80 00 04 be 40005834 <data_to_part_desc.part.1+0x114>
40005828: 80 a7 20 00 cmp %i4, 0
((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
4000582c: 32 80 00 08 bne,a 4000584c <data_to_part_desc.part.1+0x12c><== ALWAYS TAKEN
40005830: fa 26 40 00 st %i5, [ %i1 ]
*new_part_desc = part_desc;
}
else {
/* empty partition */
free(part_desc);
40005834: 90 10 00 1d mov %i5, %o0
40005838: 40 00 03 48 call 40006558 <free>
4000583c: b0 10 20 00 clr %i0
}
return RTEMS_SUCCESSFUL;
}
40005840: 81 c7 e0 08 ret
40005844: 81 e8 00 00 restore
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
*new_part_desc = part_desc;
40005848: fa 26 40 00 st %i5, [ %i1 ]
}
else {
/* empty partition */
free(part_desc);
}
return RTEMS_SUCCESSFUL;
4000584c: 81 c7 e0 08 ret
40005850: 91 e8 20 00 restore %g0, 0, %o0
40003640 <devFS_Show>:
#endif
#include "devfs.h"
void devFS_Show(void)
{
40003640: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
40003644: 03 10 00 51 sethi %hi(0x40014400), %g1
40003648: c2 00 62 4c ld [ %g1 + 0x24c ], %g1 ! 4001464c <rtems_current_user_env>
if (rootloc->mt_entry->ops == &devFS_ops) {
4000364c: 05 10 00 4e sethi %hi(0x40013800), %g2
40003650: c2 00 60 04 ld [ %g1 + 4 ], %g1
40003654: 84 10 a0 d4 or %g2, 0xd4, %g2
40003658: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
4000365c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
40003660: 80 a0 c0 02 cmp %g3, %g2
40003664: 22 80 00 04 be,a 40003674 <devFS_Show+0x34> <== ALWAYS TAKEN
40003668: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000366c: 81 c7 e0 08 ret <== NOT EXECUTED
40003670: 81 e8 00 00 restore <== NOT EXECUTED
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
40003674: f0 00 60 04 ld [ %g1 + 4 ], %i0
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
40003678: 80 a6 20 00 cmp %i0, 0
4000367c: 02 bf ff fc be 4000366c <devFS_Show+0x2c> <== NEVER TAKEN
40003680: f8 00 40 00 ld [ %g1 ], %i4
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
40003684: 23 10 00 4e sethi %hi(0x40013800), %l1
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
40003688: 35 10 00 4e sethi %hi(0x40013800), %i2
}
printk(
4000368c: 21 10 00 4e sethi %hi(0x40013800), %l0
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
40003690: b2 10 20 00 clr %i1
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
40003694: a2 14 61 28 or %l1, 0x128, %l1
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
40003698: b4 16 a1 40 or %i2, 0x140, %i2
}
printk(
4000369c: a0 14 21 30 or %l0, 0x130, %l0
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
devFS_node *current = nodes + i;
if (current->name != NULL) {
400036a0: c2 07 00 00 ld [ %i4 ], %g1
400036a4: 80 a0 60 00 cmp %g1, 0
400036a8: 22 80 00 15 be,a 400036fc <devFS_Show+0xbc>
400036ac: b2 06 60 01 inc %i1
size_t j = 0;
size_t m = current->namelen;
400036b0: f6 07 20 04 ld [ %i4 + 4 ], %i3
printk("/");
400036b4: 40 00 03 e8 call 40004654 <printk>
400036b8: 90 10 00 11 mov %l1, %o0
for (j = 0; j < m; ++j) {
400036bc: 80 a6 e0 00 cmp %i3, 0
400036c0: 02 80 00 0a be 400036e8 <devFS_Show+0xa8> <== NEVER TAKEN
400036c4: ba 10 20 00 clr %i5
printk("%c", current->name [j]);
400036c8: c2 07 00 00 ld [ %i4 ], %g1
400036cc: 90 10 00 1a mov %i2, %o0
400036d0: d2 48 40 1d ldsb [ %g1 + %i5 ], %o1
400036d4: 40 00 03 e0 call 40004654 <printk>
400036d8: ba 07 60 01 inc %i5
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
for (j = 0; j < m; ++j) {
400036dc: 80 a7 40 1b cmp %i5, %i3
400036e0: 32 bf ff fb bne,a 400036cc <devFS_Show+0x8c>
400036e4: c2 07 00 00 ld [ %i4 ], %g1
printk("%c", current->name [j]);
}
printk(
400036e8: d2 07 20 08 ld [ %i4 + 8 ], %o1
400036ec: d4 07 20 0c ld [ %i4 + 0xc ], %o2
400036f0: 40 00 03 d9 call 40004654 <printk>
400036f4: 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) {
400036f8: b2 06 60 01 inc %i1
400036fc: 80 a6 40 18 cmp %i1, %i0
40003700: 12 bf ff e8 bne 400036a0 <devFS_Show+0x60>
40003704: b8 07 20 14 add %i4, 0x14, %i4
40003708: 81 c7 e0 08 ret
4000370c: 81 e8 00 00 restore
4000dc40 <devFS_eval_path>:
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
4000dc40: 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;
4000dc44: 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;
4000dc48: e2 06 00 00 ld [ %i0 ], %l1
4000dc4c: 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;
4000dc50: f2 06 20 04 ld [ %i0 + 4 ], %i1
size_t pathlen,
devFS_node **free_node_ptr
)
{
size_t i = 0;
size_t n = data->count;
4000dc54: e0 00 60 04 ld [ %g1 + 4 ], %l0
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
devFS_node *free_node = NULL;
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
4000dc58: 80 a4 20 00 cmp %l0, 0
4000dc5c: 02 80 00 3d be 4000dd50 <devFS_eval_path+0x110>
4000dc60: fa 00 40 00 ld [ %g1 ], %i5
)
{
size_t i = 0;
size_t n = data->count;
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
4000dc64: b4 10 20 00 clr %i2
devFS_node *free_node = NULL;
4000dc68: 82 10 20 00 clr %g1
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
4000dc6c: 10 80 00 09 b 4000dc90 <devFS_eval_path+0x50>
4000dc70: b8 10 20 00 clr %i4
4000dc74: 80 a6 a0 00 cmp %i2, 0
4000dc78: 12 80 00 18 bne 4000dcd8 <devFS_eval_path+0x98> <== NEVER TAKEN
4000dc7c: b8 07 20 01 inc %i4
4000dc80: ba 07 60 14 add %i5, 0x14, %i5
4000dc84: 80 a7 00 10 cmp %i4, %l0
4000dc88: 02 80 00 1f be 4000dd04 <devFS_eval_path+0xc4>
4000dc8c: 82 10 00 1b mov %i3, %g1
devFS_node *current = nodes + i;
if (current->name != NULL) {
4000dc90: d0 07 40 00 ld [ %i5 ], %o0
4000dc94: 80 a2 20 00 cmp %o0, 0
4000dc98: 02 bf ff f7 be 4000dc74 <devFS_eval_path+0x34>
4000dc9c: b6 10 00 1d mov %i5, %i3
if (
4000dca0: c4 07 60 04 ld [ %i5 + 4 ], %g2
4000dca4: 80 a6 40 02 cmp %i1, %g2
4000dca8: 12 bf ff f3 bne 4000dc74 <devFS_eval_path+0x34>
4000dcac: b6 10 00 01 mov %g1, %i3
current->namelen == pathlen
&& memcmp(current->name, path, pathlen) == 0
4000dcb0: 92 10 00 11 mov %l1, %o1
4000dcb4: 40 00 0b 95 call 40010b08 <memcmp>
4000dcb8: 94 10 00 19 mov %i1, %o2
4000dcbc: 80 a2 20 00 cmp %o0, 0
4000dcc0: 12 bf ff ee bne 4000dc78 <devFS_eval_path+0x38>
4000dcc4: 80 a6 a0 00 cmp %i2, 0
4000dcc8: b4 10 00 1d mov %i5, %i2
size_t n = data->count;
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
devFS_node *free_node = NULL;
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
4000dccc: 80 a6 a0 00 cmp %i2, 0
4000dcd0: 02 bf ff ec be 4000dc80 <devFS_eval_path+0x40> <== NEVER TAKEN
4000dcd4: b8 07 20 01 inc %i4
4000dcd8: 80 a6 e0 00 cmp %i3, 0
4000dcdc: 22 bf ff ea be,a 4000dc84 <devFS_eval_path+0x44> <== NEVER TAKEN
4000dce0: ba 07 60 14 add %i5, 0x14, %i5 <== NOT EXECUTED
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
4000dce4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
4000dce8: 80 88 60 40 btst 0x40, %g1
4000dcec: 12 80 00 15 bne 4000dd40 <devFS_eval_path+0x100>
4000dcf0: 01 00 00 00 nop
currentloc->node_access = node;
4000dcf4: f4 26 20 20 st %i2, [ %i0 + 0x20 ]
static inline void rtems_filesystem_eval_path_clear_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->pathlen = 0;
4000dcf8: c0 26 20 04 clr [ %i0 + 4 ]
4000dcfc: 81 c7 e0 08 ret
4000dd00: 81 e8 00 00 restore
rtems_filesystem_eval_path_get_pathlen(ctx),
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
4000dd04: 80 a6 a0 00 cmp %i2, 0
4000dd08: 12 bf ff f8 bne 4000dce8 <devFS_eval_path+0xa8> <== NEVER TAKEN
4000dd0c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
}
} else {
if ((eval_flags & RTEMS_FS_MAKE) != 0) {
4000dd10: 80 88 60 20 btst 0x20, %g1
4000dd14: 02 80 00 0d be 4000dd48 <devFS_eval_path+0x108> <== NEVER TAKEN
4000dd18: 80 a6 e0 00 cmp %i3, 0
if (free_node != NULL) {
4000dd1c: 02 80 00 11 be 4000dd60 <devFS_eval_path+0x120> <== NEVER TAKEN
4000dd20: 82 10 21 ff mov 0x1ff, %g1
free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;
4000dd24: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
currentloc->node_access = free_node;
4000dd28: f6 26 20 20 st %i3, [ %i0 + 0x20 ]
rtems_filesystem_eval_path_context_t *ctx,
const char *token,
size_t tokenlen
)
{
ctx->token = token;
4000dd2c: e2 26 20 08 st %l1, [ %i0 + 8 ]
ctx->tokenlen = tokenlen;
4000dd30: f2 26 20 0c st %i1, [ %i0 + 0xc ]
static inline void rtems_filesystem_eval_path_clear_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->pathlen = 0;
4000dd34: c0 26 20 04 clr [ %i0 + 4 ]
4000dd38: 81 c7 e0 08 ret
4000dd3c: 81 e8 00 00 restore
if (node != NULL) {
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
currentloc->node_access = node;
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
4000dd40: 7f ff e1 ca call 40006468 <rtems_filesystem_eval_path_error>
4000dd44: 93 e8 20 11 restore %g0, 0x11, %o1
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, ENOSPC);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
4000dd48: 7f ff e1 c8 call 40006468 <rtems_filesystem_eval_path_error><== NOT EXECUTED
4000dd4c: 93 e8 20 02 restore %g0, 2, %o1 <== NOT EXECUTED
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
}
} else {
if ((eval_flags & RTEMS_FS_MAKE) != 0) {
4000dd50: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4000dd54: 80 88 60 20 btst 0x20, %g1
4000dd58: 02 bf ff fc be 4000dd48 <devFS_eval_path+0x108> <== NEVER TAKEN
4000dd5c: 01 00 00 00 nop
rtems_filesystem_eval_path_get_path(ctx),
rtems_filesystem_eval_path_get_pathlen(ctx)
);
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, ENOSPC);
4000dd60: 7f ff e1 c2 call 40006468 <rtems_filesystem_eval_path_error>
4000dd64: 93 e8 20 1c restore %g0, 0x1c, %o1
400051e4 <devFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
400051e4: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
400051e8: 80 a6 a0 03 cmp %i2, 3
400051ec: 22 80 00 18 be,a 4000524c <devFS_mknod+0x68>
400051f0: c2 4e 40 00 ldsb [ %i1 ], %g1
if (S_ISBLK(mode) || S_ISCHR(mode)) {
400051f4: 05 00 00 2c sethi %hi(0xb000), %g2
400051f8: 03 00 00 08 sethi %hi(0x2000), %g1
400051fc: 84 0e c0 02 and %i3, %g2, %g2
40005200: 80 a0 80 01 cmp %g2, %g1
40005204: 12 80 00 23 bne 40005290 <devFS_mknod+0xac>
40005208: 01 00 00 00 nop
char *dupname = malloc(namelen);
4000520c: 40 00 01 5a call 40005774 <malloc>
40005210: 90 10 00 1a mov %i2, %o0
if (dupname != NULL) {
40005214: 84 92 20 00 orcc %o0, 0, %g2
40005218: 02 80 00 24 be 400052a8 <devFS_mknod+0xc4>
4000521c: 92 10 00 19 mov %i1, %o1
devFS_node *node = parentloc->node_access;
40005220: c2 06 20 08 ld [ %i0 + 8 ], %g1
node->name = dupname;
40005224: c4 20 40 00 st %g2, [ %g1 ]
node->namelen = namelen;
40005228: f4 20 60 04 st %i2, [ %g1 + 4 ]
node->major = rtems_filesystem_dev_major_t(dev);
4000522c: f8 20 60 08 st %i4, [ %g1 + 8 ]
node->minor = rtems_filesystem_dev_minor_t(dev);
40005230: fa 20 60 0c st %i5, [ %g1 + 0xc ]
node->mode = mode;
40005234: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
memcpy(dupname, name, namelen);
40005238: 94 10 00 1a mov %i2, %o2
4000523c: 40 00 2e 5d call 40010bb0 <memcpy>
40005240: b0 10 20 00 clr %i0
40005244: 81 c7 e0 08 ret
40005248: 81 e8 00 00 restore
dev_t dev
)
{
int rv = 0;
if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
4000524c: 80 a0 60 64 cmp %g1, 0x64
40005250: 12 bf ff ea bne 400051f8 <devFS_mknod+0x14> <== NEVER TAKEN
40005254: 05 00 00 2c sethi %hi(0xb000), %g2
40005258: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1
4000525c: 80 a0 60 65 cmp %g1, 0x65
40005260: 12 bf ff e7 bne 400051fc <devFS_mknod+0x18> <== NEVER TAKEN
40005264: 03 00 00 08 sethi %hi(0x2000), %g1
40005268: c2 4e 60 02 ldsb [ %i1 + 2 ], %g1
4000526c: 80 a0 60 76 cmp %g1, 0x76
40005270: 12 bf ff e3 bne 400051fc <devFS_mknod+0x18> <== NEVER TAKEN
40005274: 03 00 00 08 sethi %hi(0x2000), %g1
} else {
errno = ENOTSUP;
rv = -1;
}
} else {
if (!S_ISDIR(mode)) {
40005278: 03 00 00 3c sethi %hi(0xf000), %g1
4000527c: b6 0e c0 01 and %i3, %g1, %i3
40005280: 03 00 00 10 sethi %hi(0x4000), %g1
40005284: 80 a6 c0 01 cmp %i3, %g1
40005288: 02 bf ff ef be 40005244 <devFS_mknod+0x60> <== ALWAYS TAKEN
4000528c: b0 10 20 00 clr %i0
errno = ENOTSUP;
40005290: 40 00 2b af call 4001014c <__errno>
40005294: b0 10 3f ff mov -1, %i0
40005298: 82 10 20 86 mov 0x86, %g1
4000529c: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
}
return rv;
}
400052a0: 81 c7 e0 08 ret
400052a4: 81 e8 00 00 restore
node->major = rtems_filesystem_dev_major_t(dev);
node->minor = rtems_filesystem_dev_minor_t(dev);
node->mode = mode;
memcpy(dupname, name, namelen);
} else {
errno = ENOMEM;
400052a8: 40 00 2b a9 call 4001014c <__errno>
400052ac: b0 10 3f ff mov -1, %i0
400052b0: 82 10 20 0c mov 0xc, %g1
400052b4: c2 22 00 00 st %g1, [ %o0 ]
400052b8: 81 c7 e0 08 ret
400052bc: 81 e8 00 00 restore
400041ec <disk_lock>:
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
400041ec: 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);
400041f0: 03 10 00 71 sethi %hi(0x4001c400), %g1
400041f4: d0 00 60 6c ld [ %g1 + 0x6c ], %o0 ! 4001c46c <diskdevs_mutex>
400041f8: 92 10 20 00 clr %o1
400041fc: 94 10 20 00 clr %o2
40004200: 40 00 15 f8 call 400099e0 <rtems_semaphore_obtain>
40004204: b0 10 20 16 mov 0x16, %i0
if (sc == RTEMS_SUCCESSFUL) {
40004208: 80 a2 20 00 cmp %o0, 0
4000420c: 12 80 00 05 bne 40004220 <disk_lock+0x34> <== NEVER TAKEN
40004210: 84 10 20 01 mov 1, %g2
diskdevs_protected = true;
40004214: 03 10 00 71 sethi %hi(0x4001c400), %g1
return RTEMS_SUCCESSFUL;
40004218: 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;
4000421c: c4 28 60 68 stb %g2, [ %g1 + 0x68 ]
return RTEMS_SUCCESSFUL;
} else {
return RTEMS_NOT_CONFIGURED;
}
}
40004220: 81 c7 e0 08 ret
40004224: 81 e8 00 00 restore
40004228 <disk_unlock>:
static void
disk_unlock(void)
{
40004228: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
sc = rtems_semaphore_release(diskdevs_mutex);
4000422c: 03 10 00 71 sethi %hi(0x4001c400), %g1
40004230: d0 00 60 6c ld [ %g1 + 0x6c ], %o0 ! 4001c46c <diskdevs_mutex>
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
40004234: 03 10 00 71 sethi %hi(0x4001c400), %g1
40004238: c0 28 60 68 clrb [ %g1 + 0x68 ] ! 4001c468 <diskdevs_protected>
sc = rtems_semaphore_release(diskdevs_mutex);
4000423c: 40 00 16 38 call 40009b1c <rtems_semaphore_release>
40004240: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40004244: 80 a2 20 00 cmp %o0, 0
40004248: 12 80 00 04 bne 40004258 <disk_unlock+0x30> <== NEVER TAKEN
4000424c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
40004250: 81 c7 e0 08 ret
40004254: 81 e8 00 00 restore
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
40004258: 40 00 17 9c call 4000a0c8 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000425c: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
40005dc8 <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
40005dc8: 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);
40005dcc: 7f ff f1 c1 call 400024d0 <sparc_disable_interrupts>
40005dd0: 01 00 00 00 nop
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
40005dd4: c4 06 20 84 ld [ %i0 + 0x84 ], %g2
40005dd8: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
40005ddc: 80 a0 80 01 cmp %g2, %g1
40005de0: 02 80 00 14 be 40005e30 <drainOutput.part.0+0x68> <== ALWAYS TAKEN
40005de4: 01 00 00 00 nop
tty->rawOutBufState = rob_wait;
40005de8: b8 10 20 02 mov 2, %i4 ! 2 <PROM_START+0x2> <== NOT EXECUTED
40005dec: f8 26 20 94 st %i4, [ %i0 + 0x94 ] <== NOT EXECUTED
rtems_interrupt_enable (level);
40005df0: 7f ff f1 bc call 400024e0 <sparc_enable_interrupts> <== NOT EXECUTED
40005df4: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain(
40005df8: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED
40005dfc: 92 10 20 00 clr %o1 <== NOT EXECUTED
40005e00: 40 00 09 e3 call 4000858c <rtems_semaphore_obtain> <== NOT EXECUTED
40005e04: 94 10 20 00 clr %o2 <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40005e08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40005e0c: 12 80 00 0b bne 40005e38 <drainOutput.part.0+0x70> <== NOT EXECUTED
40005e10: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
40005e14: 7f ff f1 af call 400024d0 <sparc_disable_interrupts> <== NOT EXECUTED
40005e18: 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) {
40005e1c: c4 06 20 84 ld [ %i0 + 0x84 ], %g2 <== NOT EXECUTED
40005e20: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
40005e24: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40005e28: 32 bf ff f2 bne,a 40005df0 <drainOutput.part.0+0x28> <== NOT EXECUTED
40005e2c: 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);
40005e30: 7f ff f1 ac call 400024e0 <sparc_enable_interrupts>
40005e34: 91 e8 00 08 restore %g0, %o0, %o0
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
40005e38: 40 00 0b ba call 40008d20 <rtems_fatal_error_occurred> <== NOT EXECUTED
40004774 <dup>:
int dup(
int fildes
)
{
return fcntl( fildes, F_DUPFD, 0 );
40004774: 92 10 20 00 clr %o1
40004778: 94 10 20 00 clr %o2
4000477c: 82 13 c0 00 mov %o7, %g1
40004780: 40 00 00 0c call 400047b0 <fcntl>
40004784: 9e 10 40 00 mov %g1, %o7
40004788: 40 00 48 f0 call 40016b48 <__umoddi3+0x36c> <== NOT EXECUTED
4000478c: 40 00 48 e4 call 40016b1c <__umoddi3+0x340> <== NOT EXECUTED
40004790: 40 00 48 c4 call 40016aa0 <__umoddi3+0x2c4> <== NOT EXECUTED
40004794: 40 00 48 a4 call 40016a24 <__umoddi3+0x248> <== NOT EXECUTED
40004798: 40 00 48 50 call 400168d8 <__umoddi3+0xfc> <== NOT EXECUTED
4000479c: 40 00 48 38 call 4001687c <__umoddi3+0xa0> <== NOT EXECUTED
400047a0: 40 00 48 38 call 40016880 <__umoddi3+0xa4> <== NOT EXECUTED
400047a4: 40 00 48 38 call 40016884 <__umoddi3+0xa8> <== NOT EXECUTED
400047a8: 40 00 48 38 call 40016888 <__umoddi3+0xac> <== NOT EXECUTED
400047ac: 40 00 48 38 call 4001688c <__umoddi3+0xb0> <== NOT EXECUTED
40004728 <dup2>:
*/
int dup2(
int fildes,
int fildes2
)
{
40004728: 9d e3 bf 58 save %sp, -168, %sp
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
4000472c: 90 10 00 18 mov %i0, %o0
40004730: 40 00 01 50 call 40004c70 <fstat>
40004734: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
40004738: 80 a2 3f ff cmp %o0, -1
4000473c: 02 80 00 0c be 4000476c <dup2+0x44>
40004740: 90 10 00 19 mov %i1, %o0
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
40004744: 40 00 01 4b call 40004c70 <fstat>
40004748: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
4000474c: 80 a2 3f ff cmp %o0, -1
40004750: 02 80 00 07 be 4000476c <dup2+0x44> <== NEVER TAKEN
40004754: 90 10 00 18 mov %i0, %o0
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
40004758: 92 10 20 00 clr %o1
4000475c: 40 00 00 15 call 400047b0 <fcntl>
40004760: 94 10 00 19 mov %i1, %o2
}
40004764: 81 c7 e0 08 ret
40004768: 91 e8 00 08 restore %g0, %o0, %o0
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
if ( status == -1 )
return -1;
4000476c: 81 c7 e0 08 ret
40004770: 91 e8 3f ff restore %g0, -1, %o0
40006bec <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
40006bec: 9d e3 bf 98 save %sp, -104, %sp
if ((tty->termios.c_lflag & ECHOCTL) &&
40006bf0: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40006bf4: 80 88 62 00 btst 0x200, %g1
40006bf8: 02 80 00 0d be 40006c2c <echo+0x40> <== NEVER TAKEN
40006bfc: 03 10 00 7d sethi %hi(0x4001f400), %g1
iscntrl(c) && (c != '\t') && (c != '\n')) {
40006c00: c2 00 63 60 ld [ %g1 + 0x360 ], %g1 ! 4001f760 <__ctype_ptr__>
40006c04: 82 00 40 18 add %g1, %i0, %g1
40006c08: 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) &&
40006c0c: 80 88 60 20 btst 0x20, %g1
40006c10: 02 80 00 08 be 40006c30 <echo+0x44>
40006c14: 90 10 00 18 mov %i0, %o0
iscntrl(c) && (c != '\t') && (c != '\n')) {
40006c18: 82 06 3f f7 add %i0, -9, %g1
40006c1c: 82 08 60 ff and %g1, 0xff, %g1
40006c20: 80 a0 60 01 cmp %g1, 1
40006c24: 18 80 00 07 bgu 40006c40 <echo+0x54>
40006c28: 82 10 20 5e mov 0x5e, %g1
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
40006c2c: 90 10 00 18 mov %i0, %o0
40006c30: 7f ff ff 8f call 40006a6c <oproc>
40006c34: 92 10 00 19 mov %i1, %o1
40006c38: 81 c7 e0 08 ret
40006c3c: 81 e8 00 00 restore
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
40006c40: 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] = '^';
40006c44: c2 2f bf f8 stb %g1, [ %fp + -8 ]
echobuf[1] = c ^ 0x40;
40006c48: f0 2f bf f9 stb %i0, [ %fp + -7 ]
rtems_termios_puts (echobuf, 2, tty);
40006c4c: 90 07 bf f8 add %fp, -8, %o0
40006c50: 92 10 20 02 mov 2, %o1
40006c54: 7f ff ff 36 call 4000692c <rtems_termios_puts>
40006c58: 94 10 00 19 mov %i1, %o2
tty->column += 2;
40006c5c: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
40006c60: 82 00 60 02 add %g1, 2, %g1
40006c64: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
40006c68: 81 c7 e0 08 ret
40006c6c: 81 e8 00 00 restore
40028928 <endgrent>:
}
void endgrent(void)
{
if (group_fp != NULL)
40028928: 03 10 01 a4 sethi %hi(0x40069000), %g1
4002892c: d0 00 61 68 ld [ %g1 + 0x168 ], %o0 ! 40069168 <group_fp>
40028930: 80 a2 20 00 cmp %o0, 0
40028934: 02 80 00 05 be 40028948 <endgrent+0x20> <== NEVER TAKEN
40028938: 01 00 00 00 nop
fclose(group_fp);
4002893c: 82 13 c0 00 mov %o7, %g1
40028940: 40 00 4f dc call 4003c8b0 <fclose>
40028944: 9e 10 40 00 mov %g1, %o7
40028948: 81 c3 e0 08 retl <== NOT EXECUTED
4002878c <endpwent>:
}
void endpwent(void)
{
if (passwd_fp != NULL)
4002878c: 03 10 01 a4 sethi %hi(0x40069000), %g1
40028790: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 40069088 <passwd_fp>
40028794: 80 a2 20 00 cmp %o0, 0
40028798: 02 80 00 05 be 400287ac <endpwent+0x20> <== NEVER TAKEN
4002879c: 01 00 00 00 nop
fclose(passwd_fp);
400287a0: 82 13 c0 00 mov %o7, %g1
400287a4: 40 00 50 43 call 4003c8b0 <fclose>
400287a8: 9e 10 40 00 mov %g1, %o7
400287ac: 81 c3 e0 08 retl <== NOT EXECUTED
40006c70 <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)
40006c70: 9d e3 bf a0 save %sp, -96, %sp
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
40006c74: 37 10 00 78 sethi %hi(0x4001e000), %i3
* Erase a character or line
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
40006c78: ba 10 00 18 mov %i0, %i5
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
40006c7c: 35 10 00 7d sethi %hi(0x4001f400), %i2
rtems_termios_puts ("\b \b", 3, tty);
40006c80: 31 10 00 78 sethi %hi(0x4001e000), %i0
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
40006c84: b6 16 e1 50 or %i3, 0x150, %i3
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
40006c88: 10 80 00 0f b 40006cc4 <erase.part.2+0x54>
40006c8c: b0 16 21 58 or %i0, 0x158, %i0
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
40006c90: 90 12 21 58 or %o0, 0x158, %o0
40006c94: 92 10 20 03 mov 3, %o1
40006c98: 7f ff ff 25 call 4000692c <rtems_termios_puts>
40006c9c: 94 10 00 1d mov %i5, %o2
if (tty->column)
40006ca0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40006ca4: 80 a0 60 00 cmp %g1, 0
40006ca8: 02 80 00 05 be 40006cbc <erase.part.2+0x4c> <== NEVER TAKEN
40006cac: 80 a6 60 00 cmp %i1, 0
tty->column--;
40006cb0: 82 00 7f ff add %g1, -1, %g1
40006cb4: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
}
}
if (!lineFlag)
40006cb8: 80 a6 60 00 cmp %i1, 0
40006cbc: 02 80 00 58 be 40006e1c <erase.part.2+0x1ac>
40006cc0: 01 00 00 00 nop
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
40006cc4: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40006cc8: 80 a0 a0 00 cmp %g2, 0
40006ccc: 02 80 00 54 be 40006e1c <erase.part.2+0x1ac>
40006cd0: 84 00 bf ff add %g2, -1, %g2
unsigned char c = tty->cbuf[--tty->ccount];
40006cd4: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
if (tty->termios.c_lflag & ECHO) {
40006cd8: c6 07 60 3c ld [ %i5 + 0x3c ], %g3
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
40006cdc: c4 27 60 20 st %g2, [ %i5 + 0x20 ]
if (tty->termios.c_lflag & ECHO) {
40006ce0: 80 88 e0 08 btst 8, %g3
40006ce4: 02 bf ff f5 be 40006cb8 <erase.part.2+0x48> <== NEVER TAKEN
40006ce8: c2 09 00 02 ldub [ %g4 + %g2 ], %g1
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
40006cec: 80 a6 60 00 cmp %i1, 0
40006cf0: 12 80 00 05 bne 40006d04 <erase.part.2+0x94>
40006cf4: 82 08 60 ff and %g1, 0xff, %g1
40006cf8: 80 88 e0 10 btst 0x10, %g3
40006cfc: 22 80 00 4d be,a 40006e30 <erase.part.2+0x1c0> <== NEVER TAKEN
40006d00: f0 0f 60 43 ldub [ %i5 + 0x43 ], %i0 <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
40006d04: 80 a0 60 09 cmp %g1, 9
40006d08: 02 80 00 1e be 40006d80 <erase.part.2+0x110>
40006d0c: 80 a0 a0 00 cmp %g2, 0
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
40006d10: c4 06 a3 60 ld [ %i2 + 0x360 ], %g2
40006d14: b8 00 60 01 add %g1, 1, %i4
40006d18: c2 08 80 1c ldub [ %g2 + %i4 ], %g1
40006d1c: 80 88 60 20 btst 0x20, %g1
40006d20: 02 bf ff dc be 40006c90 <erase.part.2+0x20> <== ALWAYS TAKEN
40006d24: 11 10 00 78 sethi %hi(0x4001e000), %o0
40006d28: 80 88 e2 00 btst 0x200, %g3 <== NOT EXECUTED
40006d2c: 02 bf ff e4 be 40006cbc <erase.part.2+0x4c> <== NOT EXECUTED
40006d30: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
40006d34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40006d38: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
40006d3c: 7f ff fe fc call 4000692c <rtems_termios_puts> <== NOT EXECUTED
40006d40: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
if (tty->column)
40006d44: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
40006d48: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006d4c: 12 80 00 3b bne 40006e38 <erase.part.2+0x1c8> <== NOT EXECUTED
40006d50: 11 10 00 78 sethi %hi(0x4001e000), %o0 <== NOT EXECUTED
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
40006d54: c2 06 a3 60 ld [ %i2 + 0x360 ], %g1 <== NOT EXECUTED
40006d58: c2 08 40 1c ldub [ %g1 + %i4 ], %g1 <== NOT EXECUTED
40006d5c: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
40006d60: 22 bf ff cd be,a 40006c94 <erase.part.2+0x24> <== NOT EXECUTED
40006d64: 90 12 21 58 or %o0, 0x158, %o0 <== NOT EXECUTED
40006d68: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
40006d6c: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
40006d70: 32 bf ff c9 bne,a 40006c94 <erase.part.2+0x24> <== NOT EXECUTED
40006d74: 90 12 21 58 or %o0, 0x158, %o0 <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
40006d78: 10 bf ff d1 b 40006cbc <erase.part.2+0x4c> <== NOT EXECUTED
40006d7c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
40006d80: 02 80 00 17 be 40006ddc <erase.part.2+0x16c>
40006d84: f8 07 60 2c ld [ %i5 + 0x2c ], %i4
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
40006d88: da 06 a3 60 ld [ %i2 + 0x360 ], %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;
40006d8c: 82 10 20 00 clr %g1
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
40006d90: 10 80 00 07 b 40006dac <erase.part.2+0x13c>
40006d94: 98 08 e2 00 and %g3, 0x200, %o4
40006d98: 32 80 00 02 bne,a 40006da0 <erase.part.2+0x130> <== NOT EXECUTED
40006d9c: b8 07 20 02 add %i4, 2, %i4 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
40006da0: 80 a0 80 01 cmp %g2, %g1
40006da4: 22 80 00 0f be,a 40006de0 <erase.part.2+0x170> <== NEVER TAKEN
40006da8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
c = tty->cbuf[i++];
40006dac: c6 09 00 01 ldub [ %g4 + %g1 ], %g3
40006db0: 82 00 60 01 inc %g1
if (c == '\t') {
40006db4: 80 a0 e0 09 cmp %g3, 9
40006db8: 02 80 00 1b be 40006e24 <erase.part.2+0x1b4>
40006dbc: 9e 03 40 03 add %o5, %g3, %o7
col = (col | 7) + 1;
} else if (iscntrl (c)) {
40006dc0: de 0b e0 01 ldub [ %o7 + 1 ], %o7
40006dc4: 80 8b e0 20 btst 0x20, %o7
40006dc8: 12 bf ff f4 bne 40006d98 <erase.part.2+0x128> <== NEVER TAKEN
40006dcc: 80 a3 20 00 cmp %o4, 0
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
40006dd0: 80 a0 80 01 cmp %g2, %g1
40006dd4: 12 bf ff f6 bne 40006dac <erase.part.2+0x13c>
40006dd8: b8 07 20 01 inc %i4
}
/*
* Back up over the tab
*/
while (tty->column > col) {
40006ddc: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40006de0: 80 a0 40 1c cmp %g1, %i4
40006de4: 04 bf ff b6 ble 40006cbc <erase.part.2+0x4c> <== NEVER TAKEN
40006de8: 80 a6 60 00 cmp %i1, 0
rtems_termios_puts ("\b", 1, tty);
40006dec: 90 10 00 1b mov %i3, %o0
40006df0: 92 10 20 01 mov 1, %o1
40006df4: 7f ff fe ce call 4000692c <rtems_termios_puts>
40006df8: 94 10 00 1d mov %i5, %o2
tty->column--;
40006dfc: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40006e00: 82 00 7f ff add %g1, -1, %g1
}
/*
* Back up over the tab
*/
while (tty->column > col) {
40006e04: 80 a0 40 1c cmp %g1, %i4
40006e08: 14 bf ff f9 bg 40006dec <erase.part.2+0x17c>
40006e0c: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
40006e10: 80 a6 60 00 cmp %i1, 0
40006e14: 32 bf ff ad bne,a 40006cc8 <erase.part.2+0x58> <== ALWAYS TAKEN
40006e18: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40006e1c: 81 c7 e0 08 ret
40006e20: 81 e8 00 00 restore
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
40006e24: b8 17 20 07 or %i4, 7, %i4
40006e28: 10 bf ff de b 40006da0 <erase.part.2+0x130>
40006e2c: b8 07 20 01 inc %i4
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
40006e30: 7f ff ff 6f call 40006bec <echo> <== NOT EXECUTED
40006e34: 93 e8 00 1d restore %g0, %i5, %o1 <== NOT EXECUTED
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
40006e38: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
40006e3c: 10 bf ff c6 b 40006d54 <erase.part.2+0xe4> <== NOT EXECUTED
40006e40: c2 27 60 28 st %g1, [ %i5 + 0x28 ] <== NOT EXECUTED
400052dc <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
)
{
400052dc: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
400052e0: 92 10 20 00 clr %o1
400052e4: 90 10 00 18 mov %i0, %o0
400052e8: 40 00 30 24 call 40011378 <memset>
400052ec: 94 10 20 38 mov 0x38, %o2
ctx->path = path;
400052f0: f2 26 00 00 st %i1, [ %i0 ]
ctx->pathlen = pathlen;
400052f4: 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) {
400052f8: 80 a6 a0 00 cmp %i2, 0
400052fc: 02 80 00 21 be 40005380 <eval_path_start+0xa4>
40005300: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
40005304: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
40005308: 40 00 01 a3 call 40005994 <rtems_filesystem_global_location_obtain>
4000530c: 90 10 00 1c mov %i4, %o0
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
40005310: 83 2e e0 18 sll %i3, 0x18, %g1
40005314: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
40005318: 80 a0 60 5c cmp %g1, 0x5c
4000531c: 12 80 00 32 bne 400053e4 <eval_path_start+0x108> <== ALWAYS TAKEN
40005320: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
++ctx->path;
40005324: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
--ctx->pathlen;
40005328: c2 06 20 04 ld [ %i0 + 4 ], %g1
char c = ctx->path [0];
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
if (rtems_filesystem_is_delimiter(c)) {
++ctx->path;
4000532c: 84 00 a0 01 inc %g2
--ctx->pathlen;
40005330: 82 00 7f ff add %g1, -1, %g1
char c = ctx->path [0];
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
if (rtems_filesystem_is_delimiter(c)) {
++ctx->path;
40005334: c4 26 00 00 st %g2, [ %i0 ]
--ctx->pathlen;
40005338: c2 26 20 04 st %g1, [ %i0 + 4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
4000533c: 40 00 01 96 call 40005994 <rtems_filesystem_global_location_obtain>
40005340: 90 06 20 30 add %i0, 0x30, %o0
40005344: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
40005348: 82 10 00 08 mov %o0, %g1
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
4000534c: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40005350: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005354: c2 00 40 00 ld [ %g1 ], %g1
40005358: 9f c0 40 00 call %g1
4000535c: 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(
40005360: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40005364: 40 00 1f 19 call 4000cfc8 <rtems_filesystem_location_clone>
40005368: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
4000536c: 90 10 00 18 mov %i0, %o0
40005370: 7f ff ff be call 40005268 <rtems_filesystem_eval_path_continue>
40005374: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
40005378: 81 c7 e0 08 ret
4000537c: 81 e8 00 00 restore
);
static inline rtems_filesystem_global_location_t *
rtems_filesystem_global_location_obtain_null(void)
{
rtems_filesystem_global_location_t *global_loc = NULL;
40005380: c0 27 bf fc clr [ %fp + -4 ]
return rtems_filesystem_global_location_obtain( &global_loc );
40005384: 40 00 01 84 call 40005994 <rtems_filesystem_global_location_obtain>
40005388: 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;
4000538c: c0 27 bf fc clr [ %fp + -4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
global_current_ptr
);
}
} else {
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
40005390: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
return rtems_filesystem_global_location_obtain( &global_loc );
40005394: 40 00 01 80 call 40005994 <rtems_filesystem_global_location_obtain>
40005398: 90 07 bf fc add %fp, -4, %o0
ctx->startloc = rtems_filesystem_global_location_obtain_null();
errno = ENOENT;
4000539c: 40 00 2d 69 call 40010940 <__errno>
400053a0: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
400053a4: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
400053a8: 84 10 20 02 mov 2, %g2
400053ac: c4 22 00 00 st %g2, [ %o0 ]
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
400053b0: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
400053b4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400053b8: c2 00 40 00 ld [ %g1 ], %g1
400053bc: 9f c0 40 00 call %g1
400053c0: 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(
400053c4: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
400053c8: 40 00 1f 00 call 4000cfc8 <rtems_filesystem_location_clone>
400053cc: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
400053d0: 90 10 00 18 mov %i0, %o0
400053d4: 7f ff ff a5 call 40005268 <rtems_filesystem_eval_path_continue>
400053d8: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
400053dc: 81 c7 e0 08 ret
400053e0: 81 e8 00 00 restore
if (ctx->pathlen > 0) {
char c = ctx->path [0];
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
if (rtems_filesystem_is_delimiter(c)) {
400053e4: 80 a0 60 2f cmp %g1, 0x2f
400053e8: 22 bf ff d0 be,a 40005328 <eval_path_start+0x4c>
400053ec: c4 06 00 00 ld [ %i0 ], %g2
--ctx->pathlen;
ctx->startloc = rtems_filesystem_global_location_obtain(
&ctx->rootloc
);
} else {
ctx->startloc = rtems_filesystem_global_location_obtain(
400053f0: 40 00 01 69 call 40005994 <rtems_filesystem_global_location_obtain>
400053f4: 90 10 00 1d mov %i5, %o0
400053f8: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
400053fc: 82 10 00 08 mov %o0, %g1
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40005400: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40005404: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005408: c2 00 40 00 ld [ %g1 ], %g1
4000540c: 9f c0 40 00 call %g1
40005410: 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(
40005414: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40005418: 40 00 1e ec call 4000cfc8 <rtems_filesystem_location_clone>
4000541c: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
40005420: 90 10 00 18 mov %i0, %o0
40005424: 7f ff ff 91 call 40005268 <rtems_filesystem_eval_path_continue>
40005428: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
4000542c: 81 c7 e0 08 ret
40005430: 81 e8 00 00 restore
40014620 <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)
{
40014620: 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);
40014624: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
40014628: c4 0e 20 0c ldub [ %i0 + 0xc ], %g2
sec_num);
uint32_t blk_ofs = fat_sector_offset_to_block_offset (fs_info,
sec_num,
0);
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
4001462c: c6 0e 20 89 ldub [ %i0 + 0x89 ], %g3
40014630: 84 20 80 01 sub %g2, %g1, %g2
40014634: 80 a0 e0 00 cmp %g3, 0
40014638: 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);
4001463c: 85 2f 40 02 sll %i5, %g2, %g2
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
40014640: 84 26 40 02 sub %i1, %g2, %g2
40014644: 02 80 00 06 be 4001465c <fat_buf_access+0x3c>
40014648: b9 28 80 01 sll %g2, %g1, %i4
4001464c: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
40014650: 80 a0 40 19 cmp %g1, %i1
40014654: 22 80 00 12 be,a 4001469c <fat_buf_access+0x7c>
40014658: c2 06 20 8c ld [ %i0 + 0x8c ], %g1
{
fat_buf_release(fs_info);
4001465c: 7f ff ff 7a call 40014444 <fat_buf_release>
40014660: 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);
40014664: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
40014668: 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)
4001466c: 80 a6 a0 01 cmp %i2, 1
40014670: 02 80 00 10 be 400146b0 <fat_buf_access+0x90>
40014674: 94 06 20 8c add %i0, 0x8c, %o2
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
40014678: 7f ff f6 c9 call 4001219c <rtems_bdbuf_get>
4001467c: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
40014680: 80 a2 20 00 cmp %o0, 0
40014684: 12 80 00 0f bne 400146c0 <fat_buf_access+0xa0> <== NEVER TAKEN
40014688: 82 10 20 01 mov 1, %g1
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = sec_num;
4001468c: f2 26 20 84 st %i1, [ %i0 + 0x84 ]
fs_info->c.modified = 0;
40014690: c0 2e 20 88 clrb [ %i0 + 0x88 ]
fs_info->c.state = FAT_CACHE_ACTUAL;
40014694: c2 2e 20 89 stb %g1, [ %i0 + 0x89 ]
}
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
40014698: c2 06 20 8c ld [ %i0 + 0x8c ], %g1
4001469c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
400146a0: b8 00 40 1c add %g1, %i4, %i4
400146a4: f8 26 c0 00 st %i4, [ %i3 ]
return RC_OK;
}
400146a8: 81 c7 e0 08 ret
400146ac: 91 e8 20 00 restore %g0, 0, %o0
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
{
fat_buf_release(fs_info);
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
400146b0: 7f ff f6 fb call 4001229c <rtems_bdbuf_read>
400146b4: 01 00 00 00 nop
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
400146b8: 10 bf ff f3 b 40014684 <fat_buf_access+0x64>
400146bc: 80 a2 20 00 cmp %o0, 0
rtems_set_errno_and_return_minus_one(EIO);
400146c0: 40 00 23 b4 call 4001d590 <__errno> <== NOT EXECUTED
400146c4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400146c8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
400146cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400146d0: 81 c7 e0 08 ret <== NOT EXECUTED
400146d4: 81 e8 00 00 restore <== NOT EXECUTED
40014444 <fat_buf_release>:
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
40014444: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
40014448: c2 0e 20 89 ldub [ %i0 + 0x89 ], %g1
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
4001444c: ba 10 00 18 mov %i0, %i5
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
40014450: 80 a0 60 00 cmp %g1, 0
40014454: 02 80 00 6b be 40014600 <fat_buf_release+0x1bc>
40014458: b0 10 20 00 clr %i0
return RC_OK;
if (fs_info->c.modified)
4001445c: c2 0f 60 88 ldub [ %i5 + 0x88 ], %g1
40014460: 80 a0 60 00 cmp %g1, 0
40014464: 02 80 00 47 be 40014580 <fat_buf_release+0x13c>
40014468: 01 00 00 00 nop
{
uint32_t sec_num = fs_info->c.blk_num;
4001446c: c2 07 60 84 ld [ %i5 + 0x84 ], %g1
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
40014470: c4 17 60 18 lduh [ %i5 + 0x18 ], %g2
40014474: 80 a0 40 02 cmp %g1, %g2
40014478: 0a 80 00 06 bcs 40014490 <fat_buf_release+0x4c>
4001447c: b8 10 20 00 clr %i4
40014480: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40014484: 80 a0 40 02 cmp %g1, %g2
40014488: 2a 80 00 46 bcs,a 400145a0 <fat_buf_release+0x15c>
4001448c: c4 0f 60 54 ldub [ %i5 + 0x54 ], %g2
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
40014490: 7f ff f8 40 call 40012590 <rtems_bdbuf_release_modified>
40014494: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if (sc != RTEMS_SUCCESSFUL)
40014498: 80 a2 20 00 cmp %o0, 0
4001449c: 12 80 00 5b bne 40014608 <fat_buf_release+0x1c4> <== NEVER TAKEN
400144a0: 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)
400144a4: 02 80 00 3c be 40014594 <fat_buf_release+0x150>
400144a8: c0 2f 60 88 clrb [ %i5 + 0x88 ]
400144ac: c2 0f 60 54 ldub [ %i5 + 0x54 ], %g1
400144b0: 80 a0 60 00 cmp %g1, 0
400144b4: 32 80 00 39 bne,a 40014598 <fat_buf_release+0x154> <== NEVER TAKEN
400144b8: c0 2f 60 89 clrb [ %i5 + 0x89 ] <== NOT EXECUTED
{
uint8_t i;
for (i = 1; i < fs_info->vol.fats; i++)
400144bc: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
400144c0: 80 a0 60 01 cmp %g1, 1
400144c4: 08 80 00 34 bleu 40014594 <fat_buf_release+0x150> <== NEVER TAKEN
400144c8: b6 10 20 01 mov 1, %i3
400144cc: 10 80 00 16 b 40014524 <fat_buf_release+0xe0>
400144d0: 90 10 20 01 mov 1, %o0
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
}
else
{
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
400144d4: 7f ff f7 72 call 4001229c <rtems_bdbuf_read>
400144d8: 94 07 bf fc add %fp, -4, %o2
}
if ( sc != RTEMS_SUCCESSFUL)
400144dc: 80 a2 20 00 cmp %o0, 0
400144e0: 12 80 00 44 bne 400145f0 <fat_buf_release+0x1ac> <== NEVER TAKEN
400144e4: c2 07 bf fc ld [ %fp + -4 ], %g1
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
400144e8: d2 07 60 90 ld [ %i5 + 0x90 ], %o1
400144ec: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
400144f0: d4 17 40 00 lduh [ %i5 ], %o2
400144f4: 40 00 26 cc call 4001e024 <memcpy>
400144f8: 90 02 00 1c add %o0, %i4, %o0
sc = rtems_bdbuf_release_modified(bd);
400144fc: d0 07 bf fc ld [ %fp + -4 ], %o0
40014500: 7f ff f8 24 call 40012590 <rtems_bdbuf_release_modified>
40014504: b6 06 e0 01 inc %i3
if ( sc != RTEMS_SUCCESSFUL)
40014508: 80 a2 20 00 cmp %o0, 0
4001450c: 12 80 00 39 bne 400145f0 <fat_buf_release+0x1ac> <== NEVER TAKEN
40014510: 90 0e e0 ff and %i3, 0xff, %o0
if (sec_of_fat && !fs_info->vol.mirror)
{
uint8_t i;
for (i = 1; i < fs_info->vol.fats; i++)
40014514: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
40014518: 80 a2 00 01 cmp %o0, %g1
4001451c: 3a 80 00 1f bcc,a 40014598 <fat_buf_release+0x154> <== ALWAYS TAKEN
40014520: c0 2f 60 89 clrb [ %i5 + 0x89 ]
{
rtems_bdbuf_buffer *bd;
sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
40014524: 7f ff b8 1a call 4000258c <.umul>
40014528: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4001452c: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
40014530: c6 07 60 84 ld [ %i5 + 0x84 ], %g3
40014534: c4 0f 60 0c ldub [ %i5 + 0xc ], %g2
40014538: 90 02 00 03 add %o0, %g3, %o0
4001453c: 84 20 80 01 sub %g2, %g1, %g2
40014540: 93 32 00 02 srl %o0, %g2, %o1
static inline uint32_t
fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,
const uint32_t block_number)
{
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
40014544: 85 2a 40 02 sll %o1, %g2, %g2
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
40014548: 90 22 00 02 sub %o0, %g2, %o0
fat_block_num_to_sector_num (fs_info,
fat_sector_num_to_block_num (fs_info, sector)))
<< fs_info->vol.sec_log2);
4001454c: b9 2a 00 01 sll %o0, %g1, %i4
blk = fat_sector_num_to_block_num(fs_info, sec_num);
blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (blk_ofs == 0
40014550: 80 a7 20 00 cmp %i4, 0
40014554: 12 bf ff e0 bne 400144d4 <fat_buf_release+0x90>
40014558: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
&& fs_info->vol.bps == fs_info->vol.bytes_per_block)
4001455c: c4 17 40 00 lduh [ %i5 ], %g2
40014560: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
40014564: 80 a0 80 01 cmp %g2, %g1
40014568: 12 bf ff db bne 400144d4 <fat_buf_release+0x90>
4001456c: 01 00 00 00 nop
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
40014570: 7f ff f7 0b call 4001219c <rtems_bdbuf_get>
40014574: 94 07 bf fc add %fp, -4, %o2
}
else
{
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
}
if ( sc != RTEMS_SUCCESSFUL)
40014578: 10 bf ff da b 400144e0 <fat_buf_release+0x9c>
4001457c: 80 a2 20 00 cmp %o0, 0
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
40014580: 7f ff f7 cc call 400124b0 <rtems_bdbuf_release>
40014584: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if (sc != RTEMS_SUCCESSFUL)
40014588: 80 a2 20 00 cmp %o0, 0
4001458c: 12 80 00 1f bne 40014608 <fat_buf_release+0x1c4> <== NEVER TAKEN
40014590: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
40014594: c0 2f 60 89 clrb [ %i5 + 0x89 ]
return RC_OK;
40014598: 81 c7 e0 08 ret
4001459c: 91 e8 20 00 restore %g0, 0, %o0
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
400145a0: c8 0f 60 02 ldub [ %i5 + 2 ], %g4
400145a4: c6 0f 60 0c ldub [ %i5 + 0xc ], %g3
uint32_t blk = fat_sector_num_to_block_num(fs_info, sec_num);
uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (sec_of_fat && !fs_info->vol.mirror)
400145a8: 80 a0 a0 00 cmp %g2, 0
400145ac: 12 bf ff b9 bne 40014490 <fat_buf_release+0x4c> <== NEVER TAKEN
400145b0: b8 10 20 01 mov 1, %i4
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
400145b4: c4 07 60 8c ld [ %i5 + 0x8c ], %g2
uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf,
400145b8: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
400145bc: d2 00 a0 1c ld [ %g2 + 0x1c ], %o1
400145c0: d4 17 40 00 lduh [ %i5 ], %o2
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
400145c4: 84 09 20 ff and %g4, 0xff, %g2
400145c8: 86 08 e0 ff and %g3, 0xff, %g3
400145cc: 86 20 c0 02 sub %g3, %g2, %g3
400145d0: 89 30 40 03 srl %g1, %g3, %g4
static inline uint32_t
fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,
const uint32_t block_number)
{
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
400145d4: 87 29 00 03 sll %g4, %g3, %g3
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
400145d8: 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);
400145dc: 85 28 40 02 sll %g1, %g2, %g2
return RC_OK;
if (fs_info->c.modified)
{
uint32_t sec_num = fs_info->c.blk_num;
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
400145e0: b8 10 20 01 mov 1, %i4
uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf,
400145e4: 40 00 26 90 call 4001e024 <memcpy>
400145e8: 92 02 40 02 add %o1, %g2, %o1
400145ec: 30 bf ff a9 b,a 40014490 <fat_buf_release+0x4c>
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(bd);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
400145f0: 40 00 23 e8 call 4001d590 <__errno> <== NOT EXECUTED
400145f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400145f8: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
400145fc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40014600: 81 c7 e0 08 ret
40014604: 81 e8 00 00 restore
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
40014608: 40 00 23 e2 call 4001d590 <__errno> <== NOT EXECUTED
4001460c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014610: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40014614: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40014618: 81 c7 e0 08 ret <== NOT EXECUTED
4001461c: 81 e8 00 00 restore <== NOT EXECUTED
40014808 <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)
{
40014808: 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));
4001480c: c2 16 20 06 lduh [ %i0 + 6 ], %g1
40014810: 82 20 40 1a sub %g1, %i2, %g1
40014814: 80 a6 c0 01 cmp %i3, %g1
40014818: 38 80 00 02 bgu,a 40014820 <fat_cluster_set+0x18> <== NEVER TAKEN
4001481c: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
fat_cluster_num_to_block_num (const fat_fs_info_t *fs_info,
uint32_t cln)
{
uint32_t blk;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40014820: 80 a6 60 00 cmp %i1, 0
40014824: 32 80 00 06 bne,a 4001483c <fat_cluster_set+0x34> <== ALWAYS TAKEN
40014828: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
4001482c: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1 <== NOT EXECUTED
40014830: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
40014834: 12 80 00 50 bne 40014974 <fat_cluster_set+0x16c> <== NOT EXECUTED
40014838: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
4001483c: e0 0e 20 02 ldub [ %i0 + 2 ], %l0
40014840: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
40014844: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
40014848: a0 20 40 10 sub %g1, %l0, %l0
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
4001484c: b2 06 7f fe add %i1, -2, %i1
40014850: a1 30 c0 10 srl %g3, %l0, %l0
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
40014854: 84 20 80 01 sub %g2, %g1, %g2
40014858: b3 2e 40 02 sll %i1, %g2, %i1
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
4001485c: a0 04 00 19 add %l0, %i1, %l0
const uint8_t pattern)
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
40014860: 85 36 80 01 srl %i2, %g1, %g2
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
40014864: 83 28 80 01 sll %g2, %g1, %g1
ssize_t bytes_written = 0;
40014868: a2 10 20 00 clr %l1
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
4001486c: b4 26 80 01 sub %i2, %g1, %i2
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
40014870: a0 00 80 10 add %g2, %l0, %l0
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const uint8_t pattern)
{
ssize_t rc = RC_OK;
40014874: 82 10 20 00 clr %g1
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
40014878: 80 a6 e0 00 cmp %i3, 0
4001487c: 02 80 00 25 be 40014910 <fat_cluster_set+0x108> <== NEVER TAKEN
40014880: a4 10 20 01 mov 1, %l2
40014884: 80 a0 60 00 cmp %g1, 0
40014888: 32 80 00 39 bne,a 4001496c <fat_cluster_set+0x164> <== NEVER TAKEN
4001488c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
&& (0 < bytes_to_write))
{
uint32_t c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
40014890: c4 16 20 0a lduh [ %i0 + 0xa ], %g2
40014894: 82 20 80 1a sub %g2, %i2, %g1
40014898: 80 a0 40 1b cmp %g1, %i3
4001489c: 08 80 00 03 bleu 400148a8 <fat_cluster_set+0xa0> <== ALWAYS TAKEN
400148a0: ba 10 00 01 mov %g1, %i5
400148a4: 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));
400148a8: 80 a7 40 01 cmp %i5, %g1
400148ac: 08 80 00 03 bleu 400148b8 <fat_cluster_set+0xb0> <== ALWAYS TAKEN
400148b0: b2 10 00 1d mov %i5, %i1
400148b4: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
400148b8: 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)
400148bc: 80 a6 60 00 cmp %i1, 0
400148c0: 02 80 00 24 be 40014950 <fat_cluster_set+0x148> <== NEVER TAKEN
400148c4: 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);
400148c8: 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);
400148cc: 90 10 00 18 mov %i0, %o0
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
{
if (bytes_to_write == fs_info->vol.bytes_per_block)
400148d0: 80 a0 80 19 cmp %g2, %i1
400148d4: 02 80 00 21 be 40014958 <fat_cluster_set+0x150>
400148d8: 93 2c 00 09 sll %l0, %o1, %o1
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
400148dc: 94 10 20 01 mov 1, %o2
400148e0: 7f ff ff 50 call 40014620 <fat_buf_access>
400148e4: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
400148e8: 80 a2 20 00 cmp %o0, 0
400148ec: 22 80 00 14 be,a 4001493c <fat_cluster_set+0x134> <== ALWAYS TAKEN
400148f0: d0 07 bf fc ld [ %fp + -4 ], %o0
fs_info,
cur_blk,
ofs_blk,
c,
pattern);
if (c != ret)
400148f4: 80 a2 00 1d cmp %o0, %i5
400148f8: 02 80 00 0b be 40014924 <fat_cluster_set+0x11c> <== ALWAYS TAKEN
400148fc: 82 10 3f ff mov -1, %g1
40014900: b4 10 20 00 clr %i2 <== NOT EXECUTED
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
40014904: 80 a6 e0 00 cmp %i3, 0
40014908: 12 bf ff e0 bne 40014888 <fat_cluster_set+0x80> <== NEVER TAKEN
4001490c: 80 a0 60 00 cmp %g1, 0
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
40014910: 80 a0 60 00 cmp %g1, 0
40014914: 12 80 00 16 bne 4001496c <fat_cluster_set+0x164> <== NEVER TAKEN
40014918: b0 10 3f ff mov -1, %i0
4001491c: 81 c7 e0 08 ret
40014920: 91 e8 00 11 restore %g0, %l1, %o0
pattern);
if (c != ret)
rc = -1;
else
{
bytes_to_write -= ret;
40014924: b6 26 c0 08 sub %i3, %o0, %i3
bytes_written += ret;
40014928: a2 04 40 08 add %l1, %o0, %l1
++cur_blk;
4001492c: a0 04 20 01 inc %l0
40014930: 82 10 20 00 clr %g1
40014934: 10 bf ff f4 b 40014904 <fat_cluster_set+0xfc>
40014938: b4 10 20 00 clr %i2
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
if (RC_OK == rc)
{
memset(blk_buf + offset, pattern, bytes_to_write);
4001493c: 92 10 00 1c mov %i4, %o1
40014940: 90 02 00 1a add %o0, %i2, %o0
40014944: 40 00 25 f5 call 4001e118 <memset>
40014948: 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;
4001494c: e4 2e 20 88 stb %l2, [ %i0 + 0x88 ]
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
40014950: 10 bf ff e9 b 400148f4 <fat_cluster_set+0xec>
40014954: 90 10 00 19 mov %i1, %o0
if (0 < bytes_to_write)
{
if (bytes_to_write == fs_info->vol.bytes_per_block)
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
40014958: 94 10 20 02 mov 2, %o2
4001495c: 7f ff ff 31 call 40014620 <fat_buf_access>
40014960: 96 07 bf fc add %fp, -4, %o3
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
if (RC_OK == rc)
40014964: 10 bf ff e2 b 400148ec <fat_cluster_set+0xe4>
40014968: 80 a2 20 00 cmp %o0, 0
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
4001496c: 81 c7 e0 08 ret <== NOT EXECUTED
40014970: 81 e8 00 00 restore <== NOT EXECUTED
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
40014974: c4 0e 20 02 ldub [ %i0 + 2 ], %g2 <== NOT EXECUTED
40014978: e0 06 20 20 ld [ %i0 + 0x20 ], %l0 <== NOT EXECUTED
4001497c: 84 20 40 02 sub %g1, %g2, %g2 <== NOT EXECUTED
40014980: 10 bf ff b8 b 40014860 <fat_cluster_set+0x58> <== NOT EXECUTED
40014984: a1 34 00 02 srl %l0, %g2, %l0 <== NOT EXECUTED
40014988 <fat_cluster_write>:
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const void *buff,
const bool overwrite_cluster)
{
40014988: 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));
4001498c: c2 16 20 06 lduh [ %i0 + 6 ], %g1
40014990: 82 20 40 1a sub %g1, %i2, %g1
40014994: 80 a6 c0 01 cmp %i3, %g1
40014998: 38 80 00 02 bgu,a 400149a0 <fat_cluster_write+0x18> <== NEVER TAKEN
4001499c: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
fat_cluster_num_to_block_num (const fat_fs_info_t *fs_info,
uint32_t cln)
{
uint32_t blk;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400149a0: 80 a6 60 00 cmp %i1, 0
400149a4: 32 80 00 06 bne,a 400149bc <fat_cluster_write+0x34>
400149a8: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
400149ac: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
400149b0: 80 88 60 03 btst 3, %g1
400149b4: 12 80 00 52 bne 40014afc <fat_cluster_write+0x174> <== ALWAYS TAKEN
400149b8: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1
400149bc: e2 0e 20 02 ldub [ %i0 + 2 ], %l1
400149c0: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
400149c4: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
400149c8: a2 20 40 11 sub %g1, %l1, %l1
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
400149cc: b2 06 7f fe add %i1, -2, %i1
400149d0: a3 30 c0 11 srl %g3, %l1, %l1
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
400149d4: 84 20 80 01 sub %g2, %g1, %g2
400149d8: b3 2e 40 02 sll %i1, %g2, %i1
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
400149dc: a2 04 40 19 add %l1, %i1, %l1
const bool overwrite_cluster)
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
400149e0: 85 36 80 01 srl %i2, %g1, %g2
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
400149e4: 83 28 80 01 sll %g2, %g1, %g1
ssize_t bytes_written = 0;
400149e8: a4 10 20 00 clr %l2
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
400149ec: 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;
400149f0: a2 00 80 11 add %g2, %l1, %l1
const uint32_t offset,
const uint32_t count,
const void *buff,
const bool overwrite_cluster)
{
ssize_t rc = RC_OK;
400149f4: 82 10 20 00 clr %g1
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
400149f8: 80 a6 e0 00 cmp %i3, 0
400149fc: 02 80 00 27 be 40014a98 <fat_cluster_write+0x110> <== NEVER TAKEN
40014a00: a6 10 20 01 mov 1, %l3
40014a04: 80 a0 60 00 cmp %g1, 0
40014a08: 32 80 00 3b bne,a 40014af4 <fat_cluster_write+0x16c> <== NEVER TAKEN
40014a0c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
&& (0 < bytes_to_write))
{
c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
40014a10: c4 16 20 0a lduh [ %i0 + 0xa ], %g2
40014a14: 82 20 80 1a sub %g2, %i2, %g1
40014a18: 80 a0 40 1b cmp %g1, %i3
40014a1c: 08 80 00 03 bleu 40014a28 <fat_cluster_write+0xa0>
40014a20: b2 10 00 01 mov %g1, %i1
40014a24: 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));
40014a28: 80 a6 40 01 cmp %i1, %g1
40014a2c: 08 80 00 03 bleu 40014a38 <fat_cluster_write+0xb0> <== ALWAYS TAKEN
40014a30: a0 10 00 19 mov %i1, %l0
40014a34: a0 10 00 01 mov %g1, %l0 <== NOT EXECUTED
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
40014a38: 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)
40014a3c: 80 a4 20 00 cmp %l0, 0
40014a40: 02 80 00 26 be 40014ad8 <fat_cluster_write+0x150> <== NEVER TAKEN
40014a44: 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);
40014a48: 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);
40014a4c: 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
40014a50: 80 a7 60 00 cmp %i5, 0
40014a54: 12 80 00 23 bne 40014ae0 <fat_cluster_write+0x158>
40014a58: 93 2c 40 09 sll %l1, %o1, %o1
|| (bytes_to_write == fs_info->vol.bytes_per_block))
40014a5c: 80 a0 80 10 cmp %g2, %l0
40014a60: 02 80 00 20 be 40014ae0 <fat_cluster_write+0x158>
40014a64: 94 10 20 01 mov 1, %o2
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
40014a68: 7f ff fe ee call 40014620 <fat_buf_access>
40014a6c: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
40014a70: 80 a2 20 00 cmp %o0, 0
40014a74: 22 80 00 14 be,a 40014ac4 <fat_cluster_write+0x13c> <== ALWAYS TAKEN
40014a78: d0 07 bf fc ld [ %fp + -4 ], %o0
cur_blk,
ofs_blk,
c,
&buffer[bytes_written],
overwrite_cluster);
if (c != ret)
40014a7c: 80 a2 00 19 cmp %o0, %i1
40014a80: 02 80 00 0b be 40014aac <fat_cluster_write+0x124> <== ALWAYS TAKEN
40014a84: 82 10 3f ff mov -1, %g1
40014a88: b4 10 20 00 clr %i2 <== NOT EXECUTED
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
40014a8c: 80 a6 e0 00 cmp %i3, 0
40014a90: 12 bf ff de bne 40014a08 <fat_cluster_write+0x80> <== NEVER TAKEN
40014a94: 80 a0 60 00 cmp %g1, 0
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
40014a98: 80 a0 60 00 cmp %g1, 0
40014a9c: 12 80 00 16 bne 40014af4 <fat_cluster_write+0x16c> <== NEVER TAKEN
40014aa0: b0 10 3f ff mov -1, %i0
40014aa4: 81 c7 e0 08 ret
40014aa8: 91 e8 00 12 restore %g0, %l2, %o0
overwrite_cluster);
if (c != ret)
rc = -1;
else
{
bytes_to_write -= ret;
40014aac: b6 26 c0 08 sub %i3, %o0, %i3
bytes_written += ret;
40014ab0: a4 04 80 08 add %l2, %o0, %l2
++cur_blk;
40014ab4: a2 04 60 01 inc %l1
40014ab8: 82 10 20 00 clr %g1
40014abc: 10 bf ff f4 b 40014a8c <fat_cluster_write+0x104>
40014ac0: b4 10 20 00 clr %i2
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
if (RC_OK == rc)
{
memcpy(blk_buf + offset, buf, bytes_to_write);
40014ac4: 92 07 00 12 add %i4, %l2, %o1
40014ac8: 90 02 00 1a add %o0, %i2, %o0
40014acc: 40 00 25 56 call 4001e024 <memcpy>
40014ad0: 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;
40014ad4: e6 2e 20 88 stb %l3, [ %i0 + 0x88 ]
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
40014ad8: 10 bf ff e9 b 40014a7c <fat_cluster_write+0xf4>
40014adc: 90 10 00 10 mov %l0, %o0
if (0 < bytes_to_write)
{
if ( overwrite_block
|| (bytes_to_write == fs_info->vol.bytes_per_block))
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
40014ae0: 94 10 20 02 mov 2, %o2
40014ae4: 7f ff fe cf call 40014620 <fat_buf_access>
40014ae8: 96 07 bf fc add %fp, -4, %o3
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
if (RC_OK == rc)
40014aec: 10 bf ff e2 b 40014a74 <fat_cluster_write+0xec>
40014af0: 80 a2 20 00 cmp %o0, 0
}
if (RC_OK != rc)
return rc;
else
return bytes_written;
}
40014af4: 81 c7 e0 08 ret <== NOT EXECUTED
40014af8: 81 e8 00 00 restore <== NOT EXECUTED
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
40014afc: c4 0e 20 02 ldub [ %i0 + 2 ], %g2
40014b00: e2 06 20 20 ld [ %i0 + 0x20 ], %l1
40014b04: 84 20 40 02 sub %g1, %g2, %g2
40014b08: 10 bf ff b6 b 400149e0 <fat_cluster_write+0x58>
40014b0c: a3 34 40 02 srl %l1, %g2, %l1
40013c90 <fat_file_close>:
int
fat_file_close(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
40013c90: 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)
40013c94: c2 06 60 08 ld [ %i1 + 8 ], %g1
40013c98: 80 a0 60 01 cmp %g1, 1
40013c9c: 08 80 00 06 bleu 40013cb4 <fat_file_close+0x24>
40013ca0: 82 00 7f ff add %g1, -1, %g1
{
fat_fd->links_num--;
return rc;
40013ca4: 90 10 20 00 clr %o0
* if links_num field of fat-file descriptor is greater than 1
* decrement the count of links and return
*/
if (fat_fd->links_num > 1)
{
fat_fd->links_num--;
40013ca8: c2 26 60 08 st %g1, [ %i1 + 8 ]
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
return rc;
}
40013cac: 81 c7 e0 08 ret
40013cb0: 91 e8 00 08 restore %g0, %o0, %o0
return rc;
}
key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
40013cb4: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
40013cb8: 80 88 60 01 btst 1, %g1
40013cbc: 22 80 00 15 be,a 40013d10 <fat_file_close+0x80>
40013cc0: d2 06 60 0c ld [ %i1 + 0xc ], %o1
{
rc = fat_file_truncate(fs_info, fat_fd, 0);
40013cc4: 90 10 00 18 mov %i0, %o0
40013cc8: 92 10 00 19 mov %i1, %o1
40013ccc: 7f ff ff b0 call 40013b8c <fat_file_truncate>
40013cd0: 94 10 20 00 clr %o2
if ( rc != RC_OK )
40013cd4: 80 a2 20 00 cmp %o0, 0
40013cd8: 12 bf ff f5 bne 40013cac <fat_file_close+0x1c> <== NEVER TAKEN
40013cdc: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
40013ce0: 40 00 0f 88 call 40017b00 <_Chain_Extract>
40013ce4: 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) )
40013ce8: d2 06 60 0c ld [ %i1 + 0xc ], %o1
40013cec: 40 00 06 7a call 400156d4 <fat_ino_is_unique>
40013cf0: 90 10 00 18 mov %i0, %o0
40013cf4: 80 8a 20 ff btst 0xff, %o0
40013cf8: 32 80 00 11 bne,a 40013d3c <fat_file_close+0xac> <== NEVER TAKEN
40013cfc: d2 06 60 0c ld [ %i1 + 0xc ], %o1 <== NOT EXECUTED
fat_fd->links_num = 0;
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
40013d00: 7f ff c8 23 call 40005d8c <free>
40013d04: 90 10 00 19 mov %i1, %o0
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
40013d08: 40 00 01 cf call 40014444 <fat_buf_release>
40013d0c: 81 e8 00 00 restore
free(fat_fd);
}
else
{
if (fat_ino_is_unique(fs_info, fat_fd->ino))
40013d10: 40 00 06 71 call 400156d4 <fat_ino_is_unique>
40013d14: 90 10 00 18 mov %i0, %o0
40013d18: 80 8a 20 ff btst 0xff, %o0
40013d1c: 02 80 00 05 be 40013d30 <fat_file_close+0xa0>
40013d20: 01 00 00 00 nop
{
fat_fd->links_num = 0;
40013d24: c0 26 60 08 clr [ %i1 + 8 ]
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
40013d28: 40 00 01 c7 call 40014444 <fat_buf_release>
40013d2c: 81 e8 00 00 restore
40013d30: 40 00 0f 74 call 40017b00 <_Chain_Extract>
40013d34: 90 10 00 19 mov %i1, %o0
40013d38: 30 bf ff f2 b,a 40013d00 <fat_file_close+0x70>
return rc;
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
if ( fat_ino_is_unique(fs_info, fat_fd->ino) )
fat_free_unique_ino(fs_info, fat_fd->ino);
40013d3c: 40 00 06 5b call 400156a8 <fat_free_unique_ino> <== NOT EXECUTED
40013d40: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40013d44: 30 bf ff ef b,a 40013d00 <fat_file_close+0x70> <== NOT EXECUTED
40013e1c <fat_file_extend>:
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
40013e1c: 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;
40013e20: f6 27 00 00 st %i3, [ %i4 ]
if (new_length <= fat_fd->fat_file_size)
40013e24: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t new_length,
uint32_t *a_length
)
{
int rc = RC_OK;
uint32_t chain = 0;
40013e28: 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;
40013e2c: 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)
40013e30: 80 a6 c0 01 cmp %i3, %g1
40013e34: 08 80 00 16 bleu 40013e8c <fat_file_extend+0x70>
40013e38: ba 10 00 18 mov %i0, %i5
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40013e3c: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
40013e40: 80 a0 a0 01 cmp %g2, 1
40013e44: 22 80 00 56 be,a 40013f9c <fat_file_extend+0x180>
40013e48: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
40013e4c: e0 17 60 06 lduh [ %i5 + 6 ], %l0
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
40013e50: 86 26 c0 01 sub %i3, %g1, %g3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
40013e54: 84 04 3f ff add %l0, -1, %g2
40013e58: 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 -
40013e5c: a0 24 00 12 sub %l0, %l2, %l0
40013e60: a0 0c 00 02 and %l0, %g2, %l0
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
if (bytes2add > bytes_remain)
40013e64: 80 a4 00 03 cmp %l0, %g3
40013e68: 1a 80 00 03 bcc 40013e74 <fat_file_extend+0x58>
40013e6c: a2 10 20 00 clr %l1
bytes2add -= bytes_remain;
40013e70: a2 20 c0 10 sub %g3, %l0, %l1
else
bytes2add = 0;
if (zero_fill && bytes_remain > 0) {
40013e74: 80 a4 20 00 cmp %l0, 0
40013e78: 12 80 00 3c bne 40013f68 <fat_file_extend+0x14c>
40013e7c: 80 a6 a0 00 cmp %i2, 0
/*
* if in last cluster allocated for the file there is enough room to
* handle extention (hence we don't need to add even one cluster to the
* file ) - return
*/
if (bytes2add == 0)
40013e80: 80 a4 60 00 cmp %l1, 0
40013e84: 32 80 00 04 bne,a 40013e94 <fat_file_extend+0x78>
40013e88: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
ssize_t bytes_written;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
40013e8c: 81 c7 e0 08 ret
40013e90: 91 e8 20 00 restore %g0, 0, %o0
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
40013e94: a4 04 7f ff add %l1, -1, %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
40013e98: 90 10 00 1d mov %i5, %o0
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
40013e9c: a5 34 80 01 srl %l2, %g1, %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
40013ea0: 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;
40013ea4: a4 04 a0 01 inc %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
40013ea8: 96 07 bf fc add %fp, -4, %o3
40013eac: 94 10 00 12 mov %l2, %o2
40013eb0: 98 07 bf f8 add %fp, -8, %o4
40013eb4: 40 00 1e 90 call 4001b8f4 <fat_scan_fat_for_free_clusters>
40013eb8: 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)
40013ebc: b0 92 20 00 orcc %o0, 0, %i0
40013ec0: 12 80 00 28 bne 40013f60 <fat_file_extend+0x144> <== NEVER TAKEN
40013ec4: 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))
40013ec8: 80 94 00 01 orcc %l0, %g1, %g0
40013ecc: 02 80 00 3b be 40013fb8 <fat_file_extend+0x19c> <== NEVER TAKEN
40013ed0: 80 a4 80 01 cmp %l2, %g1
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
40013ed4: 02 80 00 09 be 40013ef8 <fat_file_extend+0xdc> <== ALWAYS TAKEN
40013ed8: a4 24 80 01 sub %l2, %g1, %l2
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
40013edc: c6 17 60 06 lduh [ %i5 + 6 ], %g3 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
40013ee0: 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);
40013ee4: 86 00 ff ff add %g3, -1, %g3 <== NOT EXECUTED
40013ee8: a2 0c 40 03 and %l1, %g3, %l1 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
40013eec: a5 2c 80 02 sll %l2, %g2, %l2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
40013ef0: b6 26 c0 11 sub %i3, %l1, %i3 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
40013ef4: b6 26 c0 12 sub %i3, %l2, %i3 <== NOT EXECUTED
}
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
40013ef8: d6 06 60 18 ld [ %i1 + 0x18 ], %o3
40013efc: 80 a2 e0 00 cmp %o3, 0
40013f00: 32 80 00 43 bne,a 4001400c <fat_file_extend+0x1f0>
40013f04: d2 06 60 3c ld [ %i1 + 0x3c ], %o1
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
40013f08: c4 07 bf f0 ld [ %fp + -16 ], %g2
fat_fd->map.file_cln = 0;
40013f0c: 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;
40013f10: c4 26 60 1c st %g2, [ %i1 + 0x1c ]
40013f14: c4 26 60 38 st %g2, [ %i1 + 0x38 ]
}
fat_buf_release(fs_info);
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
40013f18: 80 a0 60 00 cmp %g1, 0
40013f1c: 22 80 00 39 be,a 40014000 <fat_file_extend+0x1e4> <== NEVER TAKEN
40013f20: f6 27 00 00 st %i3, [ %i4 ] <== NOT EXECUTED
{
fat_fd->map.last_cln = last_cl;
40013f24: c4 07 bf f8 ld [ %fp + -8 ], %g2
if (fat_fd->fat_file_type == FAT_DIRECTORY)
40013f28: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40013f2c: 80 a0 60 00 cmp %g1, 0
40013f30: 12 80 00 33 bne 40013ffc <fat_file_extend+0x1e0>
40013f34: c4 26 60 3c st %g2, [ %i1 + 0x3c ]
{
rc = fat_init_clusters_chain(fs_info, chain);
40013f38: d2 07 bf f0 ld [ %fp + -16 ], %o1
40013f3c: 40 00 05 80 call 4001553c <fat_init_clusters_chain>
40013f40: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
40013f44: 82 92 20 00 orcc %o0, 0, %g1
40013f48: 22 80 00 2e be,a 40014000 <fat_file_extend+0x1e4> <== ALWAYS TAKEN
40013f4c: f6 27 00 00 st %i3, [ %i4 ]
{
fat_free_fat_clusters_chain(fs_info, chain);
40013f50: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
40013f54: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
40013f58: 40 00 1e 2f call 4001b814 <fat_free_fat_clusters_chain> <== NOT EXECUTED
40013f5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40013f60: 81 c7 e0 08 ret <== NOT EXECUTED
40013f64: 81 e8 00 00 restore <== NOT EXECUTED
if (bytes2add > bytes_remain)
bytes2add -= bytes_remain;
else
bytes2add = 0;
if (zero_fill && bytes_remain > 0) {
40013f68: 02 bf ff c7 be 40013e84 <fat_file_extend+0x68>
40013f6c: 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;
40013f70: 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);
40013f74: 90 10 00 1d mov %i5, %o0
40013f78: 92 10 00 19 mov %i1, %o1
40013f7c: 95 30 40 0a srl %g1, %o2, %o2
40013f80: 7f ff fd 9b call 400135ec <fat_file_lseek>
40013f84: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40013f88: b0 92 60 00 orcc %o1, 0, %i0
40013f8c: 02 80 00 11 be 40013fd0 <fat_file_extend+0x1b4> <== ALWAYS TAKEN
40013f90: d2 07 bf fc ld [ %fp + -4 ], %o1
*a_length = new_length;
fat_fd->fat_file_size = new_length;
return RC_OK;
}
40013f94: 81 c7 e0 08 ret <== NOT EXECUTED
40013f98: 81 e8 00 00 restore <== NOT EXECUTED
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40013f9c: 80 a0 a0 00 cmp %g2, 0
40013fa0: 32 bf ff ac bne,a 40013e50 <fat_file_extend+0x34> <== NEVER TAKEN
40013fa4: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
40013fa8: 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)) &&
40013fac: 80 88 a0 03 btst 3, %g2
40013fb0: 22 bf ff a8 be,a 40013e50 <fat_file_extend+0x34> <== NEVER TAKEN
40013fb4: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
if (rc != RC_OK)
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
40013fb8: 40 00 25 76 call 4001d590 <__errno>
40013fbc: b0 10 3f ff mov -1, %i0
40013fc0: 82 10 20 1c mov 0x1c, %g1
40013fc4: c2 22 00 00 st %g1, [ %o0 ]
40013fc8: 81 c7 e0 08 ret
40013fcc: 81 e8 00 00 restore
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
40013fd0: 90 10 00 1d mov %i5, %o0
40013fd4: 94 10 00 12 mov %l2, %o2
40013fd8: 96 10 00 10 mov %l0, %o3
40013fdc: 98 10 20 00 clr %o4
40013fe0: 40 00 02 0a call 40014808 <fat_cluster_set>
40013fe4: b0 10 3f ff mov -1, %i0
if (bytes_remain != bytes_written)
40013fe8: 80 a2 00 10 cmp %o0, %l0
40013fec: 02 bf ff a6 be 40013e84 <fat_file_extend+0x68> <== ALWAYS TAKEN
40013ff0: 80 a4 60 00 cmp %l1, 0
*a_length = new_length;
fat_fd->fat_file_size = new_length;
return RC_OK;
}
40013ff4: 81 c7 e0 08 ret <== NOT EXECUTED
40013ff8: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
}
*a_length = new_length;
40013ffc: f6 27 00 00 st %i3, [ %i4 ]
fat_fd->fat_file_size = new_length;
40014000: f6 26 60 18 st %i3, [ %i1 + 0x18 ]
return RC_OK;
}
40014004: 81 c7 e0 08 ret
40014008: 81 e8 00 00 restore
fat_fd->map.disk_cln = fat_fd->cln = chain;
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
4001400c: 80 a2 7f ff cmp %o1, -1
40014010: 22 80 00 0d be,a 40014044 <fat_file_extend+0x228> <== NEVER TAKEN
40014014: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
40014018: d2 27 bf f4 st %o1, [ %fp + -12 ]
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
}
rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
4001401c: d4 07 bf f0 ld [ %fp + -16 ], %o2
40014020: 40 00 1d 4b call 4001b54c <fat_set_fat_cluster>
40014024: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
40014028: 82 92 20 00 orcc %o0, 0, %g1
4001402c: 12 bf ff ca bne 40013f54 <fat_file_extend+0x138> <== NEVER TAKEN
40014030: d2 07 bf f0 ld [ %fp + -16 ], %o1
{
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
fat_buf_release(fs_info);
40014034: 40 00 01 04 call 40014444 <fat_buf_release>
40014038: 90 10 00 1d mov %i5, %o0
4001403c: 10 bf ff b7 b 40013f18 <fat_file_extend+0xfc>
40014040: c2 07 bf fc ld [ %fp + -4 ], %g1
{
old_last_cl = fat_fd->map.last_cln;
}
else
{
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
40014044: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40014048: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001404c: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
40014050: 7f ff ff 3e call 40013d48 <fat_file_ioctl> <== NOT EXECUTED
40014054: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED
40014058: d2 07 bf f4 ld [ %fp + -12 ], %o1 <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
4001405c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40014060: 02 bf ff ef be 4001401c <fat_file_extend+0x200> <== NOT EXECUTED
40014064: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(fs_info, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(fs_info, chain);
40014068: 10 bf ff bb b 40013f54 <fat_file_extend+0x138> <== NOT EXECUTED
4001406c: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
40013d48 <fat_file_ioctl>:
fat_file_ioctl(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
40013d48: 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);
40013d4c: 82 07 a0 50 add %fp, 0x50, %g1
40013d50: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40013d54: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40013d58: 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;
40013d5c: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
40013d60: 80 a6 a0 01 cmp %i2, 1
40013d64: 02 80 00 08 be 40013d84 <fat_file_ioctl+0x3c> <== ALWAYS TAKEN
40013d68: c2 27 bf fc st %g1, [ %fp + -4 ]
*ret = cur_cln;
break;
default:
errno = EINVAL;
40013d6c: 40 00 26 09 call 4001d590 <__errno> <== NOT EXECUTED
40013d70: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013d74: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40013d78: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = -1;
break;
}
va_end(ap);
return rc;
}
40013d7c: 81 c7 e0 08 ret <== NOT EXECUTED
40013d80: 81 e8 00 00 restore <== NOT EXECUTED
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
40013d84: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
40013d88: 86 07 a0 58 add %fp, 0x58, %g3
40013d8c: c6 27 bf fc st %g3, [ %fp + -4 ]
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
40013d90: 80 a6 c0 02 cmp %i3, %g2
40013d94: 1a 80 00 1c bcc 40013e04 <fat_file_ioctl+0xbc> <== NEVER TAKEN
40013d98: ba 10 00 1c mov %i4, %i5
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40013d9c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
40013da0: 80 a0 60 01 cmp %g1, 1
40013da4: 22 80 00 0e be,a 40013ddc <fat_file_ioctl+0x94>
40013da8: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
*ret = 0;
rc = RC_OK;
break;
}
cl_start = pos >> fs_info->vol.bpc_log2;
40013dac: d4 0e 20 08 ldub [ %i0 + 8 ], %o2
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
40013db0: 90 10 00 18 mov %i0, %o0
40013db4: 92 10 00 19 mov %i1, %o1
40013db8: 95 36 c0 0a srl %i3, %o2, %o2
40013dbc: 7f ff fe 0c call 400135ec <fat_file_lseek>
40013dc0: 96 07 bf f8 add %fp, -8, %o3
if ( rc != RC_OK )
40013dc4: b0 92 60 00 orcc %o1, 0, %i0
40013dc8: 12 bf ff ed bne 40013d7c <fat_file_ioctl+0x34> <== NEVER TAKEN
40013dcc: c2 07 bf f8 ld [ %fp + -8 ], %g1
break;
*ret = cur_cln;
40013dd0: c2 27 40 00 st %g1, [ %i5 ]
break;
40013dd4: 81 c7 e0 08 ret
40013dd8: 81 e8 00 00 restore
if ( pos >= fat_fd->fat_file_size ) {
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40013ddc: 80 a0 60 00 cmp %g1, 0
40013de0: 32 bf ff f4 bne,a 40013db0 <fat_file_ioctl+0x68> <== NEVER TAKEN
40013de4: d4 0e 20 08 ldub [ %i0 + 8 ], %o2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
40013de8: 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)) &&
40013dec: 80 88 60 03 btst 3, %g1
40013df0: 22 bf ff f0 be,a 40013db0 <fat_file_ioctl+0x68>
40013df4: 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;
40013df8: c0 27 00 00 clr [ %i4 ]
rc = RC_OK;
break;
40013dfc: 81 c7 e0 08 ret
40013e00: 91 e8 20 00 restore %g0, 0, %o0
ret = va_arg(ap, uint32_t *);
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
40013e04: 40 00 25 e3 call 4001d590 <__errno> <== NOT EXECUTED
40013e08: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013e0c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40013e10: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013e14: 81 c7 e0 08 ret <== NOT EXECUTED
40013e18: 81 e8 00 00 restore <== NOT EXECUTED
400135ec <fat_file_lseek>:
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
400135ec: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
400135f0: f8 06 60 34 ld [ %i1 + 0x34 ], %i4
400135f4: 80 a7 00 1a cmp %i4, %i2
400135f8: 22 80 00 26 be,a 40013690 <fat_file_lseek+0xa4>
400135fc: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
{
uint32_t cur_cln;
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
40013600: 2a 80 00 19 bcs,a 40013664 <fat_file_lseek+0x78>
40013604: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
cur_cln = fat_fd->map.disk_cln;
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
40013608: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
4001360c: b8 10 00 1a mov %i2, %i4
40013610: c2 27 bf fc st %g1, [ %fp + -4 ]
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
40013614: 80 a7 20 00 cmp %i4, 0
40013618: 12 80 00 07 bne 40013634 <fat_file_lseek+0x48>
4001361c: ba 10 20 00 clr %i5
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
40013620: 10 80 00 14 b 40013670 <fat_file_lseek+0x84>
40013624: c2 07 bf fc ld [ %fp + -4 ], %g1
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
40013628: 80 a7 40 1c cmp %i5, %i4
4001362c: 02 80 00 11 be 40013670 <fat_file_lseek+0x84>
40013630: c2 07 bf fc ld [ %fp + -4 ], %g1
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40013634: d2 07 bf fc ld [ %fp + -4 ], %o1
40013638: 90 10 00 18 mov %i0, %o0
4001363c: 40 00 1f 40 call 4001b33c <fat_get_fat_cluster>
40013640: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
40013644: 80 a2 20 00 cmp %o0, 0
40013648: 22 bf ff f8 be,a 40013628 <fat_file_lseek+0x3c> <== ALWAYS TAKEN
4001364c: ba 07 60 01 inc %i5
return rc;
40013650: 86 10 00 08 mov %o0, %g3 <== NOT EXECUTED
40013654: 85 3a 20 1f sra %o0, 0x1f, %g2 <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
40013658: b2 10 00 03 mov %g3, %i1 <== NOT EXECUTED
4001365c: 81 c7 e0 08 ret <== NOT EXECUTED
40013660: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
count = file_cln - fat_fd->map.file_cln;
40013664: b8 26 80 1c sub %i2, %i4, %i4
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
40013668: 10 bf ff eb b 40013614 <fat_file_lseek+0x28>
4001366c: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
40013670: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = cur_cln;
40013674: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
*disk_cln = cur_cln;
}
return RC_OK;
40013678: 84 10 20 00 clr %g2
4001367c: 86 10 20 00 clr %g3
/* update cache */
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
40013680: c2 26 c0 00 st %g1, [ %i3 ]
}
return RC_OK;
}
40013684: b0 10 00 02 mov %g2, %i0
40013688: 81 c7 e0 08 ret
4001368c: 93 e8 00 03 restore %g0, %g3, %o1
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
40013690: 84 10 20 00 clr %g2
40013694: 86 10 20 00 clr %g3
)
{
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
*disk_cln = fat_fd->map.disk_cln;
40013698: c2 26 c0 00 st %g1, [ %i3 ]
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
4001369c: b0 10 00 02 mov %g2, %i0
400136a0: 81 c7 e0 08 ret
400136a4: 93 e8 00 03 restore %g0, %g3, %o1
400142d4 <fat_file_mark_removed>:
void
fat_file_mark_removed(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
400142d4: 9d e3 bf a0 save %sp, -96, %sp
400142d8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
400142dc: 80 a0 60 01 cmp %g1, 1
400142e0: 02 80 00 26 be 40014378 <fat_file_mark_removed+0xa4> <== NEVER TAKEN
400142e4: 80 a0 60 00 cmp %g1, 0
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400142e8: 32 80 00 1f bne,a 40014364 <fat_file_mark_removed+0x90> <== NEVER TAKEN
400142ec: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
400142f0: c4 0e 20 0e ldub [ %i0 + 0xe ], %g2
400142f4: 80 88 a0 03 btst 3, %g2
400142f8: 22 80 00 1b be,a 40014364 <fat_file_mark_removed+0x90> <== NEVER TAKEN
400142fc: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40014300: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
40014304: c4 0e 20 03 ldub [ %i0 + 3 ], %g2
40014308: bb 2f 40 02 sll %i5, %g2, %i5
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
4001430c: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
40014310: 90 10 00 19 mov %i1, %o0
40014314: 87 30 a0 09 srl %g2, 9, %g3
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
40014318: 85 30 a0 05 srl %g2, 5, %g2
4001431c: 84 08 a0 0f and %g2, 0xf, %g2
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
40014320: ba 07 40 03 add %i5, %g3, %i5
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
40014324: bb 2f 60 04 sll %i5, 4, %i5
40014328: 40 00 0d f6 call 40017b00 <_Chain_Extract>
4001432c: ba 07 40 02 add %i5, %g2, %i5
*/
static inline void
_hash_insert(rtems_chain_control *hash, uint32_t key1, uint32_t key2,
fat_file_fd_t *el)
{
rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
40014330: d0 06 20 70 ld [ %i0 + 0x70 ], %o0
40014334: 82 0f 60 01 and %i5, 1, %g1
40014338: 85 28 60 02 sll %g1, 2, %g2
4001433c: 83 28 60 04 sll %g1, 4, %g1
40014340: 82 20 40 02 sub %g1, %g2, %g1
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
40014344: 92 10 00 19 mov %i1, %o1
40014348: 7f ff db 7d call 4000b13c <_Chain_Append>
4001434c: 90 02 00 01 add %o0, %g1, %o0
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
_hash_insert(fs_info->rhash, key, fat_fd->ino, fat_fd);
fat_fd->flags |= FAT_FILE_REMOVED;
40014350: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
40014354: 82 10 60 01 or %g1, 1, %g1
40014358: c2 2e 60 30 stb %g1, [ %i1 + 0x30 ]
4001435c: 81 c7 e0 08 ret
40014360: 81 e8 00 00 restore
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40014364: c4 06 20 34 ld [ %i0 + 0x34 ], %g2 <== NOT EXECUTED
40014368: ba 00 7f fe add %g1, -2, %i5 <== NOT EXECUTED
4001436c: bb 2f 40 03 sll %i5, %g3, %i5 <== NOT EXECUTED
40014370: 10 bf ff e5 b 40014304 <fat_file_mark_removed+0x30> <== NOT EXECUTED
40014374: ba 07 40 02 add %i5, %g2, %i5 <== NOT EXECUTED
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
return 1;
40014378: 10 bf ff e5 b 4001430c <fat_file_mark_removed+0x38> <== NOT EXECUTED
4001437c: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
400136a8 <fat_file_open>:
fat_file_open(
fat_fs_info_t *fs_info,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
400136a8: 9d e3 bf a0 save %sp, -96, %sp
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
400136ac: c2 06 40 00 ld [ %i1 ], %g1
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
400136b0: 80 a0 60 01 cmp %g1, 1
400136b4: 02 80 00 9c be 40013924 <fat_file_open+0x27c>
400136b8: 80 a0 60 00 cmp %g1, 0
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400136bc: 32 80 00 7b bne,a 400138a8 <fat_file_open+0x200>
400136c0: c6 0e 20 05 ldub [ %i0 + 5 ], %g3
400136c4: c4 0e 20 0e ldub [ %i0 + 0xe ], %g2
400136c8: 80 88 a0 03 btst 3, %g2
400136cc: 22 80 00 77 be,a 400138a8 <fat_file_open+0x200> <== NEVER TAKEN
400136d0: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
400136d4: fa 06 20 20 ld [ %i0 + 0x20 ], %i5
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
400136d8: c4 0e 20 03 ldub [ %i0 + 3 ], %g2
400136dc: bb 2f 40 02 sll %i5, %g2, %i5
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
400136e0: c2 06 60 04 ld [ %i1 + 4 ], %g1
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
400136e4: de 06 20 6c ld [ %i0 + 0x6c ], %o7
400136e8: 85 30 60 09 srl %g1, 9, %g2
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
400136ec: 83 30 60 05 srl %g1, 5, %g1
400136f0: 82 08 60 0f and %g1, 0xf, %g1
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
400136f4: ba 07 40 02 add %i5, %g2, %i5
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
400136f8: bb 2f 60 04 sll %i5, 4, %i5
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
400136fc: ba 07 40 01 add %i5, %g1, %i5
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
40013700: 82 0f 60 01 and %i5, 1, %g1
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
40013704: 85 28 60 02 sll %g1, 2, %g2
40013708: b7 28 60 04 sll %g1, 4, %i3
4001370c: b6 26 c0 02 sub %i3, %g2, %i3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
40013710: c2 03 c0 1b ld [ %o7 + %i3 ], %g1
40013714: 9e 03 c0 1b add %o7, %i3, %o7
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
40013718: 9e 03 e0 04 add %o7, 4, %o7
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
4001371c: 80 a0 40 0f cmp %g1, %o7
40013720: 22 80 00 1e be,a 40013798 <fat_file_open+0xf0>
40013724: c4 06 20 70 ld [ %i0 + 0x70 ], %g2
40013728: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
4001372c: 80 a0 a0 01 cmp %g2, 1
40013730: 02 80 00 6d be 400138e4 <fat_file_open+0x23c>
40013734: 80 a0 a0 00 cmp %g2, 0
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40013738: 32 80 00 61 bne,a 400138bc <fat_file_open+0x214>
4001373c: c8 0e 20 05 ldub [ %i0 + 5 ], %g4
40013740: c6 0e 20 0e ldub [ %i0 + 0xe ], %g3
40013744: 80 88 e0 03 btst 3, %g3
40013748: 22 80 00 5d be,a 400138bc <fat_file_open+0x214> <== NEVER TAKEN
4001374c: c8 0e 20 05 ldub [ %i0 + 5 ], %g4 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40013750: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
40013754: c6 0e 20 03 ldub [ %i0 + 3 ], %g3
40013758: b9 2f 00 03 sll %i4, %g3, %i4
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
4001375c: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
40013760: 85 30 e0 05 srl %g3, 5, %g2
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
40013764: 89 30 e0 09 srl %g3, 9, %g4
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
40013768: 84 08 a0 0f and %g2, 0xf, %g2
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
4001376c: 86 07 00 04 add %i4, %g4, %g3
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
40013770: 87 28 e0 04 sll %g3, 4, %g3
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
40013774: 86 00 c0 02 add %g3, %g2, %g3
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
if ( (key1) == ck)
40013778: 80 a7 40 03 cmp %i5, %g3
4001377c: 22 80 00 55 be,a 400138d0 <fat_file_open+0x228>
40013780: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
40013784: c2 00 40 00 ld [ %g1 ], %g1
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
40013788: 80 a3 c0 01 cmp %o7, %g1
4001378c: 32 bf ff e8 bne,a 4001372c <fat_file_open+0x84>
40013790: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
40013794: c4 06 20 70 ld [ %i0 + 0x70 ], %g2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
40013798: c2 00 80 1b ld [ %g2 + %i3 ], %g1
4001379c: 84 00 80 1b add %g2, %i3, %g2
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
400137a0: 9e 00 a0 04 add %g2, 4, %o7
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
400137a4: 80 a0 40 0f cmp %g1, %o7
400137a8: 02 80 00 1e be 40013820 <fat_file_open+0x178> <== ALWAYS TAKEN
400137ac: a0 10 3f ff mov -1, %l0
400137b0: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 <== NOT EXECUTED
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
400137b4: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
400137b8: 02 80 00 59 be 4001391c <fat_file_open+0x274> <== NOT EXECUTED
400137bc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400137c0: 32 80 00 4b bne,a 400138ec <fat_file_open+0x244> <== NOT EXECUTED
400137c4: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
400137c8: c6 0e 20 0e ldub [ %i0 + 0xe ], %g3 <== NOT EXECUTED
400137cc: 80 88 e0 03 btst 3, %g3 <== NOT EXECUTED
400137d0: 22 80 00 47 be,a 400138ec <fat_file_open+0x244> <== NOT EXECUTED
400137d4: c6 0e 20 05 ldub [ %i0 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
400137d8: f8 06 20 20 ld [ %i0 + 0x20 ], %i4 <== NOT EXECUTED
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
400137dc: c8 0e 20 03 ldub [ %i0 + 3 ], %g4 <== NOT EXECUTED
400137e0: b9 2f 00 04 sll %i4, %g4, %i4 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
400137e4: c6 00 60 24 ld [ %g1 + 0x24 ], %g3 <== NOT EXECUTED
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
400137e8: 85 30 e0 05 srl %g3, 5, %g2 <== NOT EXECUTED
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
400137ec: 89 30 e0 09 srl %g3, 9, %g4 <== NOT EXECUTED
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
400137f0: 84 08 a0 0f and %g2, 0xf, %g2 <== NOT EXECUTED
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
400137f4: 86 07 00 04 add %i4, %g4, %g3 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
400137f8: 87 28 e0 04 sll %g3, 4, %g3 <== NOT EXECUTED
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
400137fc: 86 00 c0 02 add %g3, %g2, %g3 <== NOT EXECUTED
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
if ( (key1) == ck)
40013800: 80 a7 40 03 cmp %i5, %g3 <== NOT EXECUTED
40013804: 02 80 00 3f be 40013900 <fat_file_open+0x258> <== NOT EXECUTED
40013808: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
4001380c: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
40013810: 80 a0 40 0f cmp %g1, %o7 <== NOT EXECUTED
40013814: 32 bf ff e8 bne,a 400137b4 <fat_file_open+0x10c> <== NOT EXECUTED
40013818: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 <== NOT EXECUTED
return 0;
}
}
the_node = the_node->next;
}
return -1;
4001381c: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(fs_info, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
40013820: 7f ff ca ae call 400062d8 <malloc>
40013824: 90 10 20 44 mov 0x44, %o0
40013828: d0 26 80 00 st %o0, [ %i2 ]
if ( lfat_fd == NULL )
4001382c: 80 a2 20 00 cmp %o0, 0
40013830: 02 80 00 46 be 40013948 <fat_file_open+0x2a0> <== NEVER TAKEN
40013834: b8 10 00 08 mov %o0, %i4
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
40013838: 92 10 20 00 clr %o1
4001383c: 40 00 2a 37 call 4001e118 <memset>
40013840: 94 10 20 44 mov 0x44, %o2
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
40013844: de 0f 20 30 ldub [ %i4 + 0x30 ], %o7
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
40013848: c8 06 40 00 ld [ %i1 ], %g4
4001384c: c6 06 60 04 ld [ %i1 + 4 ], %g3
40013850: c4 06 60 08 ld [ %i1 + 8 ], %g2
40013854: c2 06 60 0c ld [ %i1 + 0xc ], %g1
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
40013858: b2 0b ff fe and %o7, -2, %i1
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
4001385c: c8 27 20 20 st %g4, [ %i4 + 0x20 ]
if ( lfat_fd == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
40013860: 9e 10 20 01 mov 1, %o7
lfat_fd->flags &= ~FAT_FILE_REMOVED;
40013864: f2 2f 20 30 stb %i1, [ %i4 + 0x30 ]
if ( lfat_fd == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
40013868: de 27 20 08 st %o7, [ %i4 + 8 ]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4001386c: b2 10 3f ff mov -1, %i1
lfat_fd->dir_pos = *dir_pos;
40013870: c6 27 20 24 st %g3, [ %i4 + 0x24 ]
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
40013874: f2 27 20 3c st %i1, [ %i4 + 0x3c ]
lfat_fd->dir_pos = *dir_pos;
40013878: c4 27 20 28 st %g2, [ %i4 + 0x28 ]
if ( rc != RC_OK )
4001387c: 80 a4 20 00 cmp %l0, 0
40013880: 02 80 00 2b be 4001392c <fat_file_open+0x284> <== NEVER TAKEN
40013884: c2 27 20 2c st %g1, [ %i4 + 0x2c ]
lfat_fd->ino = key;
40013888: fa 27 20 0c st %i5, [ %i4 + 0xc ]
*/
static inline void
_hash_insert(rtems_chain_control *hash, uint32_t key1, uint32_t key2,
fat_file_fd_t *el)
{
rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
4001388c: 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 );
40013890: 92 10 00 1c mov %i4, %o1
40013894: 90 02 00 1b add %o0, %i3, %o0
40013898: 7f ff de 29 call 4000b13c <_Chain_Append>
4001389c: b0 10 20 00 clr %i0
400138a0: 81 c7 e0 08 ret
400138a4: 81 e8 00 00 restore
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
400138a8: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
400138ac: ba 00 7f fe add %g1, -2, %i5
400138b0: bb 2f 40 03 sll %i5, %g3, %i5
400138b4: 10 bf ff 89 b 400136d8 <fat_file_open+0x30>
400138b8: ba 07 40 02 add %i5, %g2, %i5
400138bc: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
400138c0: b8 00 bf fe add %g2, -2, %i4
400138c4: b9 2f 00 04 sll %i4, %g4, %i4
400138c8: 10 bf ff a3 b 40013754 <fat_file_open+0xac>
400138cc: b8 07 00 03 add %i4, %g3, %i4
/* access "valid" hash table */
rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
400138d0: c2 26 80 00 st %g1, [ %i2 ]
lfat_fd->links_num++;
400138d4: 84 00 a0 01 inc %g2
400138d8: c4 20 60 08 st %g2, [ %g1 + 8 ]
400138dc: 81 c7 e0 08 ret
400138e0: 91 e8 20 00 restore %g0, 0, %o0
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
return 1;
400138e4: 10 bf ff 9e b 4001375c <fat_file_open+0xb4>
400138e8: b8 10 20 01 mov 1, %i4
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
400138ec: c8 06 20 34 ld [ %i0 + 0x34 ], %g4 <== NOT EXECUTED
400138f0: b8 00 bf fe add %g2, -2, %i4 <== NOT EXECUTED
400138f4: b9 2f 00 03 sll %i4, %g3, %i4 <== NOT EXECUTED
400138f8: 10 bf ff b9 b 400137dc <fat_file_open+0x134> <== NOT EXECUTED
400138fc: b8 07 00 04 add %i4, %g4, %i4 <== NOT EXECUTED
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
if ( (key1) == ck)
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
40013900: 02 bf ff c8 be 40013820 <fat_file_open+0x178> <== NOT EXECUTED
40013904: a0 10 20 00 clr %l0 <== NOT EXECUTED
40013908: c4 00 60 0c ld [ %g1 + 0xc ], %g2 <== NOT EXECUTED
4001390c: 80 a7 40 02 cmp %i5, %g2 <== NOT EXECUTED
40013910: 32 bf ff c0 bne,a 40013810 <fat_file_open+0x168> <== NOT EXECUTED
40013914: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40013918: 30 bf ff c2 b,a 40013820 <fat_file_open+0x178> <== NOT EXECUTED
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
return 1;
4001391c: 10 bf ff b2 b 400137e4 <fat_file_open+0x13c> <== NOT EXECUTED
40013920: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
40013924: 10 bf ff 6f b 400136e0 <fat_file_open+0x38>
40013928: ba 10 20 01 mov 1, %i5
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(fs_info);
4001392c: 40 00 07 23 call 400155b8 <fat_get_unique_ino> <== NOT EXECUTED
40013930: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
40013934: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40013938: 12 bf ff d5 bne 4001388c <fat_file_open+0x1e4> <== NOT EXECUTED
4001393c: d0 27 20 0c st %o0, [ %i4 + 0xc ] <== NOT EXECUTED
{
free((*fat_fd));
40013940: 7f ff c9 13 call 40005d8c <free> <== NOT EXECUTED
40013944: 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 );
40013948: 40 00 27 12 call 4001d590 <__errno> <== NOT EXECUTED
4001394c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40013950: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40013954: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40013958: 81 c7 e0 08 ret <== NOT EXECUTED
4001395c: 81 e8 00 00 restore <== NOT EXECUTED
40013978 <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
40013978: 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;
4001397c: c0 27 bf fc clr [ %fp + -4 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
40013980: 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)
40013984: 80 a6 e0 00 cmp %i3, 0
40013988: 02 80 00 7f be 40013b84 <fat_file_read+0x20c> <== NEVER TAKEN
4001398c: b0 10 20 00 clr %i0
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
40013990: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
40013994: 80 a0 40 1a cmp %g1, %i2
40013998: 08 80 00 7b bleu 40013b84 <fat_file_read+0x20c>
4001399c: 80 a6 c0 01 cmp %i3, %g1
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
400139a0: 08 80 00 4c bleu 40013ad0 <fat_file_read+0x158> <== ALWAYS TAKEN
400139a4: 84 20 40 1b sub %g1, %i3, %g2
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
400139a8: b6 20 40 1a sub %g1, %i2, %i3 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
400139ac: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
400139b0: 80 a0 60 01 cmp %g1, 1
400139b4: 22 80 00 4c be,a 40013ae4 <fat_file_read+0x16c>
400139b8: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
400139bc: e4 0f 60 08 ldub [ %i5 + 8 ], %l2
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
400139c0: e0 17 60 06 lduh [ %i5 + 6 ], %l0
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
400139c4: 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);
400139c8: 90 10 00 1d mov %i5, %o0
400139cc: 92 10 00 19 mov %i1, %o1
400139d0: 94 10 00 12 mov %l2, %o2
400139d4: 7f ff ff 06 call 400135ec <fat_file_lseek>
400139d8: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
400139dc: b0 92 60 00 orcc %o1, 0, %i0
400139e0: 12 80 00 69 bne 40013b84 <fat_file_read+0x20c> <== NEVER TAKEN
400139e4: a1 2c 20 10 sll %l0, 0x10, %l0
return rc;
while (count > 0)
400139e8: a6 10 20 00 clr %l3
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
400139ec: a1 34 20 10 srl %l0, 0x10, %l0
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
400139f0: a2 10 20 00 clr %l1
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
400139f4: a0 04 3f ff add %l0, -1, %l0
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
400139f8: 80 a6 e0 00 cmp %i3, 0
400139fc: 02 80 00 5b be 40013b68 <fat_file_read+0x1f0> <== NEVER TAKEN
40013a00: b4 0e 80 10 and %i2, %l0, %i2
40013a04: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
40013a08: c8 17 40 00 lduh [ %i5 ], %g4
40013a0c: 10 80 00 20 b 40013a8c <fat_file_read+0x114>
40013a10: 94 10 00 1a mov %i2, %o2
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40013a14: 80 8e 20 03 btst 3, %i0 <== NOT EXECUTED
40013a18: 22 80 00 27 be,a 40013ab4 <fat_file_read+0x13c> <== NOT EXECUTED
40013a1c: de 0f 60 05 ldub [ %i5 + 5 ], %o7 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40013a20: d2 07 60 20 ld [ %i5 + 0x20 ], %o1 <== NOT EXECUTED
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
40013a24: 87 32 80 03 srl %o2, %g3, %g3
byte = ofs & (fs_info->vol.bps - 1);
40013a28: 85 29 20 10 sll %g4, 0x10, %g2
40013a2c: 85 30 a0 10 srl %g2, 0x10, %g2
40013a30: 84 00 bf ff add %g2, -1, %g2
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
40013a34: 98 07 00 11 add %i4, %l1, %o4
40013a38: 94 0a 80 02 and %o2, %g2, %o2
40013a3c: 92 02 40 03 add %o1, %g3, %o1
40013a40: 96 10 00 10 mov %l0, %o3
40013a44: 40 00 03 25 call 400146d8 <_fat_block_read>
40013a48: 90 10 00 1d mov %i5, %o0
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40013a4c: 94 07 bf fc add %fp, -4, %o2
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
40013a50: 80 a2 20 00 cmp %o0, 0
40013a54: 06 80 00 3d bl 40013b48 <fat_file_read+0x1d0> <== NEVER TAKEN
40013a58: 90 10 00 1d mov %i5, %o0
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
40013a5c: e6 07 bf fc ld [ %fp + -4 ], %l3
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
40013a60: b6 26 c0 10 sub %i3, %l0, %i3
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40013a64: 92 10 00 13 mov %l3, %o1
40013a68: 40 00 1e 35 call 4001b33c <fat_get_fat_cluster>
40013a6c: a2 04 40 10 add %l1, %l0, %l1
if ( rc != RC_OK )
40013a70: 80 a2 20 00 cmp %o0, 0
40013a74: 12 80 00 15 bne 40013ac8 <fat_file_read+0x150> <== NEVER TAKEN
40013a78: 80 a6 e0 00 cmp %i3, 0
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
40013a7c: 02 80 00 3a be 40013b64 <fat_file_read+0x1ec>
40013a80: 94 10 20 00 clr %o2
40013a84: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
40013a88: c8 17 40 00 lduh [ %i5 ], %g4
{
c = MIN(count, (fs_info->vol.bpc - ofs));
40013a8c: e0 17 60 06 lduh [ %i5 + 6 ], %l0
40013a90: a0 24 00 0a sub %l0, %o2, %l0
40013a94: 80 a4 00 1b cmp %l0, %i3
40013a98: 08 80 00 03 bleu 40013aa4 <fat_file_read+0x12c>
40013a9c: c4 07 bf fc ld [ %fp + -4 ], %g2
40013aa0: a0 10 00 1b mov %i3, %l0
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40013aa4: 80 a0 a0 00 cmp %g2, 0
40013aa8: 22 bf ff db be,a 40013a14 <fat_file_read+0x9c> <== NEVER TAKEN
40013aac: f0 0f 60 0e ldub [ %i5 + 0xe ], %i0 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40013ab0: de 0f 60 05 ldub [ %i5 + 5 ], %o7
40013ab4: f0 07 60 34 ld [ %i5 + 0x34 ], %i0
40013ab8: 92 00 bf fe add %g2, -2, %o1
40013abc: 93 2a 40 0f sll %o1, %o7, %o1
40013ac0: 10 bf ff d9 b 40013a24 <fat_file_read+0xac>
40013ac4: 92 02 40 18 add %o1, %i0, %o1
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
40013ac8: 81 c7 e0 08 ret <== NOT EXECUTED
40013acc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
40013ad0: 80 a6 80 02 cmp %i2, %g2
40013ad4: 28 bf ff b7 bleu,a 400139b0 <fat_file_read+0x38>
40013ad8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
40013adc: 10 bf ff b4 b 400139ac <fat_file_read+0x34>
40013ae0: b6 20 40 1a sub %g1, %i2, %i3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40013ae4: 80 a0 60 00 cmp %g1, 0
40013ae8: 32 bf ff b6 bne,a 400139c0 <fat_file_read+0x48> <== NEVER TAKEN
40013aec: e4 0f 60 08 ldub [ %i5 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
40013af0: 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)) &&
40013af4: 80 88 60 03 btst 3, %g1
40013af8: 22 bf ff b2 be,a 400139c0 <fat_file_read+0x48>
40013afc: 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);
40013b00: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40013b04: 80 a0 60 00 cmp %g1, 0
40013b08: 32 80 00 12 bne,a 40013b50 <fat_file_read+0x1d8> <== NEVER TAKEN
40013b0c: c6 0f 60 05 ldub [ %i5 + 5 ], %g3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40013b10: d2 07 60 20 ld [ %i5 + 0x20 ], %o1
sec += (start >> fs_info->vol.sec_log2);
40013b14: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
byte = start & (fs_info->vol.bps - 1);
40013b18: 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);
40013b1c: 83 36 80 01 srl %i2, %g1, %g1
byte = start & (fs_info->vol.bps - 1);
40013b20: 94 02 bf ff add %o2, -1, %o2
ret = _fat_block_read(fs_info, sec, byte, count, buf);
40013b24: 90 10 00 1d mov %i5, %o0
40013b28: 92 02 40 01 add %o1, %g1, %o1
40013b2c: 94 0e 80 0a and %i2, %o2, %o2
40013b30: 96 10 00 1b mov %i3, %o3
40013b34: 40 00 02 e9 call 400146d8 <_fat_block_read>
40013b38: 98 10 00 1c mov %i4, %o4
if ( ret < 0 )
40013b3c: b0 92 20 00 orcc %o0, 0, %i0
40013b40: 16 80 00 11 bge 40013b84 <fat_file_read+0x20c> <== ALWAYS TAKEN
40013b44: 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;
40013b48: 81 c7 e0 08 ret <== NOT EXECUTED
40013b4c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40013b50: c4 07 60 34 ld [ %i5 + 0x34 ], %g2 <== NOT EXECUTED
40013b54: 92 00 7f fe add %g1, -2, %o1 <== NOT EXECUTED
40013b58: 93 2a 40 03 sll %o1, %g3, %o1 <== NOT EXECUTED
40013b5c: 10 bf ff ee b 40013b14 <fat_file_read+0x19c> <== NOT EXECUTED
40013b60: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
40013b64: b0 10 00 11 mov %l1, %i0
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
40013b68: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
40013b6c: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
40013b70: e6 26 60 38 st %l3, [ %i1 + 0x38 ]
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
40013b74: a2 06 80 11 add %i2, %l1, %l1
40013b78: a3 34 40 01 srl %l1, %g1, %l1
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
40013b7c: a4 04 40 12 add %l1, %l2, %l2
40013b80: e4 26 60 34 st %l2, [ %i1 + 0x34 ]
40013b84: 81 c7 e0 08 ret
40013b88: 81 e8 00 00 restore
40014380 <fat_file_size>:
int
fat_file_size(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
40014380: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
40014384: f8 06 60 1c ld [ %i1 + 0x1c ], %i4
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40014388: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
4001438c: 80 a0 60 01 cmp %g1, 1
40014390: 02 80 00 21 be 40014414 <fat_file_size+0x94>
40014394: f8 27 bf fc st %i4, [ %fp + -4 ]
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
40014398: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
4001439c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400143a0: 84 0f 00 02 and %i4, %g2, %g2
400143a4: 80 a0 80 01 cmp %g2, %g1
400143a8: 0a 80 00 0e bcs 400143e0 <fat_file_size+0x60> <== ALWAYS TAKEN
400143ac: c0 26 60 18 clr [ %i1 + 0x18 ]
fat_file_fd_t *fat_fd
)
{
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
400143b0: 10 80 00 15 b 40014404 <fat_file_size+0x84> <== NOT EXECUTED
400143b4: b8 10 20 00 clr %i4 <== NOT EXECUTED
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
400143b8: f6 06 60 18 ld [ %i1 + 0x18 ], %i3
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
400143bc: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
400143c0: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
400143c4: c2 07 bf fc ld [ %fp + -4 ], %g1
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
400143c8: 88 06 c0 04 add %i3, %g4, %g4
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
400143cc: 86 08 40 03 and %g1, %g3, %g3
400143d0: 80 a0 c0 02 cmp %g3, %g2
400143d4: 1a 80 00 0c bcc 40014404 <fat_file_size+0x84> <== ALWAYS TAKEN
400143d8: c8 26 60 18 st %g4, [ %i1 + 0x18 ]
400143dc: b8 10 00 01 mov %g1, %i4 <== NOT EXECUTED
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
400143e0: 92 10 00 1c mov %i4, %o1
400143e4: 90 10 00 18 mov %i0, %o0
400143e8: 40 00 1b d5 call 4001b33c <fat_get_fat_cluster>
400143ec: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
400143f0: 80 a2 20 00 cmp %o0, 0
400143f4: 22 bf ff f1 be,a 400143b8 <fat_file_size+0x38> <== ALWAYS TAKEN
400143f8: c8 16 20 06 lduh [ %i0 + 6 ], %g4
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
return rc;
}
400143fc: 81 c7 e0 08 ret <== NOT EXECUTED
40014400: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
40014404: 90 10 20 00 clr %o0
40014408: f8 26 60 3c st %i4, [ %i1 + 0x3c ]
return rc;
}
4001440c: 81 c7 e0 08 ret
40014410: 91 e8 00 08 restore %g0, %o0, %o0
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
40014414: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40014418: 80 a0 60 00 cmp %g1, 0
4001441c: 32 bf ff e0 bne,a 4001439c <fat_file_size+0x1c> <== NEVER TAKEN
40014420: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
40014424: 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)) &&
40014428: 80 88 60 03 btst 3, %g1
4001442c: 22 bf ff dc be,a 4001439c <fat_file_size+0x1c> <== ALWAYS TAKEN
40014430: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
40014434: c2 06 20 2c ld [ %i0 + 0x2c ], %g1 <== NOT EXECUTED
return rc;
40014438: 90 10 20 00 clr %o0 <== NOT EXECUTED
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
4001443c: 10 bf ff f0 b 400143fc <fat_file_size+0x7c> <== NOT EXECUTED
40014440: c2 26 60 18 st %g1, [ %i1 + 0x18 ] <== NOT EXECUTED
40013b8c <fat_file_truncate>:
fat_file_truncate(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
40013b8c: 9d e3 bf 98 save %sp, -104, %sp
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
40013b90: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
)
{
int rc = RC_OK;
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
40013b94: 84 10 3f ff mov -1, %g2
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
int rc = RC_OK;
uint32_t cur_cln = 0;
40013b98: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
40013b9c: 80 a0 40 1a cmp %g1, %i2
40013ba0: 08 80 00 26 bleu 40013c38 <fat_file_truncate+0xac>
40013ba4: c4 27 bf fc st %g2, [ %fp + -4 ]
return rc;
assert(fat_fd->fat_file_size);
40013ba8: 80 a0 60 00 cmp %g1, 0
40013bac: 02 80 00 31 be 40013c70 <fat_file_truncate+0xe4> <== NEVER TAKEN
40013bb0: 11 10 00 b7 sethi %hi(0x4002dc00), %o0
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
40013bb4: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
40013bb8: c6 16 20 06 lduh [ %i0 + 6 ], %g3
40013bbc: 86 00 ff ff add %g3, -1, %g3
40013bc0: b4 00 c0 1a add %g3, %i2, %i2
40013bc4: b5 36 80 02 srl %i2, %g2, %i2
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
40013bc8: 85 2e 80 02 sll %i2, %g2, %g2
40013bcc: 80 a0 40 02 cmp %g1, %g2
40013bd0: 08 80 00 1a bleu 40013c38 <fat_file_truncate+0xac>
40013bd4: 80 a6 a0 00 cmp %i2, 0
return RC_OK;
if (cl_start != 0)
40013bd8: 02 80 00 09 be 40013bfc <fat_file_truncate+0x70>
40013bdc: 90 10 00 18 mov %i0, %o0
{
rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
40013be0: 92 10 00 19 mov %i1, %o1
40013be4: 94 06 bf ff add %i2, -1, %o2
40013be8: 7f ff fe 81 call 400135ec <fat_file_lseek>
40013bec: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
40013bf0: 80 a2 60 00 cmp %o1, 0
40013bf4: 12 80 00 12 bne 40013c3c <fat_file_truncate+0xb0> <== NEVER TAKEN
40013bf8: 90 10 00 18 mov %i0, %o0
return rc;
}
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
40013bfc: 92 10 00 19 mov %i1, %o1
40013c00: 94 10 00 1a mov %i2, %o2
40013c04: 7f ff fe 7a call 400135ec <fat_file_lseek>
40013c08: 96 07 bf f8 add %fp, -8, %o3
if (rc != RC_OK)
40013c0c: 80 a2 60 00 cmp %o1, 0
40013c10: 12 80 00 0b bne 40013c3c <fat_file_truncate+0xb0> <== NEVER TAKEN
40013c14: 01 00 00 00 nop
return rc;
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
40013c18: d2 07 bf f8 ld [ %fp + -8 ], %o1
40013c1c: 40 00 1e fe call 4001b814 <fat_free_fat_clusters_chain>
40013c20: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
40013c24: 92 92 20 00 orcc %o0, 0, %o1
40013c28: 12 80 00 05 bne 40013c3c <fat_file_truncate+0xb0> <== NEVER TAKEN
40013c2c: 80 a6 a0 00 cmp %i2, 0
return rc;
if (cl_start != 0)
40013c30: 12 80 00 05 bne 40013c44 <fat_file_truncate+0xb8>
40013c34: d2 07 bf fc ld [ %fp + -4 ], %o1
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
return rc;
40013c38: 92 10 20 00 clr %o1
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
}
return RC_OK;
}
40013c3c: 81 c7 e0 08 ret
40013c40: 91 e8 00 09 restore %g0, %o1, %o0
if (rc != RC_OK)
return rc;
if (cl_start != 0)
{
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
40013c44: 90 10 00 18 mov %i0, %o0
40013c48: 40 00 1e 41 call 4001b54c <fat_set_fat_cluster>
40013c4c: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
40013c50: 92 92 20 00 orcc %o0, 0, %o1
40013c54: 12 bf ff fa bne 40013c3c <fat_file_truncate+0xb0> <== NEVER TAKEN
40013c58: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
fat_fd->map.file_cln = cl_start - 1;
40013c5c: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = new_last_cln;
40013c60: 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;
40013c64: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
40013c68: 10 bf ff f5 b 40013c3c <fat_file_truncate+0xb0>
40013c6c: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
if ( new_length >= fat_fd->fat_file_size )
return rc;
assert(fat_fd->fat_file_size);
40013c70: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
40013c74: 17 10 00 b7 sethi %hi(0x4002dc00), %o3 <== NOT EXECUTED
40013c78: 90 12 22 b8 or %o0, 0x2b8, %o0 <== NOT EXECUTED
40013c7c: 92 10 22 d1 mov 0x2d1, %o1 <== NOT EXECUTED
40013c80: 94 12 a3 18 or %o2, 0x318, %o2 <== NOT EXECUTED
40013c84: 7f ff c7 de call 40005bfc <__assert_func> <== NOT EXECUTED
40013c88: 96 12 e3 00 or %o3, 0x300, %o3 <== NOT EXECUTED
40014070 <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
40014070: 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;
40014074: c0 27 bf f8 clr [ %fp + -8 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
40014078: 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;
4001407c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t file_cln_initial = fat_fd->map.file_cln;
40014080: e4 06 60 34 ld [ %i1 + 0x34 ], %l2
uint32_t cln;
if ( count == 0 )
40014084: 80 a6 e0 00 cmp %i3, 0
40014088: 02 80 00 5d be 400141fc <fat_file_write+0x18c> <== NEVER TAKEN
4001408c: b0 10 20 00 clr %i0
return cmpltd;
if (start >= fat_fd->size_limit)
40014090: fa 06 60 14 ld [ %i1 + 0x14 ], %i5
40014094: 80 a6 80 1d cmp %i2, %i5
40014098: 1a 80 00 89 bcc 400142bc <fat_file_write+0x24c> <== NEVER TAKEN
4001409c: ba 27 40 1a sub %i5, %i2, %i5
400140a0: 80 a7 40 1b cmp %i5, %i3
int rc = RC_OK;
ssize_t ret;
uint32_t cmpltd = 0;
uint32_t byte;
uint32_t c = 0;
bool zero_fill = start > fat_fd->fat_file_size;
400140a4: 18 80 00 58 bgu 40014204 <fat_file_write+0x194> <== ALWAYS TAKEN
400140a8: 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);
400140ac: b6 07 40 1a add %i5, %i2, %i3 <== NOT EXECUTED
400140b0: 94 40 20 00 addx %g0, 0, %o2 <== NOT EXECUTED
400140b4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
400140b8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400140bc: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
400140c0: 7f ff ff 57 call 40013e1c <fat_file_extend> <== NOT EXECUTED
400140c4: 98 07 bf f8 add %fp, -8, %o4 <== NOT EXECUTED
if (RC_OK == rc)
400140c8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
400140cc: 12 80 00 4c bne 400141fc <fat_file_write+0x18c> <== NOT EXECUTED
400140d0: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
{
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
400140d4: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
400140d8: 32 80 00 02 bne,a 400140e0 <fat_file_write+0x70> <== NEVER TAKEN
400140dc: 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));
400140e0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
400140e4: 80 a0 60 01 cmp %g1, 1
400140e8: 02 80 00 5b be 40014254 <fat_file_write+0x1e4>
400140ec: c4 0c 20 0e ldub [ %l0 + 0xe ], %g2
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
400140f0: f6 0c 20 08 ldub [ %l0 + 8 ], %i3
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
400140f4: 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;
400140f8: ab 36 80 1b srl %i2, %i3, %l5
uint32_t file_cln_cnt;
ssize_t ret;
uint32_t c;
bool overwrite_cluster = false;
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
400140fc: 90 10 00 10 mov %l0, %o0
40014100: 92 10 00 19 mov %i1, %o1
40014104: 94 10 00 15 mov %l5, %o2
40014108: 7f ff fd 39 call 400135ec <fat_file_lseek>
4001410c: 96 07 bf fc add %fp, -4, %o3
if (RC_OK == rc)
40014110: 80 a2 60 00 cmp %o1, 0
40014114: 12 80 00 38 bne 400141f4 <fat_file_write+0x184> <== NEVER TAKEN
40014118: b0 92 60 00 orcc %o1, 0, %i0
{
file_cln_cnt = cur_cln - fat_fd->cln;
4001411c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
40014120: ec 07 bf fc ld [ %fp + -4 ], %l6
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
40014124: b7 2d 40 1b sll %l5, %i3, %i3
bool overwrite_cluster = false;
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
if (RC_OK == rc)
{
file_cln_cnt = cur_cln - fat_fd->cln;
40014128: ac 25 80 01 sub %l6, %g1, %l6
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
4001412c: 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;
40014130: b0 10 20 00 clr %i0
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
40014134: a2 10 00 1a mov %i2, %l1
uint32_t ofs_cln_save = ofs_cln;
uint32_t bytes_to_write = count;
uint32_t file_cln_cnt;
ssize_t ret;
uint32_t c;
bool overwrite_cluster = false;
40014138: a6 10 20 00 clr %l3
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
4001413c: a8 10 20 00 clr %l4
const uint32_t count,
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
40014140: b6 10 20 00 clr %i3
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
if (RC_OK == rc)
{
file_cln_cnt = cur_cln - fat_fd->cln;
while ( (RC_OK == rc)
40014144: 80 a7 60 00 cmp %i5, 0
40014148: 22 80 00 21 be,a 400141cc <fat_file_write+0x15c> <== NEVER TAKEN
4001414c: c2 0c 20 08 ldub [ %l0 + 8 ], %g1 <== NOT EXECUTED
40014150: 80 a6 20 00 cmp %i0, 0
40014154: 32 80 00 1e bne,a 400141cc <fat_file_write+0x15c> <== NEVER TAKEN
40014158: c2 0c 20 08 ldub [ %l0 + 8 ], %g1 <== NOT EXECUTED
&& (bytes_to_write > 0))
{
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
4001415c: d6 14 20 06 lduh [ %l0 + 6 ], %o3
40014160: 96 22 c0 11 sub %o3, %l1, %o3
40014164: 80 a2 c0 1d cmp %o3, %i5
40014168: 38 80 00 02 bgu,a 40014170 <fat_file_write+0x100>
4001416c: 96 10 00 1d mov %i5, %o3
if (file_cln_initial < file_cln_cnt)
40014170: 80 a4 80 16 cmp %l2, %l6
40014174: 2a 80 00 02 bcs,a 4001417c <fat_file_write+0x10c>
40014178: a6 10 20 01 mov 1, %l3
overwrite_cluster = true;
ret = fat_cluster_write(fs_info,
4001417c: d2 07 bf fc ld [ %fp + -4 ], %o1
40014180: 90 10 00 10 mov %l0, %o0
40014184: 94 10 00 11 mov %l1, %o2
40014188: 98 07 00 1b add %i4, %i3, %o4
4001418c: 9a 0c e0 01 and %l3, 1, %o5
40014190: 40 00 01 fe call 40014988 <fat_cluster_write>
40014194: b0 10 3f ff mov -1, %i0
cur_cln,
ofs_cln,
c,
&buf[cmpltd],
overwrite_cluster);
if (0 > ret)
40014198: 80 a2 20 00 cmp %o0, 0
4001419c: 06 bf ff eb bl 40014148 <fat_file_write+0xd8> <== NEVER TAKEN
400141a0: 80 a7 60 00 cmp %i5, 0
rc = -1;
if (RC_OK == rc)
{
++file_cln_cnt;
400141a4: ac 05 a0 01 inc %l6
bytes_to_write -= ret;
cmpltd += ret;
400141a8: b6 06 c0 08 add %i3, %o0, %i3
save_cln = cur_cln;
if (0 < bytes_to_write)
400141ac: ba a7 40 08 subcc %i5, %o0, %i5
400141b0: 12 80 00 22 bne 40014238 <fat_file_write+0x1c8>
400141b4: e8 07 bf fc ld [ %fp + -4 ], %l4
400141b8: 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)
400141bc: 80 a7 60 00 cmp %i5, 0
400141c0: 12 bf ff e4 bne 40014150 <fat_file_write+0xe0> <== NEVER TAKEN
400141c4: a2 10 20 00 clr %l1
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
400141c8: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
400141cc: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
400141d0: e8 26 60 38 st %l4, [ %i1 + 0x38 ]
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
400141d4: b4 06 80 1b add %i2, %i3, %i2
400141d8: b5 36 80 01 srl %i2, %g1, %i2
}
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
400141dc: aa 06 80 15 add %i2, %l5, %l5
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
}
if (RC_OK != rc)
400141e0: 92 96 20 00 orcc %i0, 0, %o1
400141e4: 12 80 00 03 bne 400141f0 <fat_file_write+0x180> <== NEVER TAKEN
400141e8: ea 26 60 34 st %l5, [ %i1 + 0x34 ]
return rc;
else
return cmpltd;
400141ec: 92 10 00 1b mov %i3, %o1
fat_fd,
start,
count,
buf,
file_cln_initial);
if (0 > ret)
400141f0: b0 92 60 00 orcc %o1, 0, %i0
400141f4: 06 80 00 30 bl 400142b4 <fat_file_write+0x244> <== NEVER TAKEN
400141f8: 01 00 00 00 nop
}
if (RC_OK != rc)
return rc;
else
return cmpltd;
}
400141fc: 81 c7 e0 08 ret
40014200: 81 e8 00 00 restore
40014204: ba 10 00 1b mov %i3, %i5
rtems_set_errno_and_return_minus_one(EFBIG);
if (count > fat_fd->size_limit - start)
count = fat_fd->size_limit - start;
rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
40014208: 94 40 20 00 addx %g0, 0, %o2
4001420c: b6 07 40 1a add %i5, %i2, %i3
40014210: 90 10 00 10 mov %l0, %o0
40014214: 92 10 00 19 mov %i1, %o1
40014218: 96 10 00 1b mov %i3, %o3
4001421c: 7f ff ff 00 call 40013e1c <fat_file_extend>
40014220: 98 07 bf f8 add %fp, -8, %o4
if (RC_OK == rc)
40014224: b0 92 20 00 orcc %o0, 0, %i0
40014228: 12 bf ff f5 bne 400141fc <fat_file_write+0x18c>
4001422c: 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))
40014230: 10 bf ff aa b 400140d8 <fat_file_write+0x68>
40014234: 80 a6 c0 01 cmp %i3, %g1
++file_cln_cnt;
bytes_to_write -= ret;
cmpltd += ret;
save_cln = cur_cln;
if (0 < bytes_to_write)
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40014238: 90 10 00 10 mov %l0, %o0
4001423c: 92 10 00 14 mov %l4, %o1
40014240: 94 07 bf fc add %fp, -4, %o2
40014244: 40 00 1c 3e call 4001b33c <fat_get_fat_cluster>
40014248: a2 10 20 00 clr %l1
4001424c: 10 bf ff be b 40014144 <fat_file_write+0xd4>
40014250: b0 10 00 08 mov %o0, %i0
*/
static bool
fat_is_fat12_or_fat16_root_dir (const fat_file_fd_t *fat_fd,
const uint8_t volume_type)
{
return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
40014254: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40014258: 80 a0 60 00 cmp %g1, 0
4001425c: 32 bf ff a6 bne,a 400140f4 <fat_file_write+0x84> <== NEVER TAKEN
40014260: f6 0c 20 08 ldub [ %l0 + 8 ], %i3 <== NOT EXECUTED
40014264: 80 88 a0 03 btst 3, %g2
40014268: 22 bf ff a3 be,a 400140f4 <fat_file_write+0x84>
4001426c: f6 0c 20 08 ldub [ %l0 + 8 ], %i3
count = c - start;
/* for the root directory of FAT12 and FAT16 we need this special handling */
if (fat_is_fat12_or_fat16_root_dir(fat_fd, fs_info->vol.type))
{
cln = fat_fd->cln;
40014270: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
cln += (start >> fs_info->vol.bpc_log2);
40014274: d2 0c 20 08 ldub [ %l0 + 8 ], %o1
byte = start & (fs_info->vol.bpc -1);
40014278: 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);
4001427c: 93 36 80 09 srl %i2, %o1, %o1
byte = start & (fs_info->vol.bpc -1);
40014280: 94 02 bf ff add %o2, -1, %o2
ret = fat_cluster_write(fs_info,
40014284: 90 10 00 10 mov %l0, %o0
40014288: 92 02 40 01 add %o1, %g1, %o1
4001428c: 94 0e 80 0a and %i2, %o2, %o2
40014290: 96 10 00 1d mov %i5, %o3
40014294: 98 10 00 1c mov %i4, %o4
40014298: 40 00 01 bc call 40014988 <fat_cluster_write>
4001429c: 9a 10 20 00 clr %o5
cln,
byte,
count,
buf,
false);
if (0 > ret)
400142a0: 80 a2 20 00 cmp %o0, 0
400142a4: 06 80 00 04 bl 400142b4 <fat_file_write+0x244> <== NEVER TAKEN
400142a8: 01 00 00 00 nop
rc = -1;
else
cmpltd = ret;
400142ac: 81 c7 e0 08 ret
400142b0: 91 e8 00 08 restore %g0, %o0, %o0
start,
count,
buf,
file_cln_initial);
if (0 > ret)
rc = -1;
400142b4: 81 c7 e0 08 ret <== NOT EXECUTED
400142b8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
if ( count == 0 )
return cmpltd;
if (start >= fat_fd->size_limit)
rtems_set_errno_and_return_minus_one(EFBIG);
400142bc: 40 00 24 b5 call 4001d590 <__errno> <== NOT EXECUTED
400142c0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400142c4: 82 10 20 1b mov 0x1b, %g1 <== NOT EXECUTED
400142c8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400142cc: 81 c7 e0 08 ret <== NOT EXECUTED
400142d0: 81 e8 00 00 restore <== NOT EXECUTED
4001b814 <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
4001b814: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4001b818: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
4001b81c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
4001b820: c0 27 bf fc clr [ %fp + -4 ]
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4001b824: 84 0e 40 02 and %i1, %g2, %g2
4001b828: 80 a0 80 01 cmp %g2, %g1
4001b82c: 1a 80 00 25 bcc 4001b8c0 <fat_free_fat_clusters_chain+0xac><== NEVER TAKEN
4001b830: ba 10 00 18 mov %i0, %i5
4001b834: b8 10 00 19 mov %i1, %i4
4001b838: b6 10 20 00 clr %i3
4001b83c: 10 80 00 0e b 4001b874 <fat_free_fat_clusters_chain+0x60>
4001b840: b4 10 20 00 clr %i2
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
4001b844: 7f ff ff 42 call 4001b54c <fat_set_fat_cluster>
4001b848: 01 00 00 00 nop
if ( rc != RC_OK )
4001b84c: 80 a2 20 00 cmp %o0, 0
4001b850: 02 80 00 03 be 4001b85c <fat_free_fat_clusters_chain+0x48><== ALWAYS TAKEN
4001b854: f8 07 bf fc ld [ %fp + -4 ], %i4
4001b858: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4001b85c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4001b860: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001b864: 84 0f 00 02 and %i4, %g2, %g2
4001b868: 80 a0 80 01 cmp %g2, %g1
4001b86c: 1a 80 00 17 bcc 4001b8c8 <fat_free_fat_clusters_chain+0xb4>
4001b870: b6 06 e0 01 inc %i3
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
4001b874: 92 10 00 1c mov %i4, %o1
4001b878: 94 07 bf fc add %fp, -4, %o2
4001b87c: 7f ff fe b0 call 4001b33c <fat_get_fat_cluster>
4001b880: 90 10 00 1d mov %i5, %o0
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
4001b884: 92 10 00 1c mov %i4, %o1
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
4001b888: b0 10 00 08 mov %o0, %i0
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
4001b88c: 94 10 20 00 clr %o2
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
if ( rc != RC_OK )
4001b890: 80 a6 20 00 cmp %i0, 0
4001b894: 02 bf ff ec be 4001b844 <fat_free_fat_clusters_chain+0x30><== ALWAYS TAKEN
4001b898: 90 10 00 1d mov %i5, %o0
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
4001b89c: c2 07 60 44 ld [ %i5 + 0x44 ], %g1 <== NOT EXECUTED
4001b8a0: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
4001b8a4: 02 80 00 03 be 4001b8b0 <fat_free_fat_clusters_chain+0x9c><== NOT EXECUTED
4001b8a8: 82 06 c0 01 add %i3, %g1, %g1 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
4001b8ac: c2 27 60 44 st %g1, [ %i5 + 0x44 ] <== NOT EXECUTED
fat_buf_release(fs_info);
4001b8b0: 7f ff e2 e5 call 40014444 <fat_buf_release> <== NOT EXECUTED
4001b8b4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b8b8: 81 c7 e0 08 ret <== NOT EXECUTED
4001b8bc: 81 e8 00 00 restore <== NOT EXECUTED
)
{
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
4001b8c0: b6 10 20 00 clr %i3 <== NOT EXECUTED
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
4001b8c4: b4 10 20 00 clr %i2 <== NOT EXECUTED
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
4001b8c8: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
4001b8cc: 80 a0 7f ff cmp %g1, -1
4001b8d0: 02 80 00 04 be 4001b8e0 <fat_free_fat_clusters_chain+0xcc><== ALWAYS TAKEN
4001b8d4: f2 27 60 4c st %i1, [ %i5 + 0x4c ]
fs_info->vol.free_cls += freed_cls_cnt;
4001b8d8: 82 06 c0 01 add %i3, %g1, %g1 <== NOT EXECUTED
4001b8dc: c2 27 60 44 st %g1, [ %i5 + 0x44 ] <== NOT EXECUTED
fat_buf_release(fs_info);
4001b8e0: b0 10 00 1a mov %i2, %i0
4001b8e4: 7f ff e2 d8 call 40014444 <fat_buf_release>
4001b8e8: 90 10 00 1d mov %i5, %o0
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
4001b8ec: 81 c7 e0 08 ret
4001b8f0: 81 e8 00 00 restore
400156a8 <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);
400156a8: c4 02 20 80 ld [ %o0 + 0x80 ], %g2 <== NOT EXECUTED
400156ac: c2 02 20 74 ld [ %o0 + 0x74 ], %g1 <== NOT EXECUTED
400156b0: 92 22 40 02 sub %o1, %g2, %o1 <== NOT EXECUTED
400156b4: 85 32 60 03 srl %o1, 3, %g2 <== NOT EXECUTED
400156b8: c6 08 40 02 ldub [ %g1 + %g2 ], %g3 <== NOT EXECUTED
400156bc: 92 0a 60 07 and %o1, 7, %o1 <== NOT EXECUTED
400156c0: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
400156c4: 93 29 00 09 sll %g4, %o1, %o1 <== NOT EXECUTED
400156c8: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
400156cc: 81 c3 e0 08 retl <== NOT EXECUTED
400156d0: d2 28 40 02 stb %o1, [ %g1 + %g2 ] <== NOT EXECUTED
4001b33c <fat_get_fat_cluster>:
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
4001b33c: 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)) )
4001b340: 80 a6 60 01 cmp %i1, 1
4001b344: 08 80 00 27 bleu 4001b3e0 <fat_get_fat_cluster+0xa4> <== NEVER TAKEN
4001b348: ba 10 00 18 mov %i0, %i5
4001b34c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
4001b350: 82 00 60 01 inc %g1
4001b354: 80 a6 40 01 cmp %i1, %g1
4001b358: 18 80 00 22 bgu 4001b3e0 <fat_get_fat_cluster+0xa4> <== NEVER TAKEN
4001b35c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4001b360: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
4001b364: 80 88 60 01 btst 1, %g1
4001b368: 12 80 00 24 bne 4001b3f8 <fat_get_fat_cluster+0xbc>
4001b36c: f6 0e 20 02 ldub [ %i0 + 2 ], %i3
4001b370: 82 08 60 02 and %g1, 2, %g1
4001b374: 80 88 60 ff btst 0xff, %g1
4001b378: 02 80 00 30 be 4001b438 <fat_get_fat_cluster+0xfc>
4001b37c: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4001b380: b9 2e 60 01 sll %i1, 1, %i4
4001b384: b7 37 00 1b srl %i4, %i3, %i3
4001b388: b6 06 c0 01 add %i3, %g1, %i3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4001b38c: e0 17 40 00 lduh [ %i5 ], %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4001b390: 90 10 00 1d mov %i5, %o0
4001b394: 92 10 00 1b mov %i3, %o1
4001b398: 94 10 20 01 mov 1, %o2
4001b39c: 7f ff e4 a1 call 40014620 <fat_buf_access>
4001b3a0: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
4001b3a4: b0 92 20 00 orcc %o0, 0, %i0
4001b3a8: 12 80 00 57 bne 4001b504 <fat_get_fat_cluster+0x1c8> <== NEVER TAKEN
4001b3ac: 01 00 00 00 nop
return rc;
switch ( fs_info->vol.type )
4001b3b0: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4001b3b4: a1 2c 20 10 sll %l0, 0x10, %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
4001b3b8: 80 a0 60 02 cmp %g1, 2
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4001b3bc: a1 34 20 10 srl %l0, 0x10, %l0
4001b3c0: a0 04 3f ff add %l0, -1, %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
4001b3c4: 02 80 00 21 be 4001b448 <fat_get_fat_cluster+0x10c>
4001b3c8: b8 0f 00 10 and %i4, %l0, %i4
4001b3cc: 80 a0 60 04 cmp %g1, 4
4001b3d0: 02 80 00 3c be 4001b4c0 <fat_get_fat_cluster+0x184>
4001b3d4: 80 a0 60 01 cmp %g1, 1
4001b3d8: 02 80 00 28 be 4001b478 <fat_get_fat_cluster+0x13c> <== ALWAYS TAKEN
4001b3dc: c4 07 bf fc ld [ %fp + -4 ], %g2
*ret_val = *((uint32_t *)(sec_buf + ofs));
*ret_val = CF_LE_L(*ret_val);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
4001b3e0: 40 00 08 6c call 4001d590 <__errno> <== NOT EXECUTED
4001b3e4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001b3e8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001b3ec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001b3f0: 81 c7 e0 08 ret <== NOT EXECUTED
4001b3f4: 81 e8 00 00 restore <== NOT EXECUTED
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4001b3f8: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4001b3fc: b9 36 60 01 srl %i1, 1, %i4
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4001b400: e0 17 40 00 lduh [ %i5 ], %l0
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4001b404: b8 07 00 19 add %i4, %i1, %i4
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4001b408: 90 10 00 1d mov %i5, %o0
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4001b40c: b7 37 00 1b srl %i4, %i3, %i3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4001b410: 94 10 20 01 mov 1, %o2
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4001b414: b6 06 c0 01 add %i3, %g1, %i3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4001b418: 96 07 bf fc add %fp, -4, %o3
4001b41c: 7f ff e4 81 call 40014620 <fat_buf_access>
4001b420: 92 10 00 1b mov %i3, %o1
if (rc != RC_OK)
4001b424: b0 92 20 00 orcc %o0, 0, %i0
4001b428: 22 bf ff e3 be,a 4001b3b4 <fat_get_fat_cluster+0x78> <== ALWAYS TAKEN
4001b42c: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
4001b430: 81 c7 e0 08 ret <== NOT EXECUTED
4001b434: 81 e8 00 00 restore <== NOT EXECUTED
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4001b438: b9 2e 60 02 sll %i1, 2, %i4
4001b43c: b7 37 00 1b srl %i4, %i3, %i3
4001b440: 10 bf ff d3 b 4001b38c <fat_get_fat_cluster+0x50>
4001b444: b6 06 c0 01 add %i3, %g1, %i3
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(sec_buf + ofs));
4001b448: c2 07 bf fc ld [ %fp + -4 ], %g1
*ret_val = CF_LE_W(*ret_val);
4001b44c: 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));
4001b450: c2 10 40 1c lduh [ %g1 + %i4 ], %g1
*ret_val = CF_LE_W(*ret_val);
4001b454: 86 10 e3 ff or %g3, 0x3ff, %g3
4001b458: 83 28 60 10 sll %g1, 0x10, %g1
4001b45c: 85 30 60 18 srl %g1, 0x18, %g2
4001b460: 83 30 60 08 srl %g1, 8, %g1
4001b464: 82 08 40 03 and %g1, %g3, %g1
4001b468: 82 10 80 01 or %g2, %g1, %g1
4001b46c: c2 26 80 00 st %g1, [ %i2 ]
break;
4001b470: 81 c7 e0 08 ret
4001b474: 81 e8 00 00 restore
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
if ( ofs == (fs_info->vol.bps - 1) )
4001b478: c6 17 40 00 lduh [ %i5 ], %g3
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
4001b47c: c2 08 80 1c ldub [ %g2 + %i4 ], %g1
if ( ofs == (fs_info->vol.bps - 1) )
4001b480: 86 00 ff ff add %g3, -1, %g3
4001b484: 80 a0 c0 1c cmp %g3, %i4
4001b488: 02 80 00 21 be 4001b50c <fat_get_fat_cluster+0x1d0> <== NEVER TAKEN
4001b48c: c2 26 80 00 st %g1, [ %i2 ]
*ret_val |= *sec_buf << 8;
}
else
{
*ret_val |= *(sec_buf + ofs + 1) << 8;
4001b490: b8 00 80 1c add %g2, %i4, %i4
4001b494: c4 0f 20 01 ldub [ %i4 + 1 ], %g2
4001b498: 85 28 a0 08 sll %g2, 8, %g2
4001b49c: 82 10 80 01 or %g2, %g1, %g1
4001b4a0: c2 26 80 00 st %g1, [ %i2 ]
}
if ( FAT_CLUSTER_IS_ODD(cln) )
4001b4a4: 80 8e 60 01 btst 1, %i1
4001b4a8: 22 80 00 16 be,a 4001b500 <fat_get_fat_cluster+0x1c4>
4001b4ac: 82 08 6f ff and %g1, 0xfff, %g1
*ret_val = (*ret_val) >> FAT12_SHIFT;
4001b4b0: 83 30 60 04 srl %g1, 4, %g1
4001b4b4: c2 26 80 00 st %g1, [ %i2 ]
4001b4b8: 81 c7 e0 08 ret
4001b4bc: 81 e8 00 00 restore
*ret_val = *((uint16_t *)(sec_buf + ofs));
*ret_val = CF_LE_W(*ret_val);
break;
case FAT_FAT32:
*ret_val = *((uint32_t *)(sec_buf + ofs));
4001b4c0: c2 07 bf fc ld [ %fp + -4 ], %g1
4001b4c4: c2 00 40 1c ld [ %g1 + %i4 ], %g1
4001b4c8: 89 28 60 18 sll %g1, 0x18, %g4
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
4001b4cc: 85 30 60 18 srl %g1, 0x18, %g2
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
4001b4d0: 87 30 60 08 srl %g1, 8, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001b4d4: 84 11 00 02 or %g4, %g2, %g2
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
4001b4d8: 86 08 e0 ff and %g3, 0xff, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
4001b4dc: 83 30 60 10 srl %g1, 0x10, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001b4e0: 87 28 e0 10 sll %g3, 0x10, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
4001b4e4: 82 08 60 ff and %g1, 0xff, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001b4e8: 84 10 80 03 or %g2, %g3, %g2
4001b4ec: 83 28 60 08 sll %g1, 8, %g1
4001b4f0: 82 10 80 01 or %g2, %g1, %g1
*ret_val = CF_LE_L(*ret_val);
4001b4f4: c2 26 80 00 st %g1, [ %i2 ]
break;
4001b4f8: 81 c7 e0 08 ret
4001b4fc: 81 e8 00 00 restore
}
if ( FAT_CLUSTER_IS_ODD(cln) )
*ret_val = (*ret_val) >> FAT12_SHIFT;
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
4001b500: c2 26 80 00 st %g1, [ %i2 ]
4001b504: 81 c7 e0 08 ret
4001b508: 81 e8 00 00 restore
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
4001b50c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b510: 92 06 e0 01 add %i3, 1, %o1 <== NOT EXECUTED
4001b514: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001b518: 7f ff e4 42 call 40014620 <fat_buf_access> <== NOT EXECUTED
4001b51c: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
4001b520: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001b524: 12 80 00 08 bne 4001b544 <fat_get_fat_cluster+0x208> <== NOT EXECUTED
4001b528: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
return rc;
*ret_val |= *sec_buf << 8;
4001b52c: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
4001b530: c4 08 80 00 ldub [ %g2 ], %g2 <== NOT EXECUTED
4001b534: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
4001b538: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
4001b53c: 10 bf ff da b 4001b4a4 <fat_get_fat_cluster+0x168> <== NOT EXECUTED
4001b540: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
4001b544: 81 c7 e0 08 ret <== NOT EXECUTED
4001b548: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
400155b8 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
400155b8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
400155bc: fa 06 20 7c ld [ %i0 + 0x7c ], %i5 <== NOT EXECUTED
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
400155c0: 33 03 ff ff sethi %hi(0xffffc00), %i1 <== NOT EXECUTED
400155c4: b2 16 63 ff or %i1, 0x3ff, %i1 ! fffffff <RAM_SIZE+0xfbfffff><== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
400155c8: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
400155cc: 22 80 00 20 be,a 4001564c <fat_get_unique_ino+0x94> <== NOT EXECUTED
400155d0: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
400155d4: c6 06 20 74 ld [ %i0 + 0x74 ], %g3 <== NOT EXECUTED
400155d8: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 <== NOT EXECUTED
400155dc: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
400155e0: c8 48 c0 02 ldsb [ %g3 + %g2 ], %g4 <== NOT EXECUTED
400155e4: b8 08 60 07 and %g1, 7, %i4 <== NOT EXECUTED
400155e8: b4 00 c0 02 add %g3, %g2, %i2 <== NOT EXECUTED
400155ec: 89 39 00 1c sra %g4, %i4, %g4 <== NOT EXECUTED
400155f0: 80 89 20 01 btst 1, %g4 <== NOT EXECUTED
400155f4: 02 80 00 1d be 40015668 <fat_get_unique_ino+0xb0> <== NOT EXECUTED
400155f8: c4 08 c0 02 ldub [ %g3 + %g2 ], %g2 <== NOT EXECUTED
400155fc: 10 80 00 0a b 40015624 <fat_get_unique_ino+0x6c> <== NOT EXECUTED
40015600: 88 10 20 00 clr %g4 <== NOT EXECUTED
40015604: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
40015608: f6 48 c0 02 ldsb [ %g3 + %g2 ], %i3 <== NOT EXECUTED
4001560c: b8 08 60 07 and %g1, 7, %i4 <== NOT EXECUTED
40015610: b4 00 c0 02 add %g3, %g2, %i2 <== NOT EXECUTED
40015614: b7 3e c0 1c sra %i3, %i4, %i3 <== NOT EXECUTED
40015618: 80 8e e0 01 btst 1, %i3 <== NOT EXECUTED
4001561c: 02 80 00 13 be 40015668 <fat_get_unique_ino+0xb0> <== NOT EXECUTED
40015620: c4 08 c0 02 ldub [ %g3 + %g2 ], %g2 <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
}
fs_info->index++;
40015624: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
40015628: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED
4001562c: 0a 80 00 03 bcs 40015638 <fat_get_unique_ino+0x80> <== NOT EXECUTED
40015630: c2 26 20 78 st %g1, [ %i0 + 0x78 ] <== NOT EXECUTED
fs_info->index = 0;
40015634: c0 26 20 78 clr [ %i0 + 0x78 ] <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
40015638: 88 01 20 01 inc %g4 <== NOT EXECUTED
4001563c: 80 a1 00 1d cmp %g4, %i5 <== NOT EXECUTED
40015640: 32 bf ff f1 bne,a 40015604 <fat_get_unique_ino+0x4c> <== NOT EXECUTED
40015644: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 <== NOT EXECUTED
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
40015648: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
4001564c: 93 2f 60 01 sll %i5, 1, %o1 <== NOT EXECUTED
40015650: 82 26 40 01 sub %i1, %g1, %g1 <== NOT EXECUTED
40015654: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
40015658: 2a 80 00 0c bcs,a 40015688 <fat_get_unique_ino+0xd0> <== NOT EXECUTED
4001565c: d0 06 20 74 ld [ %i0 + 0x74 ], %o0 <== NOT EXECUTED
}
else
resrc_unsuff = true;
}
return 0;
}
40015660: 81 c7 e0 08 ret <== NOT EXECUTED
40015664: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
40015668: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4001566c: b9 28 40 1c sll %g1, %i4, %i4 <== NOT EXECUTED
40015670: 84 17 00 02 or %i4, %g2, %g2 <== NOT EXECUTED
40015674: c4 2e 80 00 stb %g2, [ %i2 ] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
40015678: c4 06 20 78 ld [ %i0 + 0x78 ], %g2 <== NOT EXECUTED
4001567c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
40015680: 81 c7 e0 08 ret <== NOT EXECUTED
40015684: 91 e8 80 01 restore %g2, %g1, %o0 <== NOT EXECUTED
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
40015688: 7f ff c5 c6 call 40006da0 <realloc> <== NOT EXECUTED
4001568c: d2 26 20 7c st %o1, [ %i0 + 0x7c ] <== NOT EXECUTED
if (fs_info->uino != NULL)
40015690: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40015694: 02 bf ff f3 be 40015660 <fat_get_unique_ino+0xa8> <== NOT EXECUTED
40015698: d0 26 20 74 st %o0, [ %i0 + 0x74 ] <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
4001569c: fa 06 20 7c ld [ %i0 + 0x7c ], %i5 <== NOT EXECUTED
400156a0: 10 bf ff ca b 400155c8 <fat_get_unique_ino+0x10> <== NOT EXECUTED
400156a4: fa 26 20 78 st %i5, [ %i0 + 0x78 ] <== NOT EXECUTED
4001553c <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
4001553c: 9d e3 bf 98 save %sp, -104, %sp
40015540: f2 27 bf fc st %i1, [ %fp + -4 ]
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
40015544: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
40015548: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
4001554c: 92 10 00 19 mov %i1, %o1
40015550: 94 10 20 00 clr %o2
{
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
40015554: b2 0e 40 02 and %i1, %g2, %i1
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
40015558: 98 10 20 00 clr %o4
{
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
4001555c: 80 a6 40 01 cmp %i1, %g1
40015560: 1a 80 00 10 bcc 400155a0 <fat_init_clusters_chain+0x64>
40015564: 90 10 00 18 mov %i0, %o0
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
40015568: 7f ff fc a8 call 40014808 <fat_cluster_set>
4001556c: d6 16 20 06 lduh [ %i0 + 6 ], %o3
if ( ret != fs_info->vol.bpc )
40015570: c2 16 20 06 lduh [ %i0 + 6 ], %g1
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40015574: 94 07 bf fc add %fp, -4, %o2
uint32_t cur_cln = start_cln;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
if ( ret != fs_info->vol.bpc )
40015578: 80 a0 40 08 cmp %g1, %o0
4001557c: 12 80 00 0c bne 400155ac <fat_init_clusters_chain+0x70> <== NEVER TAKEN
40015580: 90 10 00 18 mov %i0, %o0
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
40015584: 40 00 17 6e call 4001b33c <fat_get_fat_cluster>
40015588: d2 07 bf fc ld [ %fp + -4 ], %o1
if ( rc != RC_OK )
4001558c: 80 a2 20 00 cmp %o0, 0
40015590: 02 bf ff ed be 40015544 <fat_init_clusters_chain+0x8> <== ALWAYS TAKEN
40015594: f2 07 bf fc ld [ %fp + -4 ], %i1
}
}
return rc;
}
40015598: 81 c7 e0 08 ret <== NOT EXECUTED
4001559c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
return rc;
}
}
return rc;
400155a0: 90 10 20 00 clr %o0
}
400155a4: 81 c7 e0 08 ret
400155a8: 91 e8 00 08 restore %g0, %o0, %o0
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
if ( ret != fs_info->vol.bpc )
{
return -1;
400155ac: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
}
}
return rc;
}
400155b0: 81 c7 e0 08 ret <== NOT EXECUTED
400155b4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40014b10 <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)
{
40014b10: 9d e3 bf 10 save %sp, -240, %sp
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
vol->fd = open(device, O_RDWR);
40014b14: 92 10 20 02 mov 2, %o1
char boot_rec[FAT_MAX_BPB_SIZE];
char fs_info_sector[FAT_USEFUL_INFO_SIZE];
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
40014b18: c0 27 bf a4 clr [ %fp + -92 ]
vol->fd = open(device, O_RDWR);
40014b1c: 7f ff c8 04 call 40006b2c <open>
40014b20: 90 10 00 19 mov %i1, %o0
if (vol->fd < 0)
40014b24: 80 a2 20 00 cmp %o0, 0
40014b28: 06 80 01 c1 bl 4001522c <fat_init_volume_info+0x71c> <== NEVER TAKEN
40014b2c: d0 26 20 60 st %o0, [ %i0 + 0x60 ]
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
40014b30: 7f ff c4 c1 call 40005e34 <fstat>
40014b34: 92 07 bf b8 add %fp, -72, %o1
if (rc != 0)
40014b38: 80 a2 20 00 cmp %o0, 0
40014b3c: 12 80 01 b9 bne 40015220 <fat_init_volume_info+0x710> <== NEVER TAKEN
40014b40: c6 07 bf c4 ld [ %fp + -60 ], %g3
close(vol->fd);
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
40014b44: 05 00 00 3c sethi %hi(0xf000), %g2
40014b48: 86 08 c0 02 and %g3, %g2, %g3
40014b4c: 05 00 00 18 sethi %hi(0x6000), %g2
40014b50: 80 a0 c0 02 cmp %g3, %g2
40014b54: 12 80 01 b4 bne 40015224 <fat_init_volume_info+0x714> <== NEVER TAKEN
40014b58: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
40014b5c: 94 06 20 64 add %i0, 0x64, %o2
40014b60: 13 10 01 10 sethi %hi(0x40044000), %o1
40014b64: 40 00 05 c6 call 4001627c <ioctl>
40014b68: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <__end+0x13d79>
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) {
40014b6c: 80 a2 20 00 cmp %o0, 0
40014b70: 12 80 01 ac bne 40015220 <fat_init_volume_info+0x710> <== NEVER TAKEN
40014b74: 92 10 20 00 clr %o1
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dd, 0, &block);
40014b78: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
40014b7c: 7f ff f5 c8 call 4001229c <rtems_bdbuf_read>
40014b80: 94 07 bf a4 add %fp, -92, %o2
if (sc != RTEMS_SUCCESSFUL)
40014b84: 80 a2 20 00 cmp %o0, 0
40014b88: 12 80 01 b5 bne 4001525c <fat_init_volume_info+0x74c> <== NEVER TAKEN
40014b8c: d0 07 bf a4 ld [ %fp + -92 ], %o0
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
40014b90: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
40014b94: c2 08 a0 20 ldub [ %g2 + 0x20 ], %g1
40014b98: f8 08 a0 0b ldub [ %g2 + 0xb ], %i4
40014b9c: c2 2f bf 93 stb %g1, [ %fp + -109 ]
40014ba0: c2 08 a0 21 ldub [ %g2 + 0x21 ], %g1
40014ba4: f6 08 a0 0c ldub [ %g2 + 0xc ], %i3
40014ba8: c2 2f bf 95 stb %g1, [ %fp + -107 ]
40014bac: c2 08 a0 22 ldub [ %g2 + 0x22 ], %g1
40014bb0: ec 08 a0 0d ldub [ %g2 + 0xd ], %l6
40014bb4: c2 2f bf 94 stb %g1, [ %fp + -108 ]
40014bb8: c2 08 a0 23 ldub [ %g2 + 0x23 ], %g1
40014bbc: e8 08 a0 0e ldub [ %g2 + 0xe ], %l4
40014bc0: c2 2f bf 8f stb %g1, [ %fp + -113 ]
40014bc4: c2 08 a0 25 ldub [ %g2 + 0x25 ], %g1
40014bc8: ea 08 a0 0f ldub [ %g2 + 0xf ], %l5
40014bcc: c2 2f bf 97 stb %g1, [ %fp + -105 ]
40014bd0: c2 08 a0 26 ldub [ %g2 + 0x26 ], %g1
40014bd4: fa 08 a0 10 ldub [ %g2 + 0x10 ], %i5
40014bd8: c2 2f bf 96 stb %g1, [ %fp + -106 ]
40014bdc: c2 08 a0 27 ldub [ %g2 + 0x27 ], %g1
40014be0: f4 08 a0 11 ldub [ %g2 + 0x11 ], %i2
40014be4: c2 2f bf 9f stb %g1, [ %fp + -97 ]
40014be8: c2 08 a0 28 ldub [ %g2 + 0x28 ], %g1
40014bec: f2 08 a0 12 ldub [ %g2 + 0x12 ], %i1
40014bf0: c2 2f bf 87 stb %g1, [ %fp + -121 ]
40014bf4: c2 08 a0 2c ldub [ %g2 + 0x2c ], %g1
40014bf8: e0 08 a0 13 ldub [ %g2 + 0x13 ], %l0
40014bfc: c2 2f bf 90 stb %g1, [ %fp + -112 ]
40014c00: c2 08 a0 2d ldub [ %g2 + 0x2d ], %g1
40014c04: e2 08 a0 14 ldub [ %g2 + 0x14 ], %l1
40014c08: e4 08 a0 16 ldub [ %g2 + 0x16 ], %l2
40014c0c: e6 08 a0 17 ldub [ %g2 + 0x17 ], %l3
40014c10: ee 08 a0 24 ldub [ %g2 + 0x24 ], %l7
40014c14: c2 2f bf 7f stb %g1, [ %fp + -129 ]
40014c18: c2 08 a0 2e ldub [ %g2 + 0x2e ], %g1
40014c1c: c2 2f bf 7e stb %g1, [ %fp + -130 ]
40014c20: c2 08 a0 2f ldub [ %g2 + 0x2f ], %g1
40014c24: c2 2f bf 77 stb %g1, [ %fp + -137 ]
40014c28: c2 08 a0 30 ldub [ %g2 + 0x30 ], %g1
40014c2c: c4 08 a0 31 ldub [ %g2 + 0x31 ], %g2
40014c30: c2 2f bf 92 stb %g1, [ %fp + -110 ]
sc = rtems_bdbuf_release( block);
40014c34: 7f ff f6 1f call 400124b0 <rtems_bdbuf_release>
40014c38: c4 2f bf 91 stb %g2, [ %fp + -111 ]
if (sc != RTEMS_SUCCESSFUL)
40014c3c: 80 a2 20 00 cmp %o0, 0
40014c40: 12 80 01 87 bne 4001525c <fat_init_volume_info+0x74c> <== NEVER TAKEN
40014c44: b6 0e e0 ff and %i3, 0xff, %i3
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO );
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
40014c48: b8 0f 20 ff and %i4, 0xff, %i4
40014c4c: b7 2e e0 08 sll %i3, 8, %i3
40014c50: b8 16 c0 1c or %i3, %i4, %i4
40014c54: f8 36 00 00 sth %i4, [ %i0 ]
if ( (vol->bps != 512) &&
40014c58: 93 2f 20 10 sll %i4, 0x10, %o1
40014c5c: 85 32 60 10 srl %o1, 0x10, %g2
40014c60: 80 a0 a4 00 cmp %g2, 0x400
40014c64: 12 80 00 dc bne 40014fd4 <fat_init_volume_info+0x4c4> <== ALWAYS TAKEN
40014c68: 9a 10 00 1c mov %i4, %o5
(vol->bps != 4096))
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
40014c6c: 85 32 60 19 srl %o1, 0x19, %g2 <== NOT EXECUTED
40014c70: 80 88 a0 01 btst 1, %g2
40014c74: 12 80 00 0a bne 40014c9c <fat_init_volume_info+0x18c> <== ALWAYS TAKEN
40014c78: c0 2e 20 03 clrb [ %i0 + 3 ]
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(fat_fs_info_t *fs_info, const char *device)
{
40014c7c: 10 80 00 03 b 40014c88 <fat_init_volume_info+0x178> <== NOT EXECUTED
40014c80: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
(vol->bps != 4096))
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
40014c84: 88 10 00 01 mov %g1, %g4 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
40014c88: 85 38 a0 01 sra %g2, 1, %g2 <== NOT EXECUTED
(vol->bps != 4096))
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
40014c8c: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
40014c90: 02 bf ff fd be 40014c84 <fat_init_volume_info+0x174> <== NOT EXECUTED
40014c94: 82 01 20 01 add %g4, 1, %g1 <== NOT EXECUTED
40014c98: c8 2e 20 03 stb %g4, [ %i0 + 3 ] <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
40014c9c: c0 2e 20 02 clrb [ %i0 + 2 ]
40014ca0: 93 32 60 10 srl %o1, 0x10, %o1
40014ca4: b6 10 20 01 mov 1, %i3
40014ca8: 80 8f 20 01 btst 1, %i4
40014cac: 02 80 00 05 be 40014cc0 <fat_init_volume_info+0x1b0> <== ALWAYS TAKEN
40014cb0: 84 10 00 09 mov %o1, %g2
40014cb4: 10 80 01 66 b 4001524c <fat_init_volume_info+0x73c> <== NOT EXECUTED
40014cb8: b6 10 20 00 clr %i3 <== NOT EXECUTED
40014cbc: b6 10 00 01 mov %g1, %i3
i >>= 1, vol->sec_log2++);
40014cc0: 85 38 a0 01 sra %g2, 1, %g2
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
40014cc4: 80 88 a0 01 btst 1, %g2
40014cc8: 02 bf ff fd be 40014cbc <fat_init_volume_info+0x1ac>
40014ccc: 82 06 e0 01 add %i3, 1, %g1
40014cd0: f6 2e 20 02 stb %i3, [ %i0 + 2 ]
i >>= 1, vol->sec_log2++);
vol->bytes_per_block = vol->bps;
vol->bytes_per_block_log2 = vol->sec_log2;
vol->sectors_per_block = 1;
40014cd4: 84 10 20 01 mov 1, %g2
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
i >>= 1, vol->sec_log2++);
vol->bytes_per_block = vol->bps;
40014cd8: da 36 20 0a sth %o5, [ %i0 + 0xa ]
vol->bytes_per_block_log2 = vol->sec_log2;
40014cdc: f6 2e 20 0c stb %i3, [ %i0 + 0xc ]
vol->sectors_per_block = 1;
40014ce0: c4 2e 20 09 stb %g2, [ %i0 + 9 ]
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
40014ce4: b8 8d a0 ff andcc %l6, 0xff, %i4
40014ce8: 02 80 01 45 be 400151fc <fat_init_volume_info+0x6ec> <== NEVER TAKEN
40014cec: ec 2e 20 04 stb %l6, [ %i0 + 4 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
40014cf0: c0 2e 20 05 clrb [ %i0 + 5 ]
40014cf4: 80 8d a0 01 btst 1, %l6
40014cf8: 12 80 01 57 bne 40015254 <fat_init_volume_info+0x744>
40014cfc: 84 10 00 1c mov %i4, %g2
40014d00: 10 80 00 03 b 40014d0c <fat_init_volume_info+0x1fc>
40014d04: 86 10 20 01 mov 1, %g3
40014d08: 86 10 00 01 mov %g1, %g3
i >>= 1, vol->spc_log2++);
40014d0c: 85 38 a0 01 sra %g2, 1, %g2
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
40014d10: 80 88 a0 01 btst 1, %g2
40014d14: 02 bf ff fd be 40014d08 <fat_init_volume_info+0x1f8>
40014d18: 82 00 e0 01 add %g3, 1, %g1
40014d1c: c6 2e 20 05 stb %g3, [ %i0 + 5 ]
40014d20: 86 08 e0 ff and %g3, 0xff, %g3
i >>= 1, vol->spc_log2++);
/*
* "bytes per cluster" value greater than 32K is invalid
*/
if ((vol->bpc = vol->bps << vol->spc_log2) > MS_BYTES_PER_CLUSTER_LIMIT)
40014d24: 87 2a 40 03 sll %o1, %g3, %g3
40014d28: 89 28 e0 10 sll %g3, 0x10, %g4
40014d2c: 05 20 00 00 sethi %hi(0x80000000), %g2
40014d30: 80 a1 00 02 cmp %g4, %g2
40014d34: 18 80 01 32 bgu 400151fc <fat_init_volume_info+0x6ec> <== NEVER TAKEN
40014d38: c6 36 20 06 sth %g3, [ %i0 + 6 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
40014d3c: c0 2e 20 08 clrb [ %i0 + 8 ]
40014d40: 05 00 00 3f sethi %hi(0xfc00), %g2
40014d44: 88 10 20 01 mov 1, %g4
40014d48: 84 10 a3 ff or %g2, 0x3ff, %g2
40014d4c: 80 88 e0 01 btst 1, %g3
40014d50: 02 80 00 05 be 40014d64 <fat_init_volume_info+0x254> <== ALWAYS TAKEN
40014d54: 84 08 c0 02 and %g3, %g2, %g2
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
40014d58: 10 80 00 09 b 40014d7c <fat_init_volume_info+0x26c> <== NOT EXECUTED
40014d5c: b4 0e a0 ff and %i2, 0xff, %i2 <== NOT EXECUTED
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
40014d60: 88 10 00 01 mov %g1, %g4
i >>= 1, vol->bpc_log2++);
40014d64: 85 38 a0 01 sra %g2, 1, %g2
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
40014d68: 80 88 a0 01 btst 1, %g2
40014d6c: 02 bf ff fd be 40014d60 <fat_init_volume_info+0x250>
40014d70: 82 01 20 01 add %g4, 1, %g1
40014d74: c8 2e 20 08 stb %g4, [ %i0 + 8 ]
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
40014d78: b4 0e a0 ff and %i2, 0xff, %i2
40014d7c: b2 0e 60 ff and %i1, 0xff, %i1
40014d80: b3 2e 60 08 sll %i1, 8, %i1
40014d84: b2 16 40 1a or %i1, %i2, %i1
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
40014d88: 87 2e 60 10 sll %i1, 0x10, %g3
40014d8c: 87 30 e0 0b srl %g3, 0xb, %g3
40014d90: 90 02 7f ff add %o1, -1, %o0
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
40014d94: fa 2e 20 0d stb %i5, [ %i0 + 0xd ]
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
40014d98: aa 0d 60 ff and %l5, 0xff, %l5
40014d9c: a8 0d 20 ff and %l4, 0xff, %l4
40014da0: ab 2d 60 08 sll %l5, 8, %l5
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
40014da4: f2 36 20 24 sth %i1, [ %i0 + 0x24 ]
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
40014da8: a8 15 40 14 or %l5, %l4, %l4
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
40014dac: 90 00 c0 08 add %g3, %o0, %o0
40014db0: 7f ff b6 33 call 4000267c <.div>
40014db4: e8 36 20 18 sth %l4, [ %i0 + 0x18 ]
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
40014db8: b7 2a 00 1b sll %o0, %i3, %i3
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
40014dbc: d0 26 20 28 st %o0, [ %i0 + 0x28 ]
40014dc0: b4 10 00 08 mov %o0, %i2
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
40014dc4: a4 0c a0 ff and %l2, 0xff, %l2
40014dc8: 90 0c e0 ff and %l3, 0xff, %o0
40014dcc: 91 2a 20 08 sll %o0, 8, %o0
40014dd0: 90 12 00 12 or %o0, %l2, %o0
40014dd4: 91 2a 20 10 sll %o0, 0x10, %o0
40014dd8: 80 a2 20 00 cmp %o0, 0
40014ddc: 02 80 00 8a be 40015004 <fat_init_volume_info+0x4f4>
40014de0: f6 26 20 2c st %i3, [ %i0 + 0x2c ]
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
40014de4: 91 32 20 10 srl %o0, 0x10, %o0
40014de8: d0 26 20 1c st %o0, [ %i0 + 0x1c ]
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
40014dec: 92 0f 60 ff and %i5, 0xff, %o1
40014df0: 7f ff b5 e7 call 4000258c <.umul>
40014df4: a9 2d 20 10 sll %l4, 0x10, %l4
40014df8: a9 35 20 10 srl %l4, 0x10, %l4
40014dfc: 90 02 00 14 add %o0, %l4, %o0
40014e00: b4 02 00 1a add %o0, %i2, %i2
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
40014e04: d0 26 20 20 st %o0, [ %i0 + 0x20 ]
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
40014e08: 90 0c 60 ff and %l1, 0xff, %o0
40014e0c: a0 0c 20 ff and %l0, 0xff, %l0
40014e10: 91 2a 20 08 sll %o0, 8, %o0
40014e14: 90 12 00 10 or %o0, %l0, %o0
40014e18: 91 2a 20 10 sll %o0, 0x10, %o0
40014e1c: 80 a2 20 00 cmp %o0, 0
40014e20: 02 80 00 e3 be 400151ac <fat_init_volume_info+0x69c>
40014e24: f4 26 20 34 st %i2, [ %i0 + 0x34 ]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
40014e28: 91 32 20 10 srl %o0, 0x10, %o0
40014e2c: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
data_secs = vol->tot_secs - vol->data_fsec;
vol->data_cls = data_secs / vol->spc;
40014e30: 90 22 00 1a sub %o0, %i2, %o0
40014e34: 7f ff b6 10 call 40002674 <.udiv>
40014e38: 92 10 00 1c mov %i4, %o1
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
40014e3c: 80 a2 2f f4 cmp %o0, 0xff4
40014e40: 18 80 00 7d bgu 40015034 <fat_init_volume_info+0x524>
40014e44: d0 26 20 38 st %o0, [ %i0 + 0x38 ]
{
vol->type = FAT_FAT12;
40014e48: 84 10 20 01 mov 1, %g2
40014e4c: c4 2e 20 0e stb %g2, [ %i0 + 0xe ]
vol->mask = FAT_FAT12_MASK;
40014e50: 84 10 2f ff mov 0xfff, %g2
40014e54: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
vol->eoc_val = FAT_FAT12_EOC;
40014e58: 84 10 2f f8 mov 0xff8, %g2
40014e5c: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
else
{
vol->rdir_cl = 0;
vol->mirror = 0;
vol->afat = 0;
vol->free_cls = FAT_UNDEFINED_VALUE;
40014e60: 84 10 3f ff mov -1, %g2
}
}
}
else
{
vol->rdir_cl = 0;
40014e64: c0 26 20 3c clr [ %i0 + 0x3c ]
vol->mirror = 0;
40014e68: c0 2e 20 54 clrb [ %i0 + 0x54 ]
vol->afat = 0;
40014e6c: c0 2e 20 5c clrb [ %i0 + 0x5c ]
vol->free_cls = FAT_UNDEFINED_VALUE;
40014e70: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
vol->next_cl = FAT_UNDEFINED_VALUE;
40014e74: c4 26 20 4c st %g2, [ %i0 + 0x4c ]
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(fat_fs_info_t *fs_info)
{
return fat_buf_release(fs_info);
40014e78: 7f ff fd 73 call 40014444 <fat_buf_release>
40014e7c: 90 10 00 18 mov %i0, %o0
vol->next_cl = FAT_UNDEFINED_VALUE;
}
_fat_block_release(fs_info);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
40014e80: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
40014e84: 7f ff b5 c2 call 4000258c <.umul>
40014e88: d0 0e 20 5c ldub [ %i0 + 0x5c ], %o0
40014e8c: c4 16 20 18 lduh [ %i0 + 0x18 ], %g2
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
40014e90: 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;
40014e94: 84 02 00 02 add %o0, %g2, %g2
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
40014e98: 90 10 20 02 mov 2, %o0
40014e9c: 7f ff c3 85 call 40005cb0 <calloc>
40014ea0: c4 26 20 58 st %g2, [ %i0 + 0x58 ]
if ( fs_info->vhash == NULL )
40014ea4: 80 a2 20 00 cmp %o0, 0
40014ea8: 02 80 01 03 be 400152b4 <fat_init_volume_info+0x7a4> <== NEVER TAKEN
40014eac: d0 26 20 6c st %o0, [ %i0 + 0x6c ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
40014eb0: 88 02 20 04 add %o0, 4, %g4
40014eb4: 84 02 20 0c add %o0, 0xc, %g2
40014eb8: 86 02 20 10 add %o0, 0x10, %g3
head->next = tail;
40014ebc: c8 22 00 00 st %g4, [ %o0 ]
head->previous = NULL;
40014ec0: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
40014ec4: 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;
40014ec8: c6 22 20 0c st %g3, [ %o0 + 0xc ]
head->previous = NULL;
40014ecc: c0 22 20 10 clr [ %o0 + 0x10 ]
tail->previous = head;
40014ed0: 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));
40014ed4: 92 10 20 0c mov 0xc, %o1
40014ed8: 7f ff c3 76 call 40005cb0 <calloc>
40014edc: 90 10 20 02 mov 2, %o0
if ( fs_info->rhash == NULL )
40014ee0: 80 a2 20 00 cmp %o0, 0
40014ee4: 02 80 01 0c be 40015314 <fat_init_volume_info+0x804> <== NEVER TAKEN
40014ee8: d0 26 20 70 st %o0, [ %i0 + 0x70 ]
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
40014eec: c4 0e 20 03 ldub [ %i0 + 3 ], %g2
40014ef0: f8 06 20 30 ld [ %i0 + 0x30 ], %i4
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
40014ef4: 86 02 20 0c add %o0, 0xc, %g3
head->next = tail;
head->previous = NULL;
40014ef8: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
40014efc: 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;
40014f00: c0 22 20 10 clr [ %o0 + 0x10 ]
tail->previous = head;
40014f04: c6 22 20 14 st %g3, [ %o0 + 0x14 ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
40014f08: 88 02 20 10 add %o0, 0x10, %g4
40014f0c: ba 02 20 04 add %o0, 4, %i5
head->next = tail;
40014f10: c8 22 20 0c st %g4, [ %o0 + 0xc ]
40014f14: fa 22 00 00 st %i5, [ %o0 ]
40014f18: 85 2f 00 02 sll %i4, %g2, %g2
40014f1c: 85 28 a0 04 sll %g2, 4, %g2
40014f20: c4 26 20 80 st %g2, [ %i0 + 0x80 ]
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
40014f24: 84 10 21 00 mov 0x100, %g2
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
40014f28: c0 26 20 78 clr [ %i0 + 0x78 ]
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
40014f2c: c4 26 20 7c st %g2, [ %i0 + 0x7c ]
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
40014f30: 90 10 21 00 mov 0x100, %o0
40014f34: 7f ff c3 5f call 40005cb0 <calloc>
40014f38: 92 10 20 01 mov 1, %o1
if ( fs_info->uino == NULL )
40014f3c: 80 a2 20 00 cmp %o0, 0
40014f40: 02 80 00 d0 be 40015280 <fat_init_volume_info+0x770> <== NEVER TAKEN
40014f44: d0 26 20 74 st %o0, [ %i0 + 0x74 ]
close(vol->fd);
free(fs_info->vhash);
free(fs_info->rhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
40014f48: d0 16 00 00 lduh [ %i0 ], %o0
40014f4c: 7f ff c3 59 call 40005cb0 <calloc>
40014f50: 92 10 20 01 mov 1, %o1
if (fs_info->sec_buf == NULL)
40014f54: 80 a2 20 00 cmp %o0, 0
40014f58: 02 80 00 e7 be 400152f4 <fat_init_volume_info+0x7e4> <== NEVER TAKEN
40014f5c: d0 26 20 90 st %o0, [ %i0 + 0x90 ]
return bytes_written;
}
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{
return (sec_num & (vol->spc - 1)) == 0;
40014f60: c4 0e 20 04 ldub [ %i0 + 4 ], %g2
40014f64: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
40014f68: 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)
40014f6c: 80 88 80 03 btst %g2, %g3
40014f70: 12 80 00 17 bne 40014fcc <fat_init_volume_info+0x4bc> <== NEVER TAKEN
40014f74: 01 00 00 00 nop
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
40014f78: c6 0e 20 0e ldub [ %i0 + 0xe ], %g3
40014f7c: 80 a0 e0 04 cmp %g3, 4
40014f80: 22 80 00 07 be,a 40014f9c <fat_init_volume_info+0x48c>
40014f84: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
return bytes_written;
}
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{
return (sec_num & (vol->spc - 1)) == 0;
40014f88: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
* If possible we will use the cluster size as bdbuf block size for faster
* file access. This requires that certain sectors are aligned to cluster
* borders.
*/
if (is_cluster_aligned(vol, vol->data_fsec)
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
40014f8c: 80 88 80 03 btst %g2, %g3
40014f90: 12 80 00 0f bne 40014fcc <fat_init_volume_info+0x4bc> <== NEVER TAKEN
40014f94: 01 00 00 00 nop
{
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
40014f98: d0 06 20 64 ld [ %i0 + 0x64 ], %o0
40014f9c: d2 16 20 06 lduh [ %i0 + 6 ], %o1
40014fa0: 7f ff f6 83 call 400129ac <rtems_bdbuf_set_block_size>
40014fa4: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
40014fa8: 80 a2 20 00 cmp %o0, 0
40014fac: 12 80 00 08 bne 40014fcc <fat_init_volume_info+0x4bc> <== NEVER TAKEN
40014fb0: 01 00 00 00 nop
{
vol->bytes_per_block = vol->bpc;
40014fb4: c8 16 20 06 lduh [ %i0 + 6 ], %g4
vol->bytes_per_block_log2 = vol->bpc_log2;
40014fb8: c6 0e 20 08 ldub [ %i0 + 8 ], %g3
vol->sectors_per_block = vol->spc;
40014fbc: c4 0e 20 04 ldub [ %i0 + 4 ], %g2
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
{
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
if (sc == RTEMS_SUCCESSFUL)
{
vol->bytes_per_block = vol->bpc;
40014fc0: c8 36 20 0a sth %g4, [ %i0 + 0xa ]
vol->bytes_per_block_log2 = vol->bpc_log2;
40014fc4: c6 2e 20 0c stb %g3, [ %i0 + 0xc ]
vol->sectors_per_block = vol->spc;
40014fc8: c4 2e 20 09 stb %g2, [ %i0 + 9 ]
}
}
return RC_OK;
40014fcc: 81 c7 e0 08 ret
40014fd0: 91 e8 20 00 restore %g0, 0, %o0
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
if ( (vol->bps != 512) &&
40014fd4: 80 a0 a2 00 cmp %g2, 0x200
40014fd8: 22 bf ff 26 be,a 40014c70 <fat_init_volume_info+0x160> <== ALWAYS TAKEN
40014fdc: 85 32 60 19 srl %o1, 0x19, %g2
(vol->bps != 1024) &&
40014fe0: 80 a0 a8 00 cmp %g2, 0x800 <== NOT EXECUTED
40014fe4: 22 bf ff 26 be,a 40014c7c <fat_init_volume_info+0x16c> <== NOT EXECUTED
40014fe8: 85 32 60 19 srl %o1, 0x19, %g2 <== NOT EXECUTED
(vol->bps != 2048) &&
40014fec: 09 00 00 04 sethi %hi(0x1000), %g4 <== NOT EXECUTED
40014ff0: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED
40014ff4: 12 80 00 82 bne 400151fc <fat_init_volume_info+0x6ec> <== NOT EXECUTED
40014ff8: 85 32 60 19 srl %o1, 0x19, %g2 <== NOT EXECUTED
40014ffc: 10 bf ff 23 b 40014c88 <fat_init_volume_info+0x178> <== NOT EXECUTED
40015000: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
40015004: c4 0f bf 96 ldub [ %fp + -106 ], %g2
40015008: d0 0f bf 97 ldub [ %fp + -105 ], %o0
4001500c: c2 0f bf 9f ldub [ %fp + -97 ], %g1
40015010: 85 28 a0 10 sll %g2, 0x10, %g2
40015014: 91 2a 20 08 sll %o0, 8, %o0
40015018: ae 0d e0 ff and %l7, 0xff, %l7
4001501c: 90 12 00 02 or %o0, %g2, %o0
40015020: 85 28 60 18 sll %g1, 0x18, %g2
40015024: 90 12 00 17 or %o0, %l7, %o0
40015028: 90 12 00 02 or %o0, %g2, %o0
4001502c: 10 bf ff 70 b 40014dec <fat_init_volume_info+0x2dc>
40015030: d0 26 20 1c st %o0, [ %i0 + 0x1c ]
vol->mask = FAT_FAT12_MASK;
vol->eoc_val = FAT_FAT12_EOC;
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
40015034: 05 00 00 3f sethi %hi(0xfc00), %g2
40015038: 86 10 a3 f4 or %g2, 0x3f4, %g3 ! fff4 <PROM_START+0xfff4>
4001503c: 80 a2 00 03 cmp %o0, %g3
40015040: 08 80 00 67 bleu 400151dc <fat_init_volume_info+0x6cc>
40015044: 86 10 a3 ff or %g2, 0x3ff, %g3
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
40015048: c2 0f bf 87 ldub [ %fp + -121 ], %g1
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
4001504c: f8 0f bf 7f ldub [ %fp + -129 ], %i4
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
40015050: 84 08 7f 80 and %g1, -128, %g2
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40015054: f6 0f bf 90 ldub [ %fp + -112 ], %i3
40015058: c8 0f bf 7e ldub [ %fp + -130 ], %g4
4001505c: c2 0f bf 77 ldub [ %fp + -137 ], %g1
40015060: b9 2f 20 08 sll %i4, 8, %i4
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
40015064: 07 03 ff ff sethi %hi(0xffffc00), %g3
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40015068: 89 29 20 10 sll %g4, 0x10, %g4
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
4001506c: ba 10 e3 ff or %g3, 0x3ff, %i5
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40015070: 88 17 00 04 or %i4, %g4, %g4
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
vol->eoc_val = FAT_FAT32_EOC;
40015074: 86 10 e3 f8 or %g3, 0x3f8, %g3
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40015078: 88 11 00 1b or %g4, %i3, %g4
4001507c: b9 28 60 18 sll %g1, 0x18, %i4
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
40015080: b6 10 20 04 mov 4, %i3
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40015084: 88 11 00 1c or %g4, %i4, %g4
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
40015088: f6 2e 20 0e stb %i3, [ %i0 + 0xe ]
vol->mask = FAT_FAT32_MASK;
4001508c: fa 26 20 10 st %i5, [ %i0 + 0x10 ]
vol->eoc_val = FAT_FAT32_EOC;
40015090: c6 26 20 14 st %g3, [ %i0 + 0x14 ]
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
40015094: c8 26 20 3c st %g4, [ %i0 + 0x3c ]
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
40015098: 80 88 a0 80 btst 0x80, %g2
4001509c: 02 80 00 6a be 40015244 <fat_init_volume_info+0x734> <== ALWAYS TAKEN
400150a0: c4 2e 20 54 stb %g2, [ %i0 + 0x54 ]
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
400150a4: c2 0f bf 87 ldub [ %fp + -121 ], %g1 <== NOT EXECUTED
400150a8: 84 08 60 0f and %g1, 0xf, %g2 <== NOT EXECUTED
400150ac: c4 2e 20 5c stb %g2, [ %i0 + 0x5c ] <== NOT EXECUTED
else
vol->afat = 0;
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
400150b0: c4 0f bf 91 ldub [ %fp + -111 ], %g2
400150b4: c6 0f bf 92 ldub [ %fp + -110 ], %g3
400150b8: 85 28 a0 08 sll %g2, 8, %g2
400150bc: 84 10 80 03 or %g2, %g3, %g2
400150c0: c4 36 20 40 sth %g2, [ %i0 + 0x40 ]
if( vol->info_sec == 0 )
400150c4: 85 28 a0 10 sll %g2, 0x10, %g2
400150c8: 93 30 a0 10 srl %g2, 0x10, %o1
400150cc: 80 a2 60 00 cmp %o1, 0
400150d0: 02 80 00 4b be 400151fc <fat_init_volume_info+0x6ec> <== NEVER TAKEN
400150d4: 90 10 00 18 mov %i0, %o0
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , 0,
400150d8: 94 10 20 00 clr %o2
400150dc: 96 10 20 04 mov 4, %o3
400150e0: 7f ff fd 7e call 400146d8 <_fat_block_read>
400150e4: 98 07 bf a8 add %fp, -88, %o4
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
400150e8: 80 a2 20 00 cmp %o0, 0
400150ec: 06 80 00 7d bl 400152e0 <fat_init_volume_info+0x7d0> <== NEVER TAKEN
400150f0: c4 0f bf ab ldub [ %fp + -85 ], %g2
{
close(vol->fd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
400150f4: c6 0f bf a9 ldub [ %fp + -87 ], %g3
400150f8: fa 0f bf aa ldub [ %fp + -86 ], %i5
400150fc: c8 0f bf a8 ldub [ %fp + -88 ], %g4
40015100: 85 28 a0 18 sll %g2, 0x18, %g2
40015104: 87 28 e0 08 sll %g3, 8, %g3
40015108: bb 2f 60 10 sll %i5, 0x10, %i5
4001510c: 86 10 c0 1d or %g3, %i5, %g3
40015110: 86 10 c0 04 or %g3, %g4, %g3
40015114: 86 10 c0 02 or %g3, %g2, %g3
40015118: 05 10 58 54 sethi %hi(0x41615000), %g2
4001511c: 84 10 a2 52 or %g2, 0x252, %g2 ! 41615252 <RAM_END+0x1215252>
40015120: 80 a0 c0 02 cmp %g3, %g2
40015124: 12 80 00 34 bne 400151f4 <fat_init_volume_info+0x6e4> <== NEVER TAKEN
40015128: 90 10 00 18 mov %i0, %o0
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
4001512c: d2 16 20 40 lduh [ %i0 + 0x40 ], %o1
40015130: 94 10 21 e4 mov 0x1e4, %o2
40015134: 96 10 20 0c mov 0xc, %o3
40015138: 7f ff fd 68 call 400146d8 <_fat_block_read>
4001513c: 98 07 bf a8 add %fp, -88, %o4
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
40015140: 80 a2 20 00 cmp %o0, 0
40015144: 06 80 00 65 bl 400152d8 <fat_init_volume_info+0x7c8> <== NEVER TAKEN
40015148: c6 0f bf ad ldub [ %fp + -83 ], %g3
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
4001514c: f2 0f bf ae ldub [ %fp + -82 ], %i1
40015150: f4 0f bf ac ldub [ %fp + -84 ], %i2
40015154: f6 0f bf af ldub [ %fp + -81 ], %i3
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
40015158: f8 0f bf b1 ldub [ %fp + -79 ], %i4
4001515c: c4 0f bf b2 ldub [ %fp + -78 ], %g2
40015160: fa 0f bf b0 ldub [ %fp + -80 ], %i5
40015164: c8 0f bf b3 ldub [ %fp + -77 ], %g4
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
40015168: 87 28 e0 08 sll %g3, 8, %g3
4001516c: b3 2e 60 10 sll %i1, 0x10, %i1
40015170: b7 2e e0 18 sll %i3, 0x18, %i3
40015174: 86 10 c0 19 or %g3, %i1, %g3
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
40015178: b9 2f 20 08 sll %i4, 8, %i4
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
4001517c: 86 10 c0 1a or %g3, %i2, %g3
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
40015180: 85 28 a0 10 sll %g2, 0x10, %g2
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
40015184: 86 10 c0 1b or %g3, %i3, %g3
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
40015188: 84 17 00 02 or %i4, %g2, %g2
4001518c: 89 29 20 18 sll %g4, 0x18, %g4
40015190: 84 10 80 1d or %g2, %i5, %g2
_fat_block_release(fs_info);
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
40015194: c6 26 20 48 st %g3, [ %i0 + 0x48 ]
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
40015198: 84 10 80 04 or %g2, %g4, %g2
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->free_cls = vol->free_cls_in_fs_info;
4001519c: c6 26 20 44 st %g3, [ %i0 + 0x44 ]
vol->next_cl_in_fs_info =
400151a0: c4 26 20 50 st %g2, [ %i0 + 0x50 ]
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
vol->next_cl = vol->next_cl_in_fs_info;
400151a4: 10 bf ff 35 b 40014e78 <fat_init_volume_info+0x368>
400151a8: c4 26 20 4c st %g2, [ %i0 + 0x4c ]
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
400151ac: c4 0f bf 94 ldub [ %fp + -108 ], %g2
400151b0: d0 0f bf 95 ldub [ %fp + -107 ], %o0
400151b4: 85 28 a0 10 sll %g2, 0x10, %g2
400151b8: 91 2a 20 08 sll %o0, 8, %o0
400151bc: c2 0f bf 93 ldub [ %fp + -109 ], %g1
400151c0: 90 12 00 02 or %o0, %g2, %o0
400151c4: c4 0f bf 8f ldub [ %fp + -113 ], %g2
400151c8: 90 12 00 01 or %o0, %g1, %o0
400151cc: ad 28 a0 18 sll %g2, 0x18, %l6
400151d0: 90 12 00 16 or %o0, %l6, %o0
400151d4: 10 bf ff 17 b 40014e30 <fat_init_volume_info+0x320>
400151d8: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
400151dc: 88 10 20 02 mov 2, %g4
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
400151e0: 84 10 a3 f8 or %g2, 0x3f8, %g2
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
400151e4: c8 2e 20 0e stb %g4, [ %i0 + 0xe ]
vol->mask = FAT_FAT16_MASK;
400151e8: c6 26 20 10 st %g3, [ %i0 + 0x10 ]
vol->eoc_val = FAT_FAT16_EOC;
400151ec: 10 bf ff 1d b 40014e60 <fat_init_volume_info+0x350>
400151f0: c4 26 20 14 st %g2, [ %i0 + 0x14 ]
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(fat_fs_info_t *fs_info)
{
return fat_buf_release(fs_info);
400151f4: 7f ff fc 94 call 40014444 <fat_buf_release> <== NOT EXECUTED
400151f8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(fs_info);
close(vol->fd);
400151fc: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
40015200: 7f ff c2 c1 call 40005d04 <close> <== NOT EXECUTED
40015204: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40015208: 40 00 20 e2 call 4001d590 <__errno> <== NOT EXECUTED
4001520c: 01 00 00 00 nop <== NOT EXECUTED
40015210: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
40015214: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40015218: 81 c7 e0 08 ret <== NOT EXECUTED
4001521c: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = fstat(vol->fd, &stat_buf);
if (rc != 0)
{
close(vol->fd);
40015220: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
40015224: 7f ff c2 b8 call 40005d04 <close> <== NOT EXECUTED
40015228: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
4001522c: 40 00 20 d9 call 4001d590 <__errno> <== NOT EXECUTED
40015230: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40015234: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED
40015238: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001523c: 81 c7 e0 08 ret <== NOT EXECUTED
40015240: 81 e8 00 00 restore <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
else
vol->afat = 0;
40015244: 10 bf ff 9b b 400150b0 <fat_init_volume_info+0x5a0>
40015248: c0 2e 20 5c clrb [ %i0 + 0x5c ]
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
i >>= 1, vol->sec_log2++);
vol->bytes_per_block = vol->bps;
vol->bytes_per_block_log2 = vol->sec_log2;
vol->sectors_per_block = 1;
4001524c: 10 bf fe a3 b 40014cd8 <fat_init_volume_info+0x1c8> <== NOT EXECUTED
40015250: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
40015254: 10 bf fe b4 b 40014d24 <fat_init_volume_info+0x214>
40015258: 86 10 20 00 clr %g3
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
sc = rtems_bdbuf_release( block);
if (sc != RTEMS_SUCCESSFUL)
{
close(vol->fd);
4001525c: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
40015260: 7f ff c2 a9 call 40005d04 <close> <== NOT EXECUTED
40015264: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
40015268: 40 00 20 ca call 4001d590 <__errno> <== NOT EXECUTED
4001526c: 01 00 00 00 nop <== NOT EXECUTED
40015270: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40015274: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40015278: 81 c7 e0 08 ret <== NOT EXECUTED
4001527c: 81 e8 00 00 restore <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
if ( fs_info->uino == NULL )
{
close(vol->fd);
40015280: 7f ff c2 a1 call 40005d04 <close> <== NOT EXECUTED
40015284: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
40015288: 7f ff c2 c1 call 40005d8c <free> <== NOT EXECUTED
4001528c: d0 06 20 6c ld [ %i0 + 0x6c ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
40015290: d0 06 20 70 ld [ %i0 + 0x70 ], %o0 <== NOT EXECUTED
if (fs_info->sec_buf == NULL)
{
close(vol->fd);
free(fs_info->vhash);
free(fs_info->rhash);
free(fs_info->uino);
40015294: 7f ff c2 be call 40005d8c <free> <== NOT EXECUTED
40015298: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4001529c: 40 00 20 bd call 4001d590 <__errno> <== NOT EXECUTED
400152a0: 01 00 00 00 nop <== NOT EXECUTED
400152a4: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
400152a8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400152ac: 81 c7 e0 08 ret <== NOT EXECUTED
400152b0: 81 e8 00 00 restore <== NOT EXECUTED
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->vhash == NULL )
{
close(vol->fd);
400152b4: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
400152b8: 7f ff c2 93 call 40005d04 <close> <== NOT EXECUTED
400152bc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
400152c0: 40 00 20 b4 call 4001d590 <__errno> <== NOT EXECUTED
400152c4: 01 00 00 00 nop <== NOT EXECUTED
400152c8: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
400152cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400152d0: 81 c7 e0 08 ret <== NOT EXECUTED
400152d4: 81 e8 00 00 restore <== NOT EXECUTED
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(fat_fs_info_t *fs_info)
{
return fat_buf_release(fs_info);
400152d8: 7f ff fc 5b call 40014444 <fat_buf_release> <== NOT EXECUTED
400152dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
{
_fat_block_release(fs_info);
close(vol->fd);
400152e0: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
400152e4: 7f ff c2 88 call 40005d04 <close> <== NOT EXECUTED
400152e8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400152ec: 81 c7 e0 08 ret <== NOT EXECUTED
400152f0: 81 e8 00 00 restore <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
if (fs_info->sec_buf == NULL)
{
close(vol->fd);
400152f4: 7f ff c2 84 call 40005d04 <close> <== NOT EXECUTED
400152f8: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
400152fc: 7f ff c2 a4 call 40005d8c <free> <== NOT EXECUTED
40015300: d0 06 20 6c ld [ %i0 + 0x6c ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
40015304: 7f ff c2 a2 call 40005d8c <free> <== NOT EXECUTED
40015308: d0 06 20 70 ld [ %i0 + 0x70 ], %o0 <== NOT EXECUTED
free(fs_info->uino);
4001530c: 10 bf ff e2 b 40015294 <fat_init_volume_info+0x784> <== NOT EXECUTED
40015310: d0 06 20 74 ld [ %i0 + 0x74 ], %o0 <== NOT EXECUTED
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->rhash == NULL )
{
close(vol->fd);
40015314: 7f ff c2 7c call 40005d04 <close> <== NOT EXECUTED
40015318: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
4001531c: 10 bf ff de b 40015294 <fat_init_volume_info+0x784> <== NOT EXECUTED
40015320: d0 06 20 6c ld [ %i0 + 0x6c ], %o0 <== NOT EXECUTED
4001b8f4 <fat_scan_fat_for_free_clusters>:
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
4001b8f4: 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;
4001b8f8: e6 06 20 38 ld [ %i0 + 0x38 ], %l3
bool zero_fill
)
{
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
4001b8fc: 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;
4001b900: c0 26 c0 00 clr [ %i3 ]
if (count == 0)
4001b904: 80 a6 a0 00 cmp %i2, 0
4001b908: 02 80 00 49 be 4001ba2c <fat_scan_fat_for_free_clusters+0x138><== NEVER TAKEN
4001b90c: a4 10 20 00 clr %l2
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
4001b910: e0 06 20 4c ld [ %i0 + 0x4c ], %l0
4001b914: 80 a4 3f ff cmp %l0, -1
4001b918: 22 80 00 02 be,a 4001b920 <fat_scan_fat_for_free_clusters+0x2c>
4001b91c: 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;
4001b920: a6 04 e0 02 add %l3, 2, %l3
/*
* fs_info->vol.data_cls is exactly the count of data clusters
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
4001b924: 80 a4 e0 02 cmp %l3, 2
4001b928: 08 80 00 4e bleu 4001ba60 <fat_scan_fat_for_free_clusters+0x16c><== NEVER TAKEN
4001b92c: a2 10 20 02 mov 2, %l1
4001b930: 10 80 00 1a b 4001b998 <fat_scan_fat_for_free_clusters+0xa4>
4001b934: a8 10 20 00 clr %l4
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
4001b938: 90 10 00 18 mov %i0, %o0
4001b93c: 92 10 00 10 mov %l0, %o1
4001b940: 7f ff ff 03 call 4001b54c <fat_set_fat_cluster>
4001b944: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
4001b948: 80 a2 20 00 cmp %o0, 0
4001b94c: 32 80 00 38 bne,a 4001ba2c <fat_scan_fat_for_free_clusters+0x138><== NEVER TAKEN
4001b950: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
if ( rc != RC_OK )
goto cleanup;
}
if (zero_fill)
4001b954: 80 a7 60 00 cmp %i5, 0
4001b958: 32 80 00 37 bne,a 4001ba34 <fat_scan_fat_for_free_clusters+0x140>
4001b95c: d6 16 20 06 lduh [ %i0 + 6 ], %o3
goto cleanup;
}
}
save_cln = cl4find;
(*cls_added)++;
4001b960: c2 06 c0 00 ld [ %i3 ], %g1
4001b964: 82 00 60 01 inc %g1
/* have we satisfied request ? */
if (*cls_added == count)
4001b968: 80 a6 80 01 cmp %i2, %g1
4001b96c: 02 80 00 53 be 4001bab8 <fat_scan_fat_for_free_clusters+0x1c4>
4001b970: c2 26 c0 00 st %g1, [ %i3 ]
4001b974: a8 10 00 10 mov %l0, %l4
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
4001b978: a0 04 20 01 inc %l0
if (cl4find >= data_cls_val)
4001b97c: 80 a4 c0 10 cmp %l3, %l0
4001b980: 18 80 00 03 bgu 4001b98c <fat_scan_fat_for_free_clusters+0x98><== ALWAYS TAKEN
4001b984: a2 04 60 01 inc %l1
cl4find = 2;
4001b988: 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)
4001b98c: 80 a4 c0 11 cmp %l3, %l1
4001b990: 22 80 00 36 be,a 4001ba68 <fat_scan_fat_for_free_clusters+0x174><== NEVER TAKEN
4001b994: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
{
rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
4001b998: 90 10 00 18 mov %i0, %o0
4001b99c: 92 10 00 10 mov %l0, %o1
4001b9a0: 7f ff fe 67 call 4001b33c <fat_get_fat_cluster>
4001b9a4: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
4001b9a8: a4 92 20 00 orcc %o0, 0, %l2
4001b9ac: 12 80 00 3b bne 4001ba98 <fat_scan_fat_for_free_clusters+0x1a4><== NEVER TAKEN
4001b9b0: c2 07 bf fc ld [ %fp + -4 ], %g1
if (*cls_added != 0)
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
4001b9b4: 80 a0 60 00 cmp %g1, 0
4001b9b8: 32 bf ff f1 bne,a 4001b97c <fat_scan_fat_for_free_clusters+0x88>
4001b9bc: 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)
4001b9c0: c2 06 c0 00 ld [ %i3 ], %g1
4001b9c4: 80 a0 60 00 cmp %g1, 0
4001b9c8: 22 bf ff dc be,a 4001b938 <fat_scan_fat_for_free_clusters+0x44>
4001b9cc: e0 26 40 00 st %l0, [ %i1 ]
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
4001b9d0: 90 10 00 18 mov %i0, %o0
4001b9d4: 92 10 00 10 mov %l0, %o1
4001b9d8: 7f ff fe dd call 4001b54c <fat_set_fat_cluster>
4001b9dc: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
4001b9e0: 82 92 20 00 orcc %o0, 0, %g1
4001b9e4: 12 80 00 40 bne 4001bae4 <fat_scan_fat_for_free_clusters+0x1f0><== NEVER TAKEN
4001b9e8: 92 10 00 14 mov %l4, %o1
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
}
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
4001b9ec: 90 10 00 18 mov %i0, %o0
4001b9f0: 7f ff fe d7 call 4001b54c <fat_set_fat_cluster>
4001b9f4: 94 10 00 10 mov %l0, %o2
if ( rc != RC_OK )
4001b9f8: a8 92 20 00 orcc %o0, 0, %l4
4001b9fc: 02 bf ff d7 be 4001b958 <fat_scan_fat_for_free_clusters+0x64><== ALWAYS TAKEN
4001ba00: 80 a7 60 00 cmp %i5, 0
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
4001ba04: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001ba08: 7f ff ff 83 call 4001b814 <fat_free_fat_clusters_chain> <== NOT EXECUTED
4001ba0c: 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);
4001ba10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ba14: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001ba18: 7f ff fe cd call 4001b54c <fat_set_fat_cluster> <== NOT EXECUTED
4001ba1c: 94 10 20 00 clr %o2 <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
4001ba20: a4 10 00 14 mov %l4, %l2 <== NOT EXECUTED
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
4001ba24: 7f ff e2 88 call 40014444 <fat_buf_release> <== NOT EXECUTED
4001ba28: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
}
4001ba2c: 81 c7 e0 08 ret
4001ba30: 91 e8 00 12 restore %g0, %l2, %o0
goto cleanup;
}
if (zero_fill)
{
bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
4001ba34: 90 10 00 18 mov %i0, %o0
4001ba38: 92 10 00 10 mov %l0, %o1
4001ba3c: 94 10 20 00 clr %o2
4001ba40: 7f ff e3 72 call 40014808 <fat_cluster_set>
4001ba44: 98 10 20 00 clr %o4
if (fs_info->vol.bpc != bytes_written)
4001ba48: c2 16 20 06 lduh [ %i0 + 6 ], %g1
4001ba4c: 80 a0 40 08 cmp %g1, %o0
4001ba50: 22 bf ff c5 be,a 4001b964 <fat_scan_fat_for_free_clusters+0x70><== ALWAYS TAKEN
4001ba54: c2 06 c0 00 ld [ %i3 ], %g1
{
rc = -1;
4001ba58: 10 bf ff eb b 4001ba04 <fat_scan_fat_for_free_clusters+0x110><== NOT EXECUTED
4001ba5c: a8 10 3f ff mov -1, %l4 <== NOT EXECUTED
/*
* fs_info->vol.data_cls is exactly the count of data clusters
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
4001ba60: a8 10 20 00 clr %l4 <== NOT EXECUTED
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
4001ba64: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
4001ba68: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
4001ba6c: 02 80 00 05 be 4001ba80 <fat_scan_fat_for_free_clusters+0x18c><== NOT EXECUTED
4001ba70: e8 26 20 4c st %l4, [ %i0 + 0x4c ] <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
4001ba74: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
4001ba78: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
4001ba7c: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*last_cl = save_cln;
4001ba80: e8 27 00 00 st %l4, [ %i4 ] <== NOT EXECUTED
fat_buf_release(fs_info);
4001ba84: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ba88: 7f ff e2 6f call 40014444 <fat_buf_release> <== NOT EXECUTED
4001ba8c: a4 10 20 00 clr %l2 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
4001ba90: 81 c7 e0 08 ret <== NOT EXECUTED
4001ba94: 91 e8 00 12 restore %g0, %l2, %o0 <== NOT EXECUTED
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
if ( rc != RC_OK )
{
if (*cls_added != 0)
4001ba98: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
4001ba9c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001baa0: 02 bf ff e3 be 4001ba2c <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
4001baa4: 01 00 00 00 nop <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
4001baa8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001baac: 7f ff ff 5a call 4001b814 <fat_free_fat_clusters_chain> <== NOT EXECUTED
4001bab0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001bab4: 30 bf ff de b,a 4001ba2c <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
4001bab8: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
4001babc: 80 a0 7f ff cmp %g1, -1
4001bac0: 02 80 00 05 be 4001bad4 <fat_scan_fat_for_free_clusters+0x1e0><== ALWAYS TAKEN
4001bac4: e0 26 20 4c st %l0, [ %i0 + 0x4c ]
fs_info->vol.free_cls -= (*cls_added);
4001bac8: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
4001bacc: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
4001bad0: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
*last_cl = save_cln;
4001bad4: e0 27 00 00 st %l0, [ %i4 ]
fat_buf_release(fs_info);
4001bad8: 7f ff e2 5b call 40014444 <fat_buf_release>
4001badc: 90 10 00 18 mov %i0, %o0
4001bae0: 30 bf ff d3 b,a 4001ba2c <fat_scan_fat_for_free_clusters+0x138>
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
4001bae4: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001bae8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001baec: 7f ff ff 4a call 4001b814 <fat_free_fat_clusters_chain> <== NOT EXECUTED
4001baf0: a4 10 00 01 mov %g1, %l2 <== NOT EXECUTED
4001baf4: 30 bf ff ce b,a 4001ba2c <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
40014758 <fat_sector_write>:
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
40014758: 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)
4001475c: 80 a6 e0 00 cmp %i3, 0
40014760: 02 80 00 28 be 40014800 <fat_sector_write+0xa8> <== NEVER TAKEN
40014764: a0 10 20 00 clr %l0
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
40014768: 10 80 00 12 b 400147b0 <fat_sector_write+0x58>
4001476c: a2 10 20 01 mov 1, %l1
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bytes_per_block)
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
40014770: 96 07 bf fc add %fp, -4, %o3
40014774: 7f ff ff ab call 40014620 <fat_buf_access>
40014778: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
4001477c: 92 07 00 10 add %i4, %l0, %o1
if (c == fs_info->vol.bytes_per_block)
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
40014780: 80 a2 20 00 cmp %o0, 0
40014784: 12 80 00 1e bne 400147fc <fat_sector_write+0xa4> <== NEVER TAKEN
40014788: 94 10 00 1d mov %i5, %o2
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
4001478c: d0 07 bf fc ld [ %fp + -4 ], %o0
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
40014790: a0 07 40 10 add %i5, %l0, %l0
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
40014794: 40 00 26 24 call 4001e024 <memcpy>
40014798: 90 02 00 1a add %o0, %i2, %o0
4001479c: e2 2e 20 88 stb %l1, [ %i0 + 0x88 ]
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
sec_num++;
400147a0: b2 06 60 01 inc %i1
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
400147a4: b6 a6 c0 1d subcc %i3, %i5, %i3
400147a8: 02 80 00 16 be 40014800 <fat_sector_write+0xa8> <== ALWAYS TAKEN
400147ac: b4 10 20 00 clr %i2
{
c = MIN(count, (fs_info->vol.bps - ofs));
400147b0: fa 16 00 00 lduh [ %i0 ], %i5
400147b4: ba 27 40 1a sub %i5, %i2, %i5
400147b8: 80 a7 40 1b cmp %i5, %i3
400147bc: 08 80 00 03 bleu 400147c8 <fat_sector_write+0x70>
400147c0: 92 10 00 19 mov %i1, %o1
400147c4: ba 10 00 1b mov %i3, %i5
if (c == fs_info->vol.bytes_per_block)
400147c8: c2 16 20 0a lduh [ %i0 + 0xa ], %g1
400147cc: 80 a0 40 1d cmp %g1, %i5
400147d0: 12 bf ff e8 bne 40014770 <fat_sector_write+0x18> <== ALWAYS TAKEN
400147d4: 94 10 20 01 mov 1, %o2
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
400147d8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400147dc: 94 10 20 02 mov 2, %o2 <== NOT EXECUTED
400147e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400147e4: 7f ff ff 8f call 40014620 <fat_buf_access> <== NOT EXECUTED
400147e8: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
400147ec: 92 07 00 10 add %i4, %l0, %o1 <== NOT EXECUTED
if (c == fs_info->vol.bytes_per_block)
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
400147f0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400147f4: 02 bf ff e6 be 4001478c <fat_sector_write+0x34> <== NOT EXECUTED
400147f8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
return -1;
400147fc: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
cmpltd +=c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
40014800: 81 c7 e0 08 ret
40014804: 91 e8 00 10 restore %g0, %l0, %o0
4001b54c <fat_set_fat_cluster>:
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
4001b54c: 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;
4001b550: c0 27 bf fc clr [ %fp + -4 ]
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
4001b554: 80 a6 60 01 cmp %i1, 1
4001b558: 08 80 00 26 bleu 4001b5f0 <fat_set_fat_cluster+0xa4> <== NEVER TAKEN
4001b55c: ba 10 00 18 mov %i0, %i5
4001b560: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
4001b564: 82 00 60 01 inc %g1
4001b568: 80 a6 40 01 cmp %i1, %g1
4001b56c: 18 80 00 21 bgu 4001b5f0 <fat_set_fat_cluster+0xa4> <== NEVER TAKEN
4001b570: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4001b574: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
4001b578: 80 88 60 01 btst 1, %g1
4001b57c: 12 80 00 23 bne 4001b608 <fat_set_fat_cluster+0xbc>
4001b580: e0 0e 20 02 ldub [ %i0 + 2 ], %l0
4001b584: 82 08 60 02 and %g1, 2, %g1
4001b588: 80 88 60 ff btst 0xff, %g1
4001b58c: 02 80 00 25 be 4001b620 <fat_set_fat_cluster+0xd4>
4001b590: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4001b594: b9 2e 60 01 sll %i1, 1, %i4
4001b598: a1 37 00 10 srl %i4, %l0, %l0
4001b59c: a0 04 00 01 add %l0, %g1, %l0
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4001b5a0: e2 17 40 00 lduh [ %i5 ], %l1
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
4001b5a4: 90 10 00 1d mov %i5, %o0
4001b5a8: 92 10 00 10 mov %l0, %o1
4001b5ac: 94 10 20 01 mov 1, %o2
4001b5b0: 7f ff e4 1c call 40014620 <fat_buf_access>
4001b5b4: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
4001b5b8: b0 92 20 00 orcc %o0, 0, %i0
4001b5bc: 12 80 00 11 bne 4001b600 <fat_set_fat_cluster+0xb4> <== NEVER TAKEN
4001b5c0: a3 2c 60 10 sll %l1, 0x10, %l1
return rc;
switch ( fs_info->vol.type )
4001b5c4: f6 0f 60 0e ldub [ %i5 + 0xe ], %i3
4001b5c8: 80 a6 e0 02 cmp %i3, 2
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
4001b5cc: a3 34 60 10 srl %l1, 0x10, %l1
4001b5d0: a2 04 7f ff add %l1, -1, %l1
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
4001b5d4: 02 80 00 17 be 4001b630 <fat_set_fat_cluster+0xe4>
4001b5d8: b8 0f 00 11 and %i4, %l1, %i4
4001b5dc: 80 a6 e0 04 cmp %i3, 4
4001b5e0: 02 80 00 3b be 4001b6cc <fat_set_fat_cluster+0x180>
4001b5e4: 80 a6 e0 01 cmp %i3, 1
4001b5e8: 02 80 00 1f be 4001b664 <fat_set_fat_cluster+0x118> <== ALWAYS TAKEN
4001b5ec: 80 8e 60 01 btst 1, %i1
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
4001b5f0: 40 00 07 e8 call 4001d590 <__errno> <== NOT EXECUTED
4001b5f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001b5f8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001b5fc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
break;
}
return RC_OK;
}
4001b600: 81 c7 e0 08 ret <== NOT EXECUTED
4001b604: 81 e8 00 00 restore <== NOT EXECUTED
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
4001b608: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4001b60c: b9 36 60 01 srl %i1, 1, %i4
4001b610: b8 07 00 19 add %i4, %i1, %i4
4001b614: a1 37 00 10 srl %i4, %l0, %l0
4001b618: 10 bf ff e2 b 4001b5a0 <fat_set_fat_cluster+0x54>
4001b61c: a0 04 00 01 add %l0, %g1, %l0
4001b620: b9 2e 60 02 sll %i1, 2, %i4
4001b624: a1 37 00 10 srl %i4, %l0, %l0
4001b628: 10 bf ff de b 4001b5a0 <fat_set_fat_cluster+0x54>
4001b62c: a0 04 00 01 add %l0, %g1, %l0
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
(uint16_t )(CT_LE_W(in_val));
4001b630: 83 2e a0 10 sll %i2, 0x10, %g1
4001b634: 83 30 60 18 srl %g1, 0x18, %g1
break;
}
return RC_OK;
}
4001b638: 05 00 00 3f sethi %hi(0xfc00), %g2
4001b63c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <PROM_START+0xffff>
4001b640: b4 0e 80 02 and %i2, %g2, %i2
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
(uint16_t )(CT_LE_W(in_val));
4001b644: b5 2e a0 08 sll %i2, 8, %i2
4001b648: b4 16 80 01 or %i2, %g1, %i2
}
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
4001b64c: c2 07 bf fc ld [ %fp + -4 ], %g1
4001b650: f4 30 40 1c sth %i2, [ %g1 + %i4 ]
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
4001b654: 82 10 20 01 mov 1, %g1
4001b658: c2 2f 60 88 stb %g1, [ %i5 + 0x88 ]
4001b65c: 81 c7 e0 08 ret
4001b660: 81 e8 00 00 restore
return rc;
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
4001b664: 02 80 00 30 be 4001b724 <fat_set_fat_cluster+0x1d8>
4001b668: c2 07 bf fc ld [ %fp + -4 ], %g1
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*(sec_buf + ofs) &= 0x0F;
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
4001b66c: 85 2e a0 04 sll %i2, 4, %g2
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*(sec_buf + ofs) &= 0x0F;
4001b670: c6 08 40 1c ldub [ %g1 + %i4 ], %g3
4001b674: 86 08 e0 0f and %g3, 0xf, %g3
4001b678: c6 28 40 1c stb %g3, [ %g1 + %i4 ]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
4001b67c: c2 07 bf fc ld [ %fp + -4 ], %g1
4001b680: c6 08 40 1c ldub [ %g1 + %i4 ], %g3
4001b684: 84 10 c0 02 or %g3, %g2, %g2
4001b688: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
4001b68c: c2 17 40 00 lduh [ %i5 ], %g1
4001b690: 82 00 7f ff add %g1, -1, %g1
4001b694: 80 a0 40 1c cmp %g1, %i4
4001b698: 02 80 00 3a be 4001b780 <fat_set_fat_cluster+0x234> <== NEVER TAKEN
4001b69c: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ]
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0x00;
4001b6a0: c2 07 bf fc ld [ %fp + -4 ], %g1
4001b6a4: b8 07 20 01 inc %i4
4001b6a8: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
4001b6ac: c2 07 bf fc ld [ %fp + -4 ], %g1
4001b6b0: b5 2e a0 14 sll %i2, 0x14, %i2
4001b6b4: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
4001b6b8: b5 36 a0 18 srl %i2, 0x18, %i2
4001b6bc: 84 10 80 1a or %g2, %i2, %g2
4001b6c0: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
4001b6c4: 81 c7 e0 08 ret
4001b6c8: 81 e8 00 00 restore
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
4001b6cc: c4 07 bf fc ld [ %fp + -4 ], %g2
(uint16_t )(CT_LE_W(in_val));
fat_buf_mark_modified(fs_info);
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
4001b6d0: 03 3c 00 00 sethi %hi(0xf0000000), %g1
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
4001b6d4: c6 00 80 1c ld [ %g2 + %i4 ], %g3
(uint16_t )(CT_LE_W(in_val));
fat_buf_mark_modified(fs_info);
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
4001b6d8: 82 2e 80 01 andn %i2, %g1, %g1
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
4001b6dc: 89 30 60 18 srl %g1, 0x18, %g4
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
4001b6e0: b7 30 60 08 srl %g1, 8, %i3
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
4001b6e4: 86 08 e0 f0 and %g3, 0xf0, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001b6e8: b5 2e a0 18 sll %i2, 0x18, %i2
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
4001b6ec: b6 0e e0 ff and %i3, 0xff, %i3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001b6f0: b4 16 80 04 or %i2, %g4, %i2
4001b6f4: b7 2e e0 10 sll %i3, 0x10, %i3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
4001b6f8: 89 30 60 10 srl %g1, 0x10, %g4
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001b6fc: 82 16 80 1b or %i2, %i3, %g1
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
4001b700: 88 09 20 ff and %g4, 0xff, %g4
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001b704: 89 29 20 08 sll %g4, 8, %g4
4001b708: 82 10 40 04 or %g1, %g4, %g1
*((uint32_t *)(sec_buf + ofs)) |= fat32_clv;
4001b70c: 82 10 40 03 or %g1, %g3, %g1
4001b710: c2 20 80 1c st %g1, [ %g2 + %i4 ]
4001b714: 82 10 20 01 mov 1, %g1
4001b718: c2 2f 60 88 stb %g1, [ %i5 + 0x88 ]
4001b71c: 81 c7 e0 08 ret
4001b720: 81 e8 00 00 restore
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
4001b724: b4 0e af ff and %i2, 0xfff, %i2
*(sec_buf + ofs) &= 0x00;
4001b728: c0 28 40 1c clrb [ %g1 + %i4 ]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
4001b72c: c2 07 bf fc ld [ %fp + -4 ], %g1
4001b730: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
4001b734: 84 10 80 1a or %g2, %i2, %g2
4001b738: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
4001b73c: c2 17 40 00 lduh [ %i5 ], %g1
4001b740: 82 00 7f ff add %g1, -1, %g1
4001b744: 80 a0 40 1c cmp %g1, %i4
4001b748: 02 80 00 20 be 4001b7c8 <fat_set_fat_cluster+0x27c> <== NEVER TAKEN
4001b74c: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ]
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
4001b750: c2 07 bf fc ld [ %fp + -4 ], %g1
4001b754: b8 07 20 01 inc %i4
4001b758: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001b75c: b5 36 a0 08 srl %i2, 8, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
4001b760: 84 08 bf f0 and %g2, -16, %g2
4001b764: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001b768: c2 07 bf fc ld [ %fp + -4 ], %g1
4001b76c: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
4001b770: b4 10 80 1a or %g2, %i2, %i2
4001b774: f4 28 40 1c stb %i2, [ %g1 + %i4 ]
4001b778: 81 c7 e0 08 ret
4001b77c: 81 e8 00 00 restore
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
4001b780: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b784: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
4001b788: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001b78c: 7f ff e3 a5 call 40014620 <fat_buf_access> <== NOT EXECUTED
4001b790: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
4001b794: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001b798: 12 bf ff 9a bne 4001b600 <fat_set_fat_cluster+0xb4> <== NOT EXECUTED
4001b79c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*sec_buf &= 0x00;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001b7a0: 87 2e a0 14 sll %i2, 0x14, %g3 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&sec_buf);
if (rc != RC_OK)
return rc;
*sec_buf &= 0x00;
4001b7a4: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001b7a8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
4001b7ac: 87 30 e0 18 srl %g3, 0x18, %g3 <== NOT EXECUTED
4001b7b0: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
4001b7b4: 84 10 c0 02 or %g3, %g2, %g2 <== NOT EXECUTED
4001b7b8: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
4001b7bc: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ] <== NOT EXECUTED
4001b7c0: 81 c7 e0 08 ret <== NOT EXECUTED
4001b7c4: 81 e8 00 00 restore <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
4001b7c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001b7cc: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
4001b7d0: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001b7d4: 7f ff e3 93 call 40014620 <fat_buf_access> <== NOT EXECUTED
4001b7d8: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
4001b7dc: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001b7e0: 12 bf ff 88 bne 4001b600 <fat_set_fat_cluster+0xb4> <== NOT EXECUTED
4001b7e4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*sec_buf &= 0xF0;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001b7e8: 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;
4001b7ec: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
4001b7f0: 84 08 bf f0 and %g2, -16, %g2 <== NOT EXECUTED
4001b7f4: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001b7f8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
4001b7fc: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
4001b800: 84 16 80 02 or %i2, %g2, %g2 <== NOT EXECUTED
4001b804: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
4001b808: f6 2f 60 88 stb %i3, [ %i5 + 0x88 ] <== NOT EXECUTED
4001b80c: 81 c7 e0 08 ret <== NOT EXECUTED
4001b810: 81 e8 00 00 restore <== NOT EXECUTED
4001544c <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)
{
4001544c: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
int i = 0;
rc = fat_sync(fs_info);
40015450: 90 10 00 18 mov %i0, %o0
40015454: 7f ff ff b4 call 40015324 <fat_sync>
40015458: b8 10 00 18 mov %i0, %i4
if ( rc != RC_OK )
4001545c: b0 92 20 00 orcc %o0, 0, %i0
40015460: 32 80 00 35 bne,a 40015534 <fat_shutdown_drive+0xe8> <== NEVER TAKEN
40015464: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
40015468: b6 10 20 00 clr %i3
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
4001546c: fa 07 20 6c ld [ %i4 + 0x6c ], %i5
while ( (node = rtems_chain_get(the_chain)) != NULL )
40015470: 10 80 00 04 b 40015480 <fat_shutdown_drive+0x34>
40015474: ba 07 40 1b add %i5, %i3, %i5
free(node);
40015478: 7f ff c2 45 call 40005d8c <free>
4001547c: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
40015480: 7f ff d7 3a call 4000b168 <_Chain_Get>
40015484: 90 10 00 1d mov %i5, %o0
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
40015488: 80 a2 20 00 cmp %o0, 0
4001548c: 12 bf ff fb bne 40015478 <fat_shutdown_drive+0x2c>
40015490: 01 00 00 00 nop
40015494: b6 06 e0 0c add %i3, 0xc, %i3
rc = fat_sync(fs_info);
if ( rc != RC_OK )
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
40015498: 80 a6 e0 18 cmp %i3, 0x18
4001549c: 32 bf ff f5 bne,a 40015470 <fat_shutdown_drive+0x24>
400154a0: fa 07 20 6c ld [ %i4 + 0x6c ], %i5
400154a4: b6 10 20 00 clr %i3
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
400154a8: fa 07 20 70 ld [ %i4 + 0x70 ], %i5
while ( (node = rtems_chain_get(the_chain)) != NULL )
400154ac: 10 80 00 04 b 400154bc <fat_shutdown_drive+0x70>
400154b0: ba 07 40 1b add %i5, %i3, %i5
free(node);
400154b4: 7f ff c2 36 call 40005d8c <free> <== NOT EXECUTED
400154b8: 01 00 00 00 nop <== NOT EXECUTED
400154bc: 7f ff d7 2b call 4000b168 <_Chain_Get>
400154c0: 90 10 00 1d mov %i5, %o0
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
400154c4: 80 a2 20 00 cmp %o0, 0
400154c8: 12 bf ff fb bne 400154b4 <fat_shutdown_drive+0x68> <== NEVER TAKEN
400154cc: 01 00 00 00 nop
400154d0: b6 06 e0 0c add %i3, 0xc, %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
400154d4: 80 a6 e0 18 cmp %i3, 0x18
400154d8: 32 bf ff f5 bne,a 400154ac <fat_shutdown_drive+0x60>
400154dc: fa 07 20 70 ld [ %i4 + 0x70 ], %i5
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
400154e0: 7f ff c2 2b call 40005d8c <free>
400154e4: d0 07 20 6c ld [ %i4 + 0x6c ], %o0
free(fs_info->rhash);
400154e8: 7f ff c2 29 call 40005d8c <free>
400154ec: d0 07 20 70 ld [ %i4 + 0x70 ], %o0
free(fs_info->uino);
400154f0: 7f ff c2 27 call 40005d8c <free>
400154f4: d0 07 20 74 ld [ %i4 + 0x74 ], %o0
free(fs_info->sec_buf);
400154f8: 7f ff c2 25 call 40005d8c <free>
400154fc: d0 07 20 90 ld [ %i4 + 0x90 ], %o0
close(fs_info->vol.fd);
40015500: 7f ff c2 01 call 40005d04 <close>
40015504: d0 07 20 60 ld [ %i4 + 0x60 ], %o0
if (rc)
40015508: 80 a6 20 00 cmp %i0, 0
4001550c: 12 80 00 04 bne 4001551c <fat_shutdown_drive+0xd0> <== NEVER TAKEN
40015510: 01 00 00 00 nop
errno = EIO;
return rc;
}
40015514: 81 c7 e0 08 ret
40015518: 81 e8 00 00 restore
free(fs_info->uino);
free(fs_info->sec_buf);
close(fs_info->vol.fd);
if (rc)
errno = EIO;
4001551c: 40 00 20 1d call 4001d590 <__errno> <== NOT EXECUTED
40015520: 01 00 00 00 nop <== NOT EXECUTED
40015524: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40015528: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return rc;
}
4001552c: 81 c7 e0 08 ret <== NOT EXECUTED
40015530: 81 e8 00 00 restore <== NOT EXECUTED
int rc = RC_OK;
int i = 0;
rc = fat_sync(fs_info);
if ( rc != RC_OK )
rc = -1;
40015534: 10 bf ff ce b 4001546c <fat_shutdown_drive+0x20> <== NOT EXECUTED
40015538: b6 10 20 00 clr %i3 <== NOT EXECUTED
40015324 <fat_sync>:
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
40015324: 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)
40015328: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1
4001532c: 80 a0 60 04 cmp %g1, 4
40015330: 02 80 00 0c be 40015360 <fat_sync+0x3c>
40015334: ba 10 00 18 mov %i0, %i5
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
sizeof(le_free_count),
&le_free_count);
}
if (next_free != fs_info->vol.next_cl_in_fs_info)
40015338: b0 10 20 00 clr %i0
rc = fat_fat32_update_fsinfo_sector(fs_info);
if ( rc != RC_OK )
rc = -1;
fat_buf_release(fs_info);
4001533c: 7f ff fc 42 call 40014444 <fat_buf_release>
40015340: 90 10 00 1d mov %i5, %o0
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
40015344: 7f ff f5 05 call 40012758 <rtems_bdbuf_syncdev>
40015348: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
4001534c: 80 a2 20 00 cmp %o0, 0
40015350: 12 80 00 3d bne 40015444 <fat_sync+0x120> <== NEVER TAKEN
40015354: 01 00 00 00 nop
rc = -1;
return rc;
}
40015358: 81 c7 e0 08 ret
4001535c: 81 e8 00 00 restore
{
ssize_t ret1 = 0, ret2 = 0;
if (fs_info->vol.type == FAT_FAT32)
{
uint32_t free_count = fs_info->vol.free_cls;
40015360: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
uint32_t next_free = fs_info->vol.next_cl;
if (free_count != fs_info->vol.free_cls_in_fs_info)
40015364: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
ssize_t ret1 = 0, ret2 = 0;
if (fs_info->vol.type == FAT_FAT32)
{
uint32_t free_count = fs_info->vol.free_cls;
uint32_t next_free = fs_info->vol.next_cl;
40015368: f8 06 20 4c ld [ %i0 + 0x4c ], %i4
if (free_count != fs_info->vol.free_cls_in_fs_info)
4001536c: 80 a0 40 02 cmp %g1, %g2
40015370: 02 80 00 16 be 400153c8 <fat_sync+0xa4> <== ALWAYS TAKEN
40015374: b6 10 20 00 clr %i3
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
40015378: 85 30 60 18 srl %g1, 0x18, %g2 <== NOT EXECUTED
{
uint32_t le_free_count = CT_LE_L(free_count);
fs_info->vol.free_cls_in_fs_info = free_count;
ret1 = fat_sector_write(fs_info,
4001537c: d2 16 20 40 lduh [ %i0 + 0x40 ], %o1 <== NOT EXECUTED
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40015380: 87 28 60 18 sll %g1, 0x18, %g3 <== NOT EXECUTED
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
40015384: 89 30 60 08 srl %g1, 8, %g4 <== NOT EXECUTED
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40015388: 86 10 c0 02 or %g3, %g2, %g3 <== NOT EXECUTED
if (free_count != fs_info->vol.free_cls_in_fs_info)
{
uint32_t le_free_count = CT_LE_L(free_count);
fs_info->vol.free_cls_in_fs_info = free_count;
4001538c: c2 26 20 48 st %g1, [ %i0 + 0x48 ] <== NOT EXECUTED
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
40015390: 85 30 60 10 srl %g1, 0x10, %g2 <== NOT EXECUTED
byte2 = (value >> 8) & 0xff;
40015394: 88 09 20 ff and %g4, 0xff, %g4 <== NOT EXECUTED
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
40015398: 84 08 a0 ff and %g2, 0xff, %g2 <== NOT EXECUTED
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001539c: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
400153a0: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
400153a4: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
400153a8: 82 10 c0 02 or %g3, %g2, %g1 <== NOT EXECUTED
ret1 = fat_sector_write(fs_info,
400153ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
uint32_t free_count = fs_info->vol.free_cls;
uint32_t next_free = fs_info->vol.next_cl;
if (free_count != fs_info->vol.free_cls_in_fs_info)
{
uint32_t le_free_count = CT_LE_L(free_count);
400153b0: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fs_info->vol.free_cls_in_fs_info = free_count;
ret1 = fat_sector_write(fs_info,
400153b4: 94 10 21 e8 mov 0x1e8, %o2 <== NOT EXECUTED
400153b8: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
400153bc: 7f ff fc e7 call 40014758 <fat_sector_write> <== NOT EXECUTED
400153c0: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
400153c4: b7 32 20 1f srl %o0, 0x1f, %i3 <== NOT EXECUTED
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
sizeof(le_free_count),
&le_free_count);
}
if (next_free != fs_info->vol.next_cl_in_fs_info)
400153c8: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
400153cc: 80 a7 00 02 cmp %i4, %g2
400153d0: 02 80 00 16 be 40015428 <fat_sync+0x104> <== NEVER TAKEN
400153d4: 90 10 20 00 clr %o0
400153d8: 85 2f 20 18 sll %i4, 0x18, %g2
{
uint32_t le_next_free = CT_LE_L(next_free);
fs_info->vol.next_cl_in_fs_info = next_free;
ret2 = fat_sector_write(fs_info,
400153dc: d2 17 60 40 lduh [ %i5 + 0x40 ], %o1
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
400153e0: 83 37 20 18 srl %i4, 0x18, %g1
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
400153e4: 87 37 20 08 srl %i4, 8, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400153e8: 82 10 80 01 or %g2, %g1, %g1
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
400153ec: 86 08 e0 ff and %g3, 0xff, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
400153f0: 85 37 20 10 srl %i4, 0x10, %g2
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400153f4: 87 28 e0 10 sll %g3, 0x10, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
400153f8: 84 08 a0 ff and %g2, 0xff, %g2
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
400153fc: 82 10 40 03 or %g1, %g3, %g1
40015400: 85 28 a0 08 sll %g2, 8, %g2
40015404: 82 10 40 02 or %g1, %g2, %g1
if (next_free != fs_info->vol.next_cl_in_fs_info)
{
uint32_t le_next_free = CT_LE_L(next_free);
fs_info->vol.next_cl_in_fs_info = next_free;
40015408: f8 27 60 50 st %i4, [ %i5 + 0x50 ]
ret2 = fat_sector_write(fs_info,
4001540c: 90 10 00 1d mov %i5, %o0
&le_free_count);
}
if (next_free != fs_info->vol.next_cl_in_fs_info)
{
uint32_t le_next_free = CT_LE_L(next_free);
40015410: c2 27 bf fc st %g1, [ %fp + -4 ]
fs_info->vol.next_cl_in_fs_info = next_free;
ret2 = fat_sector_write(fs_info,
40015414: 94 10 21 ec mov 0x1ec, %o2
40015418: 96 10 20 04 mov 4, %o3
4001541c: 7f ff fc cf call 40014758 <fat_sector_write>
40015420: 98 07 bf fc add %fp, -4, %o4
40015424: 91 32 20 1f srl %o0, 0x1f, %o0
sizeof(le_next_free),
&le_next_free);
}
}
if ( (ret1 < 0) || (ret2 < 0) )
40015428: 80 8a 20 ff btst 0xff, %o0
4001542c: 12 80 00 04 bne 4001543c <fat_sync+0x118> <== NEVER TAKEN
40015430: 80 8e e0 ff btst 0xff, %i3
40015434: 22 bf ff c2 be,a 4001533c <fat_sync+0x18> <== ALWAYS TAKEN
40015438: b0 10 20 00 clr %i0
{
int rc = RC_OK;
rc = fat_fat32_update_fsinfo_sector(fs_info);
if ( rc != RC_OK )
rc = -1;
4001543c: 10 bf ff c0 b 4001533c <fat_sync+0x18> <== NOT EXECUTED
40015440: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
fat_buf_release(fs_info);
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
rc = -1;
40015444: 81 c7 e0 08 ret <== NOT EXECUTED
40015448: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
400380b4 <fchdir>:
/**
* compatible with SVr4, 4.4BSD and X/OPEN - Change Directory
*/
int fchdir( int fd )
{
400380b4: 9d e3 bf 40 save %sp, -192, %sp <== NOT EXECUTED
st.st_mode = 0;
st.st_uid = 0;
st.st_gid = 0;
rtems_libio_check_fd( fd );
400380b8: 03 10 01 95 sethi %hi(0x40065400), %g1 <== NOT EXECUTED
400380bc: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 40065420 <rtems_libio_number_iops><== NOT EXECUTED
int rv = 0;
rtems_libio_t *iop;
struct stat st;
rtems_filesystem_location_info_t loc;
st.st_mode = 0;
400380c0: c0 27 bf c4 clr [ %fp + -60 ] <== NOT EXECUTED
st.st_uid = 0;
400380c4: c0 37 bf ca clrh [ %fp + -54 ] <== NOT EXECUTED
st.st_gid = 0;
rtems_libio_check_fd( fd );
400380c8: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED
400380cc: 1a 80 00 3d bcc 400381c0 <fchdir+0x10c> <== NOT EXECUTED
400380d0: c0 37 bf cc clrh [ %fp + -52 ] <== NOT EXECUTED
iop = rtems_libio_iop( fd );
400380d4: 03 10 01 a5 sethi %hi(0x40069400), %g1 <== NOT EXECUTED
400380d8: fa 00 63 00 ld [ %g1 + 0x300 ], %i5 ! 40069700 <rtems_libio_iops><== NOT EXECUTED
400380dc: 83 2e 20 03 sll %i0, 3, %g1 <== NOT EXECUTED
400380e0: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED
400380e4: b0 26 00 01 sub %i0, %g1, %i0 <== NOT EXECUTED
400380e8: ba 07 40 18 add %i5, %i0, %i5 <== NOT EXECUTED
rtems_libio_check_is_open( iop );
400380ec: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
400380f0: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
400380f4: 02 80 00 33 be 400381c0 <fchdir+0x10c> <== NOT EXECUTED
400380f8: 01 00 00 00 nop <== NOT EXECUTED
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;
400380fc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
40038100: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40038104: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40038108: 9f c0 40 00 call %g1 <== NOT EXECUTED
4003810c: b8 07 60 14 add %i5, 0x14, %i4 <== NOT EXECUTED
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
40038110: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
40038114: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40038118: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 <== NOT EXECUTED
4003811c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40038120: 92 07 bf b8 add %fp, -72, %o1 <== NOT EXECUTED
if ( rv == 0 ) {
40038124: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40038128: 02 80 00 09 be 4003814c <fchdir+0x98> <== NOT EXECUTED
4003812c: d2 07 bf c4 ld [ %fp + -60 ], %o1 <== NOT EXECUTED
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;
40038130: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
40038134: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40038138: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
4003813c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40038140: 01 00 00 00 nop <== NOT EXECUTED
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
}
return rv;
}
40038144: 81 c7 e0 08 ret <== NOT EXECUTED
40038148: 81 e8 00 00 restore <== NOT EXECUTED
rtems_libio_check_is_open( iop );
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
if ( rv == 0 ) {
bool access_ok = rtems_filesystem_check_access(
4003814c: d4 17 bf ca lduh [ %fp + -54 ], %o2 <== NOT EXECUTED
40038150: d6 17 bf cc lduh [ %fp + -52 ], %o3 <== NOT EXECUTED
40038154: 7f ff 5d 8e call 4000f78c <rtems_filesystem_check_access> <== NOT EXECUTED
40038158: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
st.st_mode,
st.st_uid,
st.st_gid
);
if ( access_ok ) {
4003815c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40038160: 02 80 00 0d be 40038194 <fchdir+0xe0> <== NOT EXECUTED
40038164: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
40038168: 7f ff 5b e4 call 4000f0f8 <rtems_filesystem_location_clone><== NOT EXECUTED
4003816c: 90 07 bf a0 add %fp, -96, %o0 <== NOT EXECUTED
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;
40038170: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
40038174: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40038178: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
4003817c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40038180: 01 00 00 00 nop <== NOT EXECUTED
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
40038184: 7f ff bd 5c call 400276f4 <rtems_filesystem_chdir> <== NOT EXECUTED
40038188: 90 07 bf a0 add %fp, -96, %o0 <== NOT EXECUTED
4003818c: 81 c7 e0 08 ret <== NOT EXECUTED
40038190: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
);
if ( access_ok ) {
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
} else {
errno = EACCES;
40038194: 40 00 11 75 call 4003c768 <__errno> <== NOT EXECUTED
40038198: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4003819c: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
400381a0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
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;
400381a4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
400381a8: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
400381ac: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
400381b0: 9f c0 40 00 call %g1 <== NOT EXECUTED
400381b4: 01 00 00 00 nop <== NOT EXECUTED
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
}
return rv;
}
400381b8: 81 c7 e0 08 ret <== NOT EXECUTED
400381bc: 81 e8 00 00 restore <== NOT EXECUTED
st.st_uid = 0;
st.st_gid = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
400381c0: 40 00 11 6a call 4003c768 <__errno> <== NOT EXECUTED
400381c4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400381c8: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED
400381cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400381d0: 81 c7 e0 08 ret <== NOT EXECUTED
400381d4: 81 e8 00 00 restore <== NOT EXECUTED
400381d8: 40 03 83 40 call 40118ed8 <__end+0xae8d8> <== NOT EXECUTED
400381dc: 40 03 83 34 call 40118eac <__end+0xae8ac> <== NOT EXECUTED
400381e0: 40 03 83 14 call 40118e30 <__end+0xae830> <== NOT EXECUTED
400381e4: 40 03 82 f4 call 40118db4 <__end+0xae7b4> <== NOT EXECUTED
400381e8: 40 03 82 a0 call 40118c68 <__end+0xae668> <== NOT EXECUTED
400381ec: 40 03 82 88 call 40118c0c <__end+0xae60c> <== NOT EXECUTED
400381f0: 40 03 82 88 call 40118c10 <__end+0xae610> <== NOT EXECUTED
400381f4: 40 03 82 88 call 40118c14 <__end+0xae614> <== NOT EXECUTED
400381f8: 40 03 82 88 call 40118c18 <__end+0xae618> <== NOT EXECUTED
400381fc: 40 03 82 88 call 40118c1c <__end+0xae61c> <== NOT EXECUTED
40027c3c <fchmod>:
/**
* POSIX 1003.1b 5.6.4 - Change File Modes
*/
int fchmod( int fd, mode_t mode )
{
40027c3c: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
40027c40: 03 10 01 95 sethi %hi(0x40065400), %g1
40027c44: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 40065420 <rtems_libio_number_iops>
40027c48: 80 a6 00 01 cmp %i0, %g1
40027c4c: 1a 80 00 28 bcc 40027cec <fchmod+0xb0>
40027c50: 03 10 01 a5 sethi %hi(0x40069400), %g1
iop = rtems_libio_iop( fd );
40027c54: fa 00 63 00 ld [ %g1 + 0x300 ], %i5 ! 40069700 <rtems_libio_iops>
40027c58: 83 2e 20 03 sll %i0, 3, %g1
40027c5c: b1 2e 20 06 sll %i0, 6, %i0
40027c60: b0 26 00 01 sub %i0, %g1, %i0
40027c64: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
40027c68: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40027c6c: 80 88 61 00 btst 0x100, %g1
40027c70: 02 80 00 1f be 40027cec <fchmod+0xb0>
40027c74: 01 00 00 00 nop
if (iop->pathinfo.mt_entry->writeable) {
40027c78: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
40027c7c: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
40027c80: 80 a0 60 00 cmp %g1, 0
40027c84: 02 80 00 14 be 40027cd4 <fchmod+0x98> <== NEVER TAKEN
40027c88: 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 );
40027c8c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40027c90: c2 00 40 00 ld [ %g1 ], %g1
40027c94: 9f c0 40 00 call %g1
40027c98: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
40027c9c: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40027ca0: 90 07 60 14 add %i5, 0x14, %o0
40027ca4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40027ca8: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
40027cac: 9f c0 40 00 call %g1
40027cb0: 92 10 00 19 mov %i1, %o1
40027cb4: 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;
40027cb8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40027cbc: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40027cc0: c2 00 60 04 ld [ %g1 + 4 ], %g1
40027cc4: 9f c0 40 00 call %g1
40027cc8: 01 00 00 00 nop
40027ccc: 81 c7 e0 08 ret
40027cd0: 81 e8 00 00 restore
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
40027cd4: 40 00 52 a5 call 4003c768 <__errno> <== NOT EXECUTED
40027cd8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40027cdc: 82 10 20 1e mov 0x1e, %g1 <== NOT EXECUTED
40027ce0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40027ce4: 81 c7 e0 08 ret <== NOT EXECUTED
40027ce8: 81 e8 00 00 restore <== NOT EXECUTED
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
40027cec: 40 00 52 9f call 4003c768 <__errno>
40027cf0: b0 10 3f ff mov -1, %i0
40027cf4: 82 10 20 09 mov 9, %g1
40027cf8: c2 22 00 00 st %g1, [ %o0 ]
40027cfc: 81 c7 e0 08 ret
40027d00: 81 e8 00 00 restore
40027d04 <fchown>:
/**
* POSIX 1003.1b 5.6.5 - Change Owner and Group of a File
*/
int fchown( int fd, uid_t owner, gid_t group )
{
40027d04: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
40027d08: 03 10 01 95 sethi %hi(0x40065400), %g1
40027d0c: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 40065420 <rtems_libio_number_iops>
40027d10: 80 a6 00 01 cmp %i0, %g1
40027d14: 1a 80 00 29 bcc 40027db8 <fchown+0xb4>
40027d18: 03 10 01 a5 sethi %hi(0x40069400), %g1
iop = rtems_libio_iop( fd );
40027d1c: fa 00 63 00 ld [ %g1 + 0x300 ], %i5 ! 40069700 <rtems_libio_iops>
40027d20: 83 2e 20 03 sll %i0, 3, %g1
40027d24: b1 2e 20 06 sll %i0, 6, %i0
40027d28: b0 26 00 01 sub %i0, %g1, %i0
40027d2c: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
40027d30: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40027d34: 80 88 61 00 btst 0x100, %g1
40027d38: 02 80 00 20 be 40027db8 <fchown+0xb4>
40027d3c: 01 00 00 00 nop
if (iop->pathinfo.mt_entry->writeable) {
40027d40: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
40027d44: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
40027d48: 80 a0 60 00 cmp %g1, 0
40027d4c: 02 80 00 15 be 40027da0 <fchown+0x9c> <== NEVER TAKEN
40027d50: 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 );
40027d54: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40027d58: c2 00 40 00 ld [ %g1 ], %g1
40027d5c: 9f c0 40 00 call %g1
40027d60: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->chown_h)(
40027d64: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40027d68: 90 07 60 14 add %i5, 0x14, %o0
40027d6c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40027d70: 92 10 00 19 mov %i1, %o1
40027d74: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40027d78: 9f c0 40 00 call %g1
40027d7c: 94 10 00 1a mov %i2, %o2
40027d80: 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;
40027d84: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40027d88: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40027d8c: c2 00 60 04 ld [ %g1 + 4 ], %g1
40027d90: 9f c0 40 00 call %g1
40027d94: 01 00 00 00 nop
40027d98: 81 c7 e0 08 ret
40027d9c: 81 e8 00 00 restore
owner,
group
);
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
40027da0: 40 00 52 72 call 4003c768 <__errno> <== NOT EXECUTED
40027da4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40027da8: 82 10 20 1e mov 0x1e, %g1 <== NOT EXECUTED
40027dac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40027db0: 81 c7 e0 08 ret <== NOT EXECUTED
40027db4: 81 e8 00 00 restore <== NOT EXECUTED
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
40027db8: 40 00 52 6c call 4003c768 <__errno>
40027dbc: b0 10 3f ff mov -1, %i0
40027dc0: 82 10 20 09 mov 9, %g1
40027dc4: c2 22 00 00 st %g1, [ %o0 ]
40027dc8: 81 c7 e0 08 ret
40027dcc: 81 e8 00 00 restore
4003418c <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
4003418c: 9d e3 bf 98 save %sp, -104, %sp
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
40034190: 03 10 00 e8 sethi %hi(0x4003a000), %g1
40034194: c4 00 63 ac ld [ %g1 + 0x3ac ], %g2 ! 4003a3ac <rtems_libio_number_iops>
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
40034198: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
4003419c: 82 07 a0 4c add %fp, 0x4c, %g1
400341a0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
400341a4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
400341a8: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
400341ac: 80 a6 00 02 cmp %i0, %g2
400341b0: 1a 80 00 7c bcc 400343a0 <fcntl+0x214>
400341b4: c2 27 bf fc st %g1, [ %fp + -4 ]
iop = rtems_libio_iop( fd );
400341b8: 39 10 01 2c sethi %hi(0x4004b000), %i4
400341bc: fa 07 20 94 ld [ %i4 + 0x94 ], %i5 ! 4004b094 <rtems_libio_iops>
400341c0: 85 2e 20 03 sll %i0, 3, %g2
400341c4: b1 2e 20 06 sll %i0, 6, %i0
400341c8: b0 26 00 02 sub %i0, %g2, %i0
400341cc: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
400341d0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
400341d4: 80 8a 21 00 btst 0x100, %o0
400341d8: 02 80 00 72 be 400343a0 <fcntl+0x214>
400341dc: 80 a6 60 09 cmp %i1, 9
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
400341e0: 08 80 00 08 bleu 40034200 <fcntl+0x74>
400341e4: 85 2e 60 02 sll %i1, 2, %g2
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
400341e8: 7f ff be 54 call 40023b38 <__errno>
400341ec: b0 10 3f ff mov -1, %i0
400341f0: 82 10 20 16 mov 0x16, %g1
400341f4: c2 22 00 00 st %g1, [ %o0 ]
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
400341f8: 81 c7 e0 08 ret
400341fc: 81 e8 00 00 restore
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
40034200: 07 10 00 d0 sethi %hi(0x40034000), %g3
40034204: 86 10 e1 64 or %g3, 0x164, %g3 ! 40034164 <_calloc_r+0x14>
40034208: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
4003420c: 81 c0 80 00 jmp %g2
40034210: 01 00 00 00 nop
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
40034214: 7f ff be 49 call 40023b38 <__errno>
40034218: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff>
4003421c: 82 10 20 86 mov 0x86, %g1
40034220: c2 22 00 00 st %g1, [ %o0 ]
40034224: 81 c7 e0 08 ret
40034228: 81 e8 00 00 restore
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
4003422c: d0 00 40 00 ld [ %g1 ], %o0
40034230: 7f ff 54 95 call 40009484 <rtems_libio_fcntl_flags>
40034234: b0 10 20 00 clr %i0
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
40034238: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4003423c: 90 0a 22 01 and %o0, 0x201, %o0
40034240: 82 08 7d fe and %g1, -514, %g1
40034244: 82 12 00 01 or %o0, %g1, %g1
40034248: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
4003424c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40034250: 90 10 00 1d mov %i5, %o0
40034254: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
40034258: 9f c0 40 00 call %g1
4003425c: 92 10 00 19 mov %i1, %o1
if (err) {
40034260: ba 92 20 00 orcc %o0, 0, %i5
40034264: 02 80 00 53 be 400343b0 <fcntl+0x224> <== ALWAYS TAKEN
40034268: 01 00 00 00 nop
errno = err;
4003426c: 7f ff be 33 call 40023b38 <__errno> <== NOT EXECUTED
40034270: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40034274: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
40034278: 81 c7 e0 08 ret <== NOT EXECUTED
4003427c: 81 e8 00 00 restore <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
40034280: 7f ff 54 8e call 400094b8 <rtems_libio_to_fcntl_flags>
40034284: 01 00 00 00 nop
40034288: b0 10 00 08 mov %o0, %i0
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
4003428c: 80 a6 20 00 cmp %i0, 0
40034290: 36 bf ff f0 bge,a 40034250 <fcntl+0xc4> <== ALWAYS TAKEN
40034294: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
40034298: 81 c7 e0 08 ret <== NOT EXECUTED
4003429c: 81 e8 00 00 restore <== NOT EXECUTED
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
400342a0: c2 00 40 00 ld [ %g1 ], %g1
400342a4: 80 a0 60 00 cmp %g1, 0
400342a8: 22 80 00 3b be,a 40034394 <fcntl+0x208>
400342ac: 90 0a 37 ff and %o0, -2049, %o0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
400342b0: 90 12 28 00 or %o0, 0x800, %o0
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
400342b4: b0 10 20 00 clr %i0
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
400342b8: 10 bf ff e5 b 4003424c <fcntl+0xc0>
400342bc: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
fd2 = va_arg( ap, int );
ret = duplicate_iop( iop, fd2 );
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
400342c0: b1 32 20 0b srl %o0, 0xb, %i0
400342c4: 10 bf ff e2 b 4003424c <fcntl+0xc0>
400342c8: b0 0e 20 01 and %i0, 1, %i0
/*
* FIXME: We ignore the start value fd2 for the file descriptor search. This
* is not POSIX conform.
*/
rtems_libio_t *diop = rtems_libio_allocate();
400342cc: 7f ff 54 92 call 40009514 <rtems_libio_allocate>
400342d0: 01 00 00 00 nop
if (diop != NULL) {
400342d4: b6 92 20 00 orcc %o0, 0, %i3
400342d8: 02 bf ff c8 be 400341f8 <fcntl+0x6c>
400342dc: b0 10 3f ff mov -1, %i0
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
400342e0: 7f ff 54 76 call 400094b8 <rtems_libio_to_fcntl_flags>
400342e4: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
oflag &= ~O_CREAT;
diop->flags |= rtems_libio_fcntl_flags( oflag );
400342e8: f0 06 e0 10 ld [ %i3 + 0x10 ], %i0
rtems_libio_t *diop = rtems_libio_allocate();
if (diop != NULL) {
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
oflag &= ~O_CREAT;
400342ec: b4 0a 3d ff and %o0, -513, %i2
diop->flags |= rtems_libio_fcntl_flags( oflag );
400342f0: 7f ff 54 65 call 40009484 <rtems_libio_fcntl_flags>
400342f4: 90 10 00 1a mov %i2, %o0
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
400342f8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
400342fc: b0 12 00 18 or %o0, %i0, %i0
(*mt_entry->ops->lock_h)( mt_entry );
40034300: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40034304: 90 10 00 01 mov %g1, %o0
40034308: c2 00 80 00 ld [ %g2 ], %g1
4003430c: 9f c0 40 00 call %g1
40034310: f0 26 e0 10 st %i0, [ %i3 + 0x10 ]
rtems_filesystem_instance_lock( &iop->pathinfo );
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
40034314: 92 07 60 14 add %i5, 0x14, %o1
40034318: 7f ff 91 ac call 400189c8 <rtems_filesystem_location_clone>
4003431c: 90 06 e0 14 add %i3, 0x14, %o0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40034320: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40034324: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40034328: c2 00 60 04 ld [ %g1 + 4 ], %g1
4003432c: 9f c0 40 00 call %g1
40034330: 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 );
40034334: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
40034338: 90 10 00 1b mov %i3, %o0
4003433c: c2 00 40 00 ld [ %g1 ], %g1
40034340: 92 10 20 00 clr %o1
40034344: 94 10 00 1a mov %i2, %o2
40034348: 9f c0 40 00 call %g1
4003434c: 96 10 20 00 clr %o3
if ( rv == 0 ) {
40034350: b0 92 20 00 orcc %o0, 0, %i0
40034354: 12 80 00 19 bne 400343b8 <fcntl+0x22c> <== NEVER TAKEN
40034358: c2 07 20 94 ld [ %i4 + 0x94 ], %g1
rv = diop - rtems_libio_iops;
4003435c: b6 26 c0 01 sub %i3, %g1, %i3
40034360: b7 3e e0 03 sra %i3, 3, %i3
40034364: 85 2e e0 03 sll %i3, 3, %g2
40034368: 83 2e e0 06 sll %i3, 6, %g1
4003436c: 82 00 80 01 add %g2, %g1, %g1
40034370: 85 28 60 06 sll %g1, 6, %g2
40034374: 82 00 40 02 add %g1, %g2, %g1
40034378: 82 00 40 1b add %g1, %i3, %g1
4003437c: 85 28 60 0f sll %g1, 0xf, %g2
40034380: 82 00 40 02 add %g1, %g2, %g1
40034384: 83 28 60 03 sll %g1, 3, %g1
40034388: b6 00 40 1b add %g1, %i3, %i3
4003438c: 10 bf ff c0 b 4003428c <fcntl+0x100>
40034390: b0 20 00 1b neg %i3, %i0
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
40034394: b0 10 20 00 clr %i0
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
40034398: 10 bf ff ad b 4003424c <fcntl+0xc0>
4003439c: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
400343a0: 7f ff bd e6 call 40023b38 <__errno>
400343a4: b0 10 3f ff mov -1, %i0
400343a8: 82 10 20 09 mov 9, %g1
400343ac: c2 22 00 00 st %g1, [ %o0 ]
400343b0: 81 c7 e0 08 ret
400343b4: 81 e8 00 00 restore
*/
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
if ( rv == 0 ) {
rv = diop - rtems_libio_iops;
} else {
rtems_libio_free( diop );
400343b8: 7f ff 54 6d call 4000956c <rtems_libio_free> <== NOT EXECUTED
400343bc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
400343c0: 10 bf ff b4 b 40034290 <fcntl+0x104> <== NOT EXECUTED
400343c4: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
40004bec <fdatasync>:
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
40004bec: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
40004bf0: 03 10 00 60 sethi %hi(0x40018000), %g1
40004bf4: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 ! 400180c4 <rtems_libio_number_iops>
40004bf8: 80 a6 00 01 cmp %i0, %g1
40004bfc: 1a 80 00 13 bcc 40004c48 <fdatasync+0x5c>
40004c00: 03 10 00 63 sethi %hi(0x40018c00), %g1
iop = rtems_libio_iop( fd );
40004c04: d0 00 60 20 ld [ %g1 + 0x20 ], %o0 ! 40018c20 <rtems_libio_iops>
40004c08: 83 2e 20 03 sll %i0, 3, %g1
40004c0c: b1 2e 20 06 sll %i0, 6, %i0
40004c10: b0 26 00 01 sub %i0, %g1, %i0
40004c14: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open(iop);
40004c18: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40004c1c: 80 88 61 00 btst 0x100, %g1
40004c20: 02 80 00 0a be 40004c48 <fdatasync+0x5c> <== NEVER TAKEN
40004c24: 80 88 60 04 btst 4, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40004c28: 02 80 00 08 be 40004c48 <fdatasync+0x5c>
40004c2c: 01 00 00 00 nop
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
40004c30: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
40004c34: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40004c38: 9f c0 40 00 call %g1
40004c3c: 01 00 00 00 nop
}
40004c40: 81 c7 e0 08 ret
40004c44: 91 e8 00 08 restore %g0, %o0, %o0
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40004c48: 40 00 32 5d call 400115bc <__errno>
40004c4c: b0 10 3f ff mov -1, %i0
40004c50: 82 10 20 09 mov 9, %g1
40004c54: c2 22 00 00 st %g1, [ %o0 ]
40004c58: 81 c7 e0 08 ret
40004c5c: 81 e8 00 00 restore
4000ed00 <fifo_open>:
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000ed00: 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) {
4000ed04: 3b 10 00 92 sethi %hi(0x40024800), %i5
4000ed08: d0 07 63 20 ld [ %i5 + 0x320 ], %o0 ! 40024b20 <pipe_semaphore>
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000ed0c: b6 10 00 18 mov %i0, %i3
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
4000ed10: 80 a2 20 00 cmp %o0, 0
4000ed14: 02 80 00 18 be 4000ed74 <fifo_open+0x74>
4000ed18: b8 17 63 20 or %i5, 0x320, %i4
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4000ed1c: 92 10 20 00 clr %o1
4000ed20: 7f ff eb d9 call 40009c84 <rtems_semaphore_obtain>
4000ed24: 94 10 20 00 clr %o2
}
if (sc == RTEMS_SUCCESSFUL) {
4000ed28: 80 a2 20 00 cmp %o0, 0
4000ed2c: 12 80 00 7a bne 4000ef14 <fifo_open+0x214> <== NEVER TAKEN
4000ed30: 01 00 00 00 nop
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
4000ed34: f8 06 c0 00 ld [ %i3 ], %i4
if (pipe == NULL) {
4000ed38: 80 a7 20 00 cmp %i4, 0
4000ed3c: 02 80 00 1b be 4000eda8 <fifo_open+0xa8>
4000ed40: 01 00 00 00 nop
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
4000ed44: d0 07 20 28 ld [ %i4 + 0x28 ], %o0
4000ed48: 92 10 20 00 clr %o1
4000ed4c: 7f ff eb ce call 40009c84 <rtems_semaphore_obtain>
4000ed50: 94 10 20 00 clr %o2
4000ed54: 80 a2 20 00 cmp %o0, 0
4000ed58: 02 80 00 8c be 4000ef88 <fifo_open+0x288> <== ALWAYS TAKEN
4000ed5c: c2 06 c0 00 ld [ %i3 ], %g1
err = -EINTR;
if (*pipep == NULL) {
4000ed60: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000ed64: 22 80 00 6e be,a 4000ef1c <fifo_open+0x21c> <== NOT EXECUTED
4000ed68: d0 07 20 2c ld [ %i4 + 0x2c ], %o0 <== NOT EXECUTED
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
4000ed6c: 10 80 00 76 b 4000ef44 <fifo_open+0x244> <== NOT EXECUTED
4000ed70: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000ed74: 35 10 00 93 sethi %hi(0x40024c00), %i2
4000ed78: d0 06 a2 0c ld [ %i2 + 0x20c ], %o0 ! 40024e0c <rtems_libio_semaphore>
4000ed7c: 92 10 20 00 clr %o1
4000ed80: 7f ff eb c1 call 40009c84 <rtems_semaphore_obtain>
4000ed84: 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) {
4000ed88: c2 07 63 20 ld [ %i5 + 0x320 ], %g1
4000ed8c: 80 a0 60 00 cmp %g1, 0
4000ed90: 02 80 00 55 be 4000eee4 <fifo_open+0x1e4> <== ALWAYS TAKEN
4000ed94: 98 10 00 1c mov %i4, %o4
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4000ed98: 7f ff ec 0a call 40009dc0 <rtems_semaphore_release> <== NOT EXECUTED
4000ed9c: d0 06 a2 0c ld [ %i2 + 0x20c ], %o0 <== NOT EXECUTED
4000eda0: 10 bf ff df b 4000ed1c <fifo_open+0x1c> <== NOT EXECUTED
4000eda4: d0 07 63 20 ld [ %i5 + 0x320 ], %o0 <== NOT EXECUTED
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
4000eda8: 7f ff da 69 call 4000574c <malloc>
4000edac: 90 10 20 34 mov 0x34, %o0
if (pipe == NULL)
4000edb0: b8 92 20 00 orcc %o0, 0, %i4
4000edb4: 02 80 00 73 be 4000ef80 <fifo_open+0x280> <== NEVER TAKEN
4000edb8: 82 10 22 00 mov 0x200, %g1
return err;
memset(pipe, 0, sizeof(pipe_control_t));
4000edbc: c0 27 00 00 clr [ %i4 ]
4000edc0: c0 27 20 08 clr [ %i4 + 8 ]
4000edc4: c0 27 20 0c clr [ %i4 + 0xc ]
4000edc8: c0 27 20 10 clr [ %i4 + 0x10 ]
4000edcc: c0 27 20 14 clr [ %i4 + 0x14 ]
4000edd0: c0 27 20 18 clr [ %i4 + 0x18 ]
4000edd4: c0 27 20 1c clr [ %i4 + 0x1c ]
4000edd8: c0 27 20 20 clr [ %i4 + 0x20 ]
4000eddc: c0 27 20 24 clr [ %i4 + 0x24 ]
4000ede0: c0 27 20 28 clr [ %i4 + 0x28 ]
4000ede4: c0 27 20 2c clr [ %i4 + 0x2c ]
4000ede8: c0 27 20 30 clr [ %i4 + 0x30 ]
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
4000edec: 90 10 22 00 mov 0x200, %o0
4000edf0: 7f ff da 57 call 4000574c <malloc>
4000edf4: c2 27 20 04 st %g1, [ %i4 + 4 ]
if (! pipe->Buffer)
4000edf8: 80 a2 20 00 cmp %o0, 0
4000edfc: 02 80 00 5f be 4000ef78 <fifo_open+0x278> <== NEVER TAKEN
4000ee00: d0 27 00 00 st %o0, [ %i4 ]
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
4000ee04: 35 10 00 90 sethi %hi(0x40024000), %i2
4000ee08: d0 4e a3 90 ldsb [ %i2 + 0x390 ], %o0 ! 40024390 <c.7174>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
4000ee0c: 31 14 12 5c sethi %hi(0x50497000), %i0
4000ee10: 82 16 22 00 or %i0, 0x200, %g1 ! 50497200 <RAM_END+0x10097200>
4000ee14: 92 10 20 00 clr %o1
4000ee18: 94 10 20 00 clr %o2
4000ee1c: 90 12 00 01 or %o0, %g1, %o0
4000ee20: 40 00 06 59 call 40010784 <rtems_barrier_create>
4000ee24: 96 07 20 2c add %i4, 0x2c, %o3
4000ee28: 80 a2 20 00 cmp %o0, 0
4000ee2c: 12 80 00 51 bne 4000ef70 <fifo_open+0x270>
4000ee30: d0 4e a3 90 ldsb [ %i2 + 0x390 ], %o0
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
4000ee34: 03 14 12 5d sethi %hi(0x50497400), %g1
4000ee38: 82 10 63 00 or %g1, 0x300, %g1 ! 50497700 <RAM_END+0x10097700>
4000ee3c: 92 10 20 00 clr %o1
4000ee40: 94 10 20 00 clr %o2
4000ee44: 90 12 00 01 or %o0, %g1, %o0
4000ee48: 40 00 06 4f call 40010784 <rtems_barrier_create>
4000ee4c: 96 07 20 30 add %i4, 0x30, %o3
4000ee50: 80 a2 20 00 cmp %o0, 0
4000ee54: 12 80 00 45 bne 4000ef68 <fifo_open+0x268>
4000ee58: d0 4e a3 90 ldsb [ %i2 + 0x390 ], %o0
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
4000ee5c: b0 16 23 00 or %i0, 0x300, %i0
4000ee60: 92 10 20 01 mov 1, %o1
4000ee64: 90 12 00 18 or %o0, %i0, %o0
4000ee68: 94 10 20 10 mov 0x10, %o2
4000ee6c: 96 10 20 00 clr %o3
4000ee70: 7f ff ea dd call 400099e4 <rtems_semaphore_create>
4000ee74: 98 07 20 28 add %i4, 0x28, %o4
4000ee78: 80 a2 20 00 cmp %o0, 0
4000ee7c: 12 80 00 39 bne 4000ef60 <fifo_open+0x260>
4000ee80: 94 07 bf fc add %fp, -4, %o2
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
4000ee84: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
4000ee88: 21 10 00 96 sethi %hi(0x40025800), %l0
4000ee8c: 7f ff f2 85 call 4000b8a0 <_Objects_Get>
4000ee90: 90 14 20 a0 or %l0, 0xa0, %o0 ! 400258a0 <_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;
4000ee94: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
4000ee98: 31 04 00 00 sethi %hi(0x10000000), %i0
4000ee9c: 82 10 40 18 or %g1, %i0, %g1
_Thread_Enable_dispatch();
4000eea0: 7f ff f6 37 call 4000c77c <_Thread_Enable_dispatch>
4000eea4: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
4000eea8: d2 07 20 30 ld [ %i4 + 0x30 ], %o1
4000eeac: 94 07 bf fc add %fp, -4, %o2
4000eeb0: 7f ff f2 7c call 4000b8a0 <_Objects_Get>
4000eeb4: 90 14 20 a0 or %l0, 0xa0, %o0
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
4000eeb8: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
4000eebc: b0 10 40 18 or %g1, %i0, %i0
_Thread_Enable_dispatch();
4000eec0: 7f ff f6 2f call 4000c77c <_Thread_Enable_dispatch>
4000eec4: f0 22 20 4c st %i0, [ %o0 + 0x4c ]
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
4000eec8: c2 4e a3 90 ldsb [ %i2 + 0x390 ], %g1
4000eecc: 80 a0 60 7a cmp %g1, 0x7a
4000eed0: 02 80 00 21 be 4000ef54 <fifo_open+0x254>
4000eed4: c4 0e a3 90 ldub [ %i2 + 0x390 ], %g2
4000eed8: 84 00 a0 01 inc %g2
4000eedc: 10 bf ff 9a b 4000ed44 <fifo_open+0x44>
4000eee0: c4 2e a3 90 stb %g2, [ %i2 + 0x390 ]
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
sc = rtems_semaphore_create(
4000eee4: 92 10 20 01 mov 1, %o1
4000eee8: 94 10 20 54 mov 0x54, %o2
4000eeec: 96 10 20 00 clr %o3
4000eef0: 11 14 12 54 sethi %hi(0x50495000), %o0
4000eef4: 7f ff ea bc call 400099e4 <rtems_semaphore_create>
4000eef8: 90 12 20 45 or %o0, 0x45, %o0 ! 50495045 <RAM_END+0x10095045>
4000eefc: b8 10 00 08 mov %o0, %i4
4000ef00: 7f ff eb b0 call 40009dc0 <rtems_semaphore_release>
4000ef04: d0 06 a2 0c ld [ %i2 + 0x20c ], %o0
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
4000ef08: 80 a7 20 00 cmp %i4, 0
4000ef0c: 02 bf ff 84 be 4000ed1c <fifo_open+0x1c>
4000ef10: d0 07 63 20 ld [ %i5 + 0x320 ], %o0
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
err = -ENXIO;
4000ef14: 81 c7 e0 08 ret
4000ef18: 91 e8 3f f4 restore %g0, -12, %o0
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
4000ef1c: 40 00 06 4b call 40010848 <rtems_barrier_delete> <== NOT EXECUTED
4000ef20: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
4000ef24: 40 00 06 49 call 40010848 <rtems_barrier_delete> <== NOT EXECUTED
4000ef28: d0 07 20 30 ld [ %i4 + 0x30 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
4000ef2c: 7f ff eb 1f call 40009ba8 <rtems_semaphore_delete> <== NOT EXECUTED
4000ef30: d0 07 20 28 ld [ %i4 + 0x28 ], %o0 <== NOT EXECUTED
free(pipe->Buffer);
4000ef34: 7f ff d8 eb call 400052e0 <free> <== NOT EXECUTED
4000ef38: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free(pipe);
4000ef3c: 7f ff d8 e9 call 400052e0 <free> <== NOT EXECUTED
4000ef40: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
4000ef44: 7f ff eb 9f call 40009dc0 <rtems_semaphore_release>
4000ef48: d0 07 63 20 ld [ %i5 + 0x320 ], %o0
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
4000ef4c: 81 c7 e0 08 ret
4000ef50: 81 e8 00 00 restore
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
c = 'a';
4000ef54: 82 10 20 61 mov 0x61, %g1
4000ef58: 10 bf ff 7b b 4000ed44 <fifo_open+0x44>
4000ef5c: c2 2e a3 90 stb %g1, [ %i2 + 0x390 ]
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
4000ef60: 40 00 06 3a call 40010848 <rtems_barrier_delete>
4000ef64: d0 07 20 30 ld [ %i4 + 0x30 ], %o0
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
4000ef68: 40 00 06 38 call 40010848 <rtems_barrier_delete>
4000ef6c: d0 07 20 2c ld [ %i4 + 0x2c ], %o0
err_rbar:
free(pipe->Buffer);
4000ef70: 7f ff d8 dc call 400052e0 <free>
4000ef74: d0 07 00 00 ld [ %i4 ], %o0
err_buf:
free(pipe);
4000ef78: 7f ff d8 da call 400052e0 <free>
4000ef7c: 90 10 00 1c mov %i4, %o0
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
4000ef80: 10 bf ff f1 b 4000ef44 <fifo_open+0x244>
4000ef84: b0 10 3f f4 mov -12, %i0
if (*pipep == NULL) {
4000ef88: 80 a0 60 00 cmp %g1, 0
4000ef8c: 22 80 00 02 be,a 4000ef94 <fifo_open+0x294>
4000ef90: f8 26 c0 00 st %i4, [ %i3 ]
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
4000ef94: 7f ff eb 8b call 40009dc0 <rtems_semaphore_release>
4000ef98: d0 07 63 20 ld [ %i5 + 0x320 ], %o0
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
4000ef9c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000efa0: 82 08 60 06 and %g1, 6, %g1
4000efa4: 80 a0 60 04 cmp %g1, 4
4000efa8: 02 80 00 0c be 4000efd8 <fifo_open+0x2d8>
4000efac: fa 06 c0 00 ld [ %i3 ], %i5
4000efb0: 80 a0 60 06 cmp %g1, 6
4000efb4: 02 80 00 58 be 4000f114 <fifo_open+0x414>
4000efb8: 80 a0 60 02 cmp %g1, 2
4000efbc: 22 80 00 31 be,a 4000f080 <fifo_open+0x380> <== ALWAYS TAKEN
4000efc0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
4000efc4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
4000efc8: 7f ff eb 7e call 40009dc0 <rtems_semaphore_release>
4000efcc: b0 10 20 00 clr %i0
return 0;
4000efd0: 81 c7 e0 08 ret
4000efd4: 81 e8 00 00 restore
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
4000efd8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
4000efdc: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
if (pipe->Writers ++ == 0)
4000efe0: 86 00 60 01 add %g1, 1, %g3
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
4000efe4: 84 00 a0 01 inc %g2
if (pipe->Writers ++ == 0)
4000efe8: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
4000efec: 80 a0 60 00 cmp %g1, 0
4000eff0: 02 80 00 68 be 4000f190 <fifo_open+0x490> <== ALWAYS TAKEN
4000eff4: c4 27 60 24 st %g2, [ %i5 + 0x24 ]
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4000eff8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
4000effc: 80 a0 60 00 cmp %g1, 0
4000f000: 32 bf ff f2 bne,a 4000efc8 <fifo_open+0x2c8>
4000f004: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000f008: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000f00c: 80 88 60 01 btst 1, %g1
4000f010: 32 80 00 65 bne,a 4000f1a4 <fifo_open+0x4a4>
4000f014: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
4000f018: 10 80 00 0c b 4000f048 <fifo_open+0x348>
4000f01c: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
4000f020: 92 10 20 00 clr %o1
4000f024: 7f ff eb 18 call 40009c84 <rtems_semaphore_obtain>
4000f028: 94 10 20 00 clr %o2
4000f02c: 80 a2 20 00 cmp %o0, 0
4000f030: 12 80 00 0f bne 4000f06c <fifo_open+0x36c> <== NEVER TAKEN
4000f034: b0 10 3f fc mov -4, %i0
goto out_error;
} while (prevCounter == pipe->readerCounter);
4000f038: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000f03c: 80 a0 40 1c cmp %g1, %i4
4000f040: 32 bf ff e2 bne,a 4000efc8 <fifo_open+0x2c8> <== ALWAYS TAKEN
4000f044: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
4000f048: 7f ff eb 5e call 40009dc0 <rtems_semaphore_release>
4000f04c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_WRITEWAIT(pipe))
4000f050: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000f054: 40 00 06 3e call 4001094c <rtems_barrier_wait>
4000f058: 92 10 20 00 clr %o1
4000f05c: 80 a2 20 00 cmp %o0, 0
4000f060: 22 bf ff f0 be,a 4000f020 <fifo_open+0x320> <== ALWAYS TAKEN
4000f064: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
/* Not an error */
if (LIBIO_NODELAY(iop))
break;
prevCounter = pipe->writerCounter;
err = -EINTR;
4000f068: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
4000f06c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000f070: 7f ff fe e5 call 4000ec04 <pipe_release>
4000f074: 92 10 00 19 mov %i1, %o1
return err;
4000f078: 81 c7 e0 08 ret
4000f07c: 81 e8 00 00 restore
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
4000f080: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
if (pipe->Readers ++ == 0)
4000f084: 86 00 60 01 add %g1, 1, %g3
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
4000f088: 84 00 a0 01 inc %g2
if (pipe->Readers ++ == 0)
4000f08c: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
4000f090: 80 a0 60 00 cmp %g1, 0
4000f094: 02 80 00 35 be 4000f168 <fifo_open+0x468> <== ALWAYS TAKEN
4000f098: c4 27 60 20 st %g2, [ %i5 + 0x20 ]
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
4000f09c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
4000f0a0: 80 a0 60 00 cmp %g1, 0
4000f0a4: 32 bf ff c9 bne,a 4000efc8 <fifo_open+0x2c8>
4000f0a8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
/* Not an error */
if (LIBIO_NODELAY(iop))
4000f0ac: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000f0b0: 80 88 60 01 btst 1, %g1
4000f0b4: 32 bf ff c5 bne,a 4000efc8 <fifo_open+0x2c8>
4000f0b8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
break;
prevCounter = pipe->writerCounter;
4000f0bc: 10 80 00 0c b 4000f0ec <fifo_open+0x3ec>
4000f0c0: f8 07 60 24 ld [ %i5 + 0x24 ], %i4
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
4000f0c4: 92 10 20 00 clr %o1
4000f0c8: 7f ff ea ef call 40009c84 <rtems_semaphore_obtain>
4000f0cc: 94 10 20 00 clr %o2
4000f0d0: 80 a2 20 00 cmp %o0, 0
4000f0d4: 12 bf ff e6 bne 4000f06c <fifo_open+0x36c> <== NEVER TAKEN
4000f0d8: b0 10 3f fc mov -4, %i0
goto out_error;
} while (prevCounter == pipe->writerCounter);
4000f0dc: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000f0e0: 80 a0 40 1c cmp %g1, %i4
4000f0e4: 32 bf ff b9 bne,a 4000efc8 <fifo_open+0x2c8> <== ALWAYS TAKEN
4000f0e8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
4000f0ec: 7f ff eb 35 call 40009dc0 <rtems_semaphore_release>
4000f0f0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_READWAIT(pipe))
4000f0f4: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000f0f8: 40 00 06 15 call 4001094c <rtems_barrier_wait>
4000f0fc: 92 10 20 00 clr %o1
4000f100: 80 a2 20 00 cmp %o0, 0
4000f104: 22 bf ff f0 be,a 4000f0c4 <fifo_open+0x3c4> <== ALWAYS TAKEN
4000f108: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
/* Not an error */
if (LIBIO_NODELAY(iop))
break;
prevCounter = pipe->writerCounter;
err = -EINTR;
4000f10c: 10 bf ff d8 b 4000f06c <fifo_open+0x36c> <== NOT EXECUTED
4000f110: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
4000f114: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
4000f118: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
if (pipe->Readers ++ == 0)
4000f11c: 86 00 60 01 add %g1, 1, %g3
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
4000f120: 84 00 a0 01 inc %g2
if (pipe->Readers ++ == 0)
4000f124: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
4000f128: 80 a0 60 00 cmp %g1, 0
4000f12c: 02 80 00 14 be 4000f17c <fifo_open+0x47c> <== ALWAYS TAKEN
4000f130: c4 27 60 20 st %g2, [ %i5 + 0x20 ]
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
4000f134: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
4000f138: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
if (pipe->Writers ++ == 0)
4000f13c: 86 00 60 01 add %g1, 1, %g3
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
4000f140: 84 00 a0 01 inc %g2
if (pipe->Writers ++ == 0)
4000f144: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
4000f148: 80 a0 60 00 cmp %g1, 0
4000f14c: 12 bf ff 9e bne 4000efc4 <fifo_open+0x2c4> <== NEVER TAKEN
4000f150: c4 27 60 24 st %g2, [ %i5 + 0x24 ]
PIPE_WAKEUPREADERS(pipe);
4000f154: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000f158: 40 00 05 e5 call 400108ec <rtems_barrier_release>
4000f15c: 92 07 bf f8 add %fp, -8, %o1
break;
}
PIPE_UNLOCK(pipe);
4000f160: 10 bf ff 9a b 4000efc8 <fifo_open+0x2c8>
4000f164: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
4000f168: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000f16c: 40 00 05 e0 call 400108ec <rtems_barrier_release>
4000f170: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Writers == 0) {
4000f174: 10 bf ff cb b 4000f0a0 <fifo_open+0x3a0>
4000f178: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
4000f17c: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000f180: 40 00 05 db call 400108ec <rtems_barrier_release>
4000f184: 92 07 bf f8 add %fp, -8, %o1
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
4000f188: 10 bf ff ec b 4000f138 <fifo_open+0x438>
4000f18c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
4000f190: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000f194: 40 00 05 d6 call 400108ec <rtems_barrier_release>
4000f198: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4000f19c: 10 bf ff 98 b 4000effc <fifo_open+0x2fc>
4000f1a0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
PIPE_UNLOCK(pipe);
4000f1a4: 7f ff eb 07 call 40009dc0 <rtems_semaphore_release>
4000f1a8: b0 10 3f fa mov -6, %i0
err = -ENXIO;
goto out_error;
4000f1ac: 10 bf ff b1 b 4000f070 <fifo_open+0x370>
4000f1b0: 90 10 00 1b mov %i3, %o0
4000aa74 <fpathconf>:
*/
long fpathconf(
int fd,
int name
)
{
4000aa74: 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);
4000aa78: 03 10 00 4d sethi %hi(0x40013400), %g1
4000aa7c: c2 00 61 e8 ld [ %g1 + 0x1e8 ], %g1 ! 400135e8 <rtems_libio_number_iops>
4000aa80: 80 a6 00 01 cmp %i0, %g1
4000aa84: 1a 80 00 3e bcc 4000ab7c <fpathconf+0x108>
4000aa88: 03 10 00 4f sethi %hi(0x40013c00), %g1
iop = rtems_libio_iop(fd);
4000aa8c: c2 00 63 b4 ld [ %g1 + 0x3b4 ], %g1 ! 40013fb4 <rtems_libio_iops>
4000aa90: 85 2e 20 03 sll %i0, 3, %g2
4000aa94: b1 2e 20 06 sll %i0, 6, %i0
4000aa98: b0 26 00 02 sub %i0, %g2, %i0
4000aa9c: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_is_open(iop);
4000aaa0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4000aaa4: 80 88 61 00 btst 0x100, %g1
4000aaa8: 02 80 00 35 be 4000ab7c <fpathconf+0x108> <== NEVER TAKEN
4000aaac: 80 a6 60 0b cmp %i1, 0xb
/*
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
4000aab0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
switch ( name ) {
4000aab4: 08 80 00 08 bleu 4000aad4 <fpathconf+0x60>
4000aab8: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
4000aabc: 40 00 09 72 call 4000d084 <__errno>
4000aac0: b0 10 3f ff mov -1, %i0
4000aac4: 82 10 20 16 mov 0x16, %g1
4000aac8: c2 22 00 00 st %g1, [ %o0 ]
break;
}
return return_value;
}
4000aacc: 81 c7 e0 08 ret
4000aad0: 81 e8 00 00 restore
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
4000aad4: b3 2e 60 02 sll %i1, 2, %i1
4000aad8: 05 10 00 2a sethi %hi(0x4000a800), %g2
4000aadc: 84 10 a2 44 or %g2, 0x244, %g2 ! 4000aa44 <_close_r+0x10>
4000aae0: c4 00 80 19 ld [ %g2 + %i1 ], %g2
4000aae4: 81 c0 80 00 jmp %g2
4000aae8: 01 00 00 00 nop
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
4000aaec: f0 00 60 24 ld [ %g1 + 0x24 ], %i0
break;
4000aaf0: 81 c7 e0 08 ret
4000aaf4: 81 e8 00 00 restore
break;
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
4000aaf8: f0 00 60 18 ld [ %g1 + 0x18 ], %i0
break;
4000aafc: 81 c7 e0 08 ret
4000ab00: 81 e8 00 00 restore
break;
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
break;
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
4000ab04: f0 00 60 2c ld [ %g1 + 0x2c ], %i0
break;
4000ab08: 81 c7 e0 08 ret
4000ab0c: 81 e8 00 00 restore
break;
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
break;
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
4000ab10: f0 00 60 20 ld [ %g1 + 0x20 ], %i0
break;
4000ab14: 81 c7 e0 08 ret
4000ab18: 81 e8 00 00 restore
break;
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
break;
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
4000ab1c: f0 00 60 1c ld [ %g1 + 0x1c ], %i0
break;
4000ab20: 81 c7 e0 08 ret
4000ab24: 81 e8 00 00 restore
break;
case _PC_PATH_MAX:
return_value = the_limits->path_max;
break;
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
4000ab28: f0 00 60 14 ld [ %g1 + 0x14 ], %i0
break;
4000ab2c: 81 c7 e0 08 ret
4000ab30: 81 e8 00 00 restore
break;
case _PC_NAME_MAX:
return_value = the_limits->name_max;
break;
case _PC_PATH_MAX:
return_value = the_limits->path_max;
4000ab34: f0 00 60 10 ld [ %g1 + 0x10 ], %i0
break;
4000ab38: 81 c7 e0 08 ret
4000ab3c: 81 e8 00 00 restore
break;
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
break;
case _PC_NAME_MAX:
return_value = the_limits->name_max;
4000ab40: f0 00 60 0c ld [ %g1 + 0xc ], %i0
break;
4000ab44: 81 c7 e0 08 ret
4000ab48: 81 e8 00 00 restore
break;
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
break;
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
4000ab4c: f0 00 60 08 ld [ %g1 + 8 ], %i0
break;
4000ab50: 81 c7 e0 08 ret
4000ab54: 81 e8 00 00 restore
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
break;
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
4000ab58: f0 00 60 04 ld [ %g1 + 4 ], %i0
break;
4000ab5c: 81 c7 e0 08 ret
4000ab60: 81 e8 00 00 restore
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
4000ab64: f0 00 40 00 ld [ %g1 ], %i0
break;
4000ab68: 81 c7 e0 08 ret
4000ab6c: 81 e8 00 00 restore
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
4000ab70: f0 00 60 28 ld [ %g1 + 0x28 ], %i0
break;
4000ab74: 81 c7 e0 08 ret
4000ab78: 81 e8 00 00 restore
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
4000ab7c: 40 00 09 42 call 4000d084 <__errno>
4000ab80: b0 10 3f ff mov -1, %i0
4000ab84: 82 10 20 09 mov 9, %g1
4000ab88: c2 22 00 00 st %g1, [ %o0 ]
4000ab8c: 81 c7 e0 08 ret
4000ab90: 81 e8 00 00 restore
40004208 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
40004208: 9d e3 bf a0 save %sp, -96, %sp
MSBUMP(free_calls, 1);
4000420c: 03 10 00 80 sethi %hi(0x40020000), %g1
40004210: 82 10 61 30 or %g1, 0x130, %g1 ! 40020130 <rtems_malloc_statistics>
40004214: c4 00 60 0c ld [ %g1 + 0xc ], %g2
#include <stdlib.h>
void free(
void *ptr
)
{
40004218: b2 10 00 18 mov %i0, %i1
MSBUMP(free_calls, 1);
4000421c: 84 00 a0 01 inc %g2
if ( !ptr )
40004220: 80 a6 20 00 cmp %i0, 0
40004224: 02 80 00 15 be 40004278 <free+0x70>
40004228: 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()) &&
4000422c: 03 10 00 81 sethi %hi(0x40020400), %g1
40004230: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 400207b8 <_System_state_Current>
40004234: 80 a0 60 03 cmp %g1, 3
40004238: 02 80 00 17 be 40004294 <free+0x8c> <== ALWAYS TAKEN
4000423c: 03 10 00 7f sethi %hi(0x4001fc00), %g1
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
40004240: c2 00 60 90 ld [ %g1 + 0x90 ], %g1 ! 4001fc90 <rtems_malloc_statistics_helpers>
40004244: 80 a0 60 00 cmp %g1, 0
40004248: 02 80 00 06 be 40004260 <free+0x58>
4000424c: 3b 10 00 7d sethi %hi(0x4001f400), %i5
(*rtems_malloc_statistics_helpers->at_free)(ptr);
40004250: c2 00 60 08 ld [ %g1 + 8 ], %g1
40004254: 9f c0 40 00 call %g1
40004258: 90 10 00 19 mov %i1, %o0
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
4000425c: 3b 10 00 7d sethi %hi(0x4001f400), %i5
40004260: d0 07 61 60 ld [ %i5 + 0x160 ], %o0 ! 4001f560 <RTEMS_Malloc_Heap>
40004264: 40 00 18 8e call 4000a49c <_Protected_heap_Free>
40004268: 92 10 00 19 mov %i1, %o1
4000426c: 80 8a 20 ff btst 0xff, %o0
40004270: 02 80 00 04 be 40004280 <free+0x78>
40004274: c2 07 61 60 ld [ %i5 + 0x160 ], %g1
40004278: 81 c7 e0 08 ret
4000427c: 81 e8 00 00 restore
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
40004280: 31 10 00 77 sethi %hi(0x4001dc00), %i0
40004284: f4 00 60 18 ld [ %g1 + 0x18 ], %i2
40004288: f6 00 60 1c ld [ %g1 + 0x1c ], %i3
4000428c: 40 00 03 81 call 40005090 <printk>
40004290: 91 ee 23 18 restore %i0, 0x318, %o0
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
40004294: 40 00 00 67 call 40004430 <malloc_is_system_state_OK>
40004298: 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()) &&
4000429c: 80 8a 20 ff btst 0xff, %o0
400042a0: 12 bf ff e8 bne 40004240 <free+0x38>
400042a4: 03 10 00 7f sethi %hi(0x4001fc00), %g1
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
400042a8: 40 00 00 7c call 40004498 <malloc_deferred_free>
400042ac: 81 e8 00 00 restore
4001c74c <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
4001c74c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
4001c750: 80 a6 60 00 cmp %i1, 0
4001c754: 02 80 00 1f be 4001c7d0 <fstat+0x84> <== NEVER TAKEN
4001c758: 03 10 00 7d sethi %hi(0x4001f400), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
4001c75c: c2 00 61 a4 ld [ %g1 + 0x1a4 ], %g1 ! 4001f5a4 <rtems_libio_number_iops>
4001c760: 80 a6 00 01 cmp %i0, %g1
4001c764: 1a 80 00 15 bcc 4001c7b8 <fstat+0x6c>
4001c768: 03 10 00 80 sethi %hi(0x40020000), %g1
4001c76c: c2 00 61 24 ld [ %g1 + 0x124 ], %g1 ! 40020124 <rtems_libio_iops>
4001c770: 85 2e 20 03 sll %i0, 3, %g2
4001c774: b1 2e 20 06 sll %i0, 6, %i0
4001c778: b0 26 00 02 sub %i0, %g2, %i0
4001c77c: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
4001c780: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4001c784: 80 88 61 00 btst 0x100, %g1
4001c788: 02 80 00 0c be 4001c7b8 <fstat+0x6c>
4001c78c: 94 10 20 48 mov 0x48, %o2
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
4001c790: 92 10 20 00 clr %o1
4001c794: 7f ff d2 f9 call 40011378 <memset>
4001c798: 90 10 00 19 mov %i1, %o0
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
4001c79c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4001c7a0: 90 06 20 14 add %i0, 0x14, %o0
4001c7a4: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
4001c7a8: 9f c0 40 00 call %g1
4001c7ac: 92 10 00 19 mov %i1, %o1
}
4001c7b0: 81 c7 e0 08 ret
4001c7b4: 91 e8 00 08 restore %g0, %o0, %o0
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
4001c7b8: 7f ff d0 62 call 40010940 <__errno>
4001c7bc: b0 10 3f ff mov -1, %i0
4001c7c0: 82 10 20 09 mov 9, %g1
4001c7c4: c2 22 00 00 st %g1, [ %o0 ]
4001c7c8: 81 c7 e0 08 ret
4001c7cc: 81 e8 00 00 restore
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
rtems_set_errno_and_return_minus_one( EFAULT );
4001c7d0: 7f ff d0 5c call 40010940 <__errno> <== NOT EXECUTED
4001c7d4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001c7d8: 82 10 20 0e mov 0xe, %g1 <== NOT EXECUTED
4001c7dc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001c7e0: 81 c7 e0 08 ret <== NOT EXECUTED
4001c7e4: 81 e8 00 00 restore <== NOT EXECUTED
400040f8 <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) {
400040f8: 03 10 00 71 sethi %hi(0x4001c400), %g1
400040fc: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 ! 4001c470 <disktab_size>
40004100: 80 a0 40 08 cmp %g1, %o0
40004104: 08 80 00 20 bleu 40004184 <get_disk_entry+0x8c> <== NEVER TAKEN
40004108: 03 10 00 71 sethi %hi(0x4001c400), %g1
4000410c: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 4001c474 <disktab>
40004110: 80 a0 60 00 cmp %g1, 0
40004114: 02 80 00 1c be 40004184 <get_disk_entry+0x8c> <== NEVER TAKEN
40004118: 01 00 00 00 nop
rtems_disk_device_table *dtab = disktab + major;
4000411c: 91 2a 20 03 sll %o0, 3, %o0
40004120: 84 00 40 08 add %g1, %o0, %g2
if (minor < dtab->size && dtab->minor != NULL) {
40004124: c4 00 a0 04 ld [ %g2 + 4 ], %g2
40004128: 80 a0 80 09 cmp %g2, %o1
4000412c: 08 80 00 16 bleu 40004184 <get_disk_entry+0x8c> <== NEVER TAKEN
40004130: 01 00 00 00 nop
40004134: c2 00 40 08 ld [ %g1 + %o0 ], %g1
40004138: 80 a0 60 00 cmp %g1, 0
4000413c: 02 80 00 12 be 40004184 <get_disk_entry+0x8c> <== NEVER TAKEN
40004140: 93 2a 60 02 sll %o1, 2, %o1
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && !lookup_only) {
40004144: 80 a2 a0 01 cmp %o2, 1
40004148: 12 80 00 04 bne 40004158 <get_disk_entry+0x60>
4000414c: d0 00 40 09 ld [ %g1 + %o1 ], %o0
return dd;
}
}
return NULL;
}
40004150: 81 c3 e0 08 retl
40004154: 01 00 00 00 nop
rtems_disk_device_table *dtab = disktab + major;
if (minor < dtab->size && dtab->minor != NULL) {
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && !lookup_only) {
40004158: 80 a2 20 00 cmp %o0, 0
4000415c: 02 bf ff fd be 40004150 <get_disk_entry+0x58> <== NEVER TAKEN
40004160: 01 00 00 00 nop
if (!dd->deleted) {
40004164: c2 0a 20 40 ldub [ %o0 + 0x40 ], %g1
40004168: 80 a0 60 00 cmp %g1, 0
4000416c: 12 80 00 06 bne 40004184 <get_disk_entry+0x8c>
40004170: 01 00 00 00 nop
++dd->uses;
40004174: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40004178: 82 00 60 01 inc %g1
4000417c: 81 c3 e0 08 retl
40004180: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
return dd;
}
}
return NULL;
}
40004184: 81 c3 e0 08 retl
40004188: 90 10 20 00 clr %o0
400056c4 <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,
400056c4: 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);
400056c8: 40 00 05 41 call 40006bcc <malloc>
400056cc: 90 10 22 04 mov 0x204, %o0
if (s == NULL)
{
return RTEMS_NO_MEMORY;
400056d0: 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)
400056d4: 80 a2 20 00 cmp %o0, 0
400056d8: 02 80 00 0c be 40005708 <get_sector.part.0+0x44> <== NEVER TAKEN
400056dc: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);
400056e0: 90 10 00 18 mov %i0, %o0
400056e4: 92 07 60 04 add %i5, 4, %o1
400056e8: 40 00 07 eb call 40007694 <read>
400056ec: 94 10 22 00 mov 0x200, %o2
if (n != RTEMS_IDE_SECTOR_SIZE)
400056f0: 80 a2 22 00 cmp %o0, 0x200
400056f4: 02 80 00 07 be 40005710 <get_sector.part.0+0x4c> <== ALWAYS TAKEN
400056f8: 82 10 20 00 clr %g1
{
free(s);
400056fc: 40 00 03 97 call 40006558 <free> <== NOT EXECUTED
40005700: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
40005704: 82 10 20 1b mov 0x1b, %g1 <== NOT EXECUTED
s->sector_num = sector_num;
*sector = s;
return RTEMS_SUCCESSFUL;
}
40005708: 81 c7 e0 08 ret <== NOT EXECUTED
4000570c: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
{
free(s);
return RTEMS_IO_ERROR;
}
s->sector_num = sector_num;
40005710: f2 27 40 00 st %i1, [ %i5 ]
*sector = s;
40005714: fa 26 80 00 st %i5, [ %i2 ]
return RTEMS_SUCCESSFUL;
}
40005718: 81 c7 e0 08 ret
4000571c: 91 e8 00 01 restore %g0, %g1, %o0
400343f0 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
400343f0: 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 );
400343f4: 03 10 00 e8 sethi %hi(0x4003a000), %g1
400343f8: c2 00 63 ac ld [ %g1 + 0x3ac ], %g1 ! 4003a3ac <rtems_libio_number_iops>
400343fc: 80 a6 00 01 cmp %i0, %g1
40034400: 1a 80 00 08 bcc 40034420 <getdents+0x30> <== NEVER TAKEN
40034404: ba 10 20 00 clr %i5
40034408: 03 10 01 2c sethi %hi(0x4004b000), %g1
4003440c: fa 00 60 94 ld [ %g1 + 0x94 ], %i5 ! 4004b094 <rtems_libio_iops>
40034410: 83 2e 20 03 sll %i0, 3, %g1
40034414: b1 2e 20 06 sll %i0, 6, %i0
40034418: b0 26 00 01 sub %i0, %g1, %i0
4003441c: ba 07 40 18 add %i5, %i0, %i5
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
40034420: 7f ff 5b 59 call 4000b184 <rtems_filesystem_node_type>
40034424: 90 07 60 14 add %i5, 0x14, %o0
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
40034428: 80 a2 20 00 cmp %o0, 0
4003442c: 12 80 00 09 bne 40034450 <getdents+0x60>
40034430: 90 10 00 1d mov %i5, %o0
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len );
40034434: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40034438: c2 00 60 08 ld [ %g1 + 8 ], %g1
4003443c: 92 10 00 19 mov %i1, %o1
40034440: 9f c0 40 00 call %g1
40034444: 94 10 00 1a mov %i2, %o2
}
40034448: 81 c7 e0 08 ret
4003444c: 91 e8 00 08 restore %g0, %o0, %o0
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
40034450: 7f ff bd ba call 40023b38 <__errno>
40034454: b0 10 3f ff mov -1, %i0
40034458: 82 10 20 14 mov 0x14, %g1
4003445c: c2 22 00 00 st %g1, [ %o0 ]
40034460: 81 c7 e0 08 ret
40034464: 81 e8 00 00 restore
4000fdac <imfs_dir_read>:
ssize_t imfs_dir_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
4000fdac: 9d e3 be 88 save %sp, -376, %sp
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
4000fdb0: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
4000fdb4: c4 02 20 0c ld [ %o0 + 0xc ], %g2
4000fdb8: c2 00 80 00 ld [ %g2 ], %g1
4000fdbc: 9f c0 40 00 call %g1
4000fdc0: 01 00 00 00 nop
int last_entry;
struct dirent tmp_dirent;
rtems_filesystem_instance_lock( &iop->pathinfo );
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
4000fdc4: e4 06 20 1c ld [ %i0 + 0x1c ], %l2
the_chain = &the_jnode->info.directory.Entries;
/* Move to the first of the desired directory entries */
bytes_transferred = 0;
first_entry = iop->offset;
4000fdc8: e0 06 20 0c ld [ %i0 + 0xc ], %l0
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry
+ (count / sizeof( struct dirent )) * sizeof( struct dirent );
4000fdcc: 90 10 00 1a mov %i2, %o0
4000fdd0: 40 00 27 29 call 40019a74 <.udiv>
4000fdd4: 92 10 21 18 mov 0x118, %o1
4000fdd8: 83 2a 20 03 sll %o0, 3, %g1
4000fddc: 91 2a 20 05 sll %o0, 5, %o0
4000fde0: 82 00 40 08 add %g1, %o0, %g1
4000fde4: a3 28 60 03 sll %g1, 3, %l1
4000fde8: a2 24 40 01 sub %l1, %g1, %l1
4000fdec: a2 04 40 10 add %l1, %l0, %l1
/* The directory was not empty so try to move to the desired entry in chain*/
for (
4000fdf0: 80 a4 60 00 cmp %l1, 0
4000fdf4: 04 80 00 34 ble 4000fec4 <imfs_dir_read+0x118> <== NEVER TAKEN
4000fdf8: f4 04 a0 50 ld [ %l2 + 0x50 ], %i2
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
4000fdfc: a4 04 a0 54 add %l2, 0x54, %l2
current_entry = 0,
the_node = rtems_chain_first( the_chain );
current_entry < last_entry
&& !rtems_chain_is_tail( the_chain, the_node );
4000fe00: 80 a6 80 12 cmp %i2, %l2
4000fe04: 02 80 00 29 be 4000fea8 <imfs_dir_read+0xfc>
4000fe08: a6 10 20 00 clr %l3
4000fe0c: b6 10 20 00 clr %i3
the_node = rtems_chain_next( the_node )
) {
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
4000fe10: 10 80 00 08 b 4000fe30 <imfs_dir_read+0x84>
4000fe14: a8 10 21 18 mov 0x118, %l4
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry
+ (count / sizeof( struct dirent )) * sizeof( struct dirent );
/* The directory was not empty so try to move to the desired entry in chain*/
for (
4000fe18: 80 a4 40 1b cmp %l1, %i3
4000fe1c: 04 80 00 23 ble 4000fea8 <imfs_dir_read+0xfc> <== NEVER TAKEN
4000fe20: f4 06 80 00 ld [ %i2 ], %i2
current_entry = 0,
the_node = rtems_chain_first( the_chain );
current_entry < last_entry
&& !rtems_chain_is_tail( the_chain, the_node );
4000fe24: 80 a6 80 12 cmp %i2, %l2
4000fe28: 22 80 00 21 be,a 4000feac <imfs_dir_read+0x100>
4000fe2c: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
current_entry += sizeof( struct dirent ),
the_node = rtems_chain_next( the_node )
) {
if( current_entry >= first_entry ) {
4000fe30: 80 a4 00 1b cmp %l0, %i3
4000fe34: 34 bf ff f9 bg,a 4000fe18 <imfs_dir_read+0x6c>
4000fe38: b6 06 e1 18 add %i3, 0x118, %i3
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
4000fe3c: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1
current_entry += sizeof( struct dirent ),
the_node = rtems_chain_next( the_node )
) {
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
4000fe40: 85 3e e0 1f sra %i3, 0x1f, %g2
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
4000fe44: ba 06 a0 0c add %i2, 0xc, %i5
current_entry += sizeof( struct dirent ),
the_node = rtems_chain_next( the_node )
) {
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
4000fe48: c4 27 be f0 st %g2, [ %fp + -272 ]
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
4000fe4c: c2 27 be e8 st %g1, [ %fp + -280 ]
current_entry += sizeof( struct dirent ),
the_node = rtems_chain_next( the_node )
) {
if( current_entry >= first_entry ) {
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
4000fe50: f6 27 be f4 st %i3, [ %fp + -268 ]
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
4000fe54: 90 10 00 1d mov %i5, %o0
4000fe58: 40 00 08 1f call 40011ed4 <strlen>
4000fe5c: e8 37 be f8 sth %l4, [ %fp + -264 ]
strcpy( tmp_dirent.d_name, the_jnode->name );
4000fe60: 92 10 00 1d mov %i5, %o1
4000fe64: 94 02 20 01 add %o0, 1, %o2
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
4000fe68: d0 37 be fa sth %o0, [ %fp + -262 ]
strcpy( tmp_dirent.d_name, the_jnode->name );
4000fe6c: 40 00 05 06 call 40011284 <memcpy>
4000fe70: 90 07 be fc add %fp, -260, %o0
memcpy(
4000fe74: 90 06 40 13 add %i1, %l3, %o0
4000fe78: 92 07 be e8 add %fp, -280, %o1
4000fe7c: 40 00 05 02 call 40011284 <memcpy>
4000fe80: 94 10 21 18 mov 0x118, %o2
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset += sizeof( struct dirent );
4000fe84: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
#include "imfs.h"
#include <string.h>
#include <dirent.h>
ssize_t imfs_dir_read(
4000fe88: b6 06 e1 18 add %i3, 0x118, %i3
memcpy(
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset += sizeof( struct dirent );
4000fe8c: ba 80 e1 18 addcc %g3, 0x118, %i5
4000fe90: b8 40 a0 00 addx %g2, 0, %i4
4000fe94: f8 3e 20 08 std %i4, [ %i0 + 8 ]
bytes_transferred += sizeof( struct dirent );
4000fe98: a6 04 e1 18 add %l3, 0x118, %l3
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry
+ (count / sizeof( struct dirent )) * sizeof( struct dirent );
/* The directory was not empty so try to move to the desired entry in chain*/
for (
4000fe9c: 80 a4 40 1b cmp %l1, %i3
4000fea0: 14 bf ff e1 bg 4000fe24 <imfs_dir_read+0x78> <== NEVER TAKEN
4000fea4: f4 06 80 00 ld [ %i2 ], %i2
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
4000fea8: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
4000feac: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000feb0: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000feb4: 9f c0 40 00 call %g1
4000feb8: b0 10 00 13 mov %l3, %i0
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
return bytes_transferred;
}
4000febc: 81 c7 e0 08 ret
4000fec0: 81 e8 00 00 restore
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
the_chain = &the_jnode->info.directory.Entries;
/* Move to the first of the desired directory entries */
bytes_transferred = 0;
4000fec4: 10 bf ff f9 b 4000fea8 <imfs_dir_read+0xfc> <== NOT EXECUTED
4000fec8: a6 10 20 00 clr %l3 <== NOT EXECUTED
400283a0 <init_etc_passwd_group>:
/**
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
400283a0: 9d e3 bf a0 save %sp, -96, %sp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
400283a4: 03 10 01 a3 sethi %hi(0x40068c00), %g1
400283a8: c4 48 63 a0 ldsb [ %g1 + 0x3a0 ], %g2 ! 40068fa0 <etc_passwd_initted.7068>
400283ac: 80 a0 a0 00 cmp %g2, 0
400283b0: 02 80 00 04 be 400283c0 <init_etc_passwd_group+0x20>
400283b4: 84 10 20 01 mov 1, %g2
400283b8: 81 c7 e0 08 ret
400283bc: 81 e8 00 00 restore
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
400283c0: 92 10 21 ff mov 0x1ff, %o1
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
400283c4: c4 28 63 a0 stb %g2, [ %g1 + 0x3a0 ]
mkdir("/etc", 0777);
400283c8: 11 10 01 81 sethi %hi(0x40060400), %o0
400283cc: 7f ff 6f 80 call 400041cc <mkdir>
400283d0: 90 12 22 08 or %o0, 0x208, %o0 ! 40060608 <rtems_status_assoc+0x168>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
400283d4: 39 10 01 81 sethi %hi(0x40060400), %i4
400283d8: 3b 10 01 93 sethi %hi(0x40064c00), %i5
400283dc: 90 17 22 10 or %i4, 0x210, %o0
400283e0: 40 00 53 92 call 4003d228 <fopen>
400283e4: 92 17 60 a0 or %i5, 0xa0, %o1
400283e8: 80 a2 20 00 cmp %o0, 0
400283ec: 22 80 00 0d be,a 40028420 <init_etc_passwd_group+0x80>
400283f0: 90 17 22 10 or %i4, 0x210, %o0
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
400283f4: 40 00 51 2f call 4003c8b0 <fclose>
400283f8: 01 00 00 00 nop
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
400283fc: 39 10 01 81 sethi %hi(0x40060400), %i4
40028400: 92 17 60 a0 or %i5, 0xa0, %o1
40028404: 40 00 53 89 call 4003d228 <fopen>
40028408: 90 17 22 88 or %i4, 0x288, %o0
4002840c: 80 a2 20 00 cmp %o0, 0
40028410: 22 80 00 11 be,a 40028454 <init_etc_passwd_group+0xb4>
40028414: 90 17 22 88 or %i4, 0x288, %o0
fclose(fp);
40028418: 40 00 51 26 call 4003c8b0 <fclose>
4002841c: 91 e8 00 08 restore %g0, %o0, %o0
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
40028420: 13 10 01 78 sethi %hi(0x4005e000), %o1
40028424: 40 00 53 81 call 4003d228 <fopen>
40028428: 92 12 60 e8 or %o1, 0xe8, %o1 ! 4005e0e8 <rtems_rtc_shell_usage+0x4e8>
4002842c: b8 92 20 00 orcc %o0, 0, %i4
40028430: 02 bf ff f3 be 400283fc <init_etc_passwd_group+0x5c> <== NEVER TAKEN
40028434: 92 10 20 01 mov 1, %o1
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
40028438: 94 10 20 66 mov 0x66, %o2
4002843c: 96 10 00 1c mov %i4, %o3
40028440: 11 10 01 81 sethi %hi(0x40060400), %o0
40028444: 40 00 58 48 call 4003e564 <fwrite>
40028448: 90 12 22 20 or %o0, 0x220, %o0 ! 40060620 <rtems_status_assoc+0x180>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
4002844c: 10 bf ff ea b 400283f4 <init_etc_passwd_group+0x54>
40028450: 90 10 00 1c mov %i4, %o0
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
40028454: 13 10 01 78 sethi %hi(0x4005e000), %o1
40028458: 40 00 53 74 call 4003d228 <fopen>
4002845c: 92 12 60 e8 or %o1, 0xe8, %o1 ! 4005e0e8 <rtems_rtc_shell_usage+0x4e8>
40028460: b0 92 20 00 orcc %o0, 0, %i0
40028464: 02 bf ff d5 be 400283b8 <init_etc_passwd_group+0x18> <== NEVER TAKEN
40028468: 92 10 20 01 mov 1, %o1
fprintf( fp, "root:x:0:root\n"
4002846c: 11 10 01 81 sethi %hi(0x40060400), %o0
40028470: 94 10 20 2a mov 0x2a, %o2
40028474: 96 10 00 18 mov %i0, %o3
40028478: 40 00 58 3b call 4003e564 <fwrite>
4002847c: 90 12 22 98 or %o0, 0x298, %o0
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
40028480: 40 00 51 0c call 4003c8b0 <fclose>
40028484: 81 e8 00 00 restore
40006e44 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
40006e44: 9d e3 bf a0 save %sp, -96, %sp
if (tty->termios.c_iflag & ISTRIP)
40006e48: c2 06 60 30 ld [ %i1 + 0x30 ], %g1
40006e4c: 80 88 60 20 btst 0x20, %g1
40006e50: 32 80 00 02 bne,a 40006e58 <iproc+0x14> <== NEVER TAKEN
40006e54: b0 0e 20 7f and %i0, 0x7f, %i0 <== NOT EXECUTED
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
40006e58: 80 88 62 00 btst 0x200, %g1
40006e5c: 02 80 00 0d be 40006e90 <iproc+0x4c>
40006e60: 80 a6 20 0d cmp %i0, 0xd
c = tolower (c);
40006e64: 05 10 00 7d sethi %hi(0x4001f400), %g2
40006e68: c6 00 a3 60 ld [ %g2 + 0x360 ], %g3 ! 4001f760 <__ctype_ptr__>
40006e6c: 84 10 00 18 mov %i0, %g2
40006e70: b0 00 c0 18 add %g3, %i0, %i0
40006e74: c6 0e 20 01 ldub [ %i0 + 1 ], %g3
40006e78: 86 08 e0 03 and %g3, 3, %g3
40006e7c: 80 a0 e0 01 cmp %g3, 1
40006e80: 22 80 00 02 be,a 40006e88 <iproc+0x44>
40006e84: 84 00 a0 20 add %g2, 0x20, %g2
40006e88: b0 08 a0 ff and %g2, 0xff, %i0
if (c == '\r') {
40006e8c: 80 a6 20 0d cmp %i0, 0xd
40006e90: 02 80 00 1d be 40006f04 <iproc+0xc0>
40006e94: 80 a6 20 0a cmp %i0, 0xa
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
40006e98: 02 80 00 44 be 40006fa8 <iproc+0x164>
40006e9c: 80 a6 20 00 cmp %i0, 0
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
40006ea0: 32 80 00 1f bne,a 40006f1c <iproc+0xd8> <== ALWAYS TAKEN
40006ea4: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
40006ea8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
40006eac: 05 10 00 7d sethi %hi(0x4001f400), %g2
40006eb0: c4 00 a1 e8 ld [ %g2 + 0x1e8 ], %g2 ! 4001f5e8 <rtems_termios_cbufsize>
40006eb4: 84 00 bf ff add %g2, -1, %g2
40006eb8: 80 a0 40 02 cmp %g1, %g2
40006ebc: 1a 80 00 10 bcc 40006efc <iproc+0xb8> <== NEVER TAKEN
40006ec0: 01 00 00 00 nop
if (tty->termios.c_lflag & ECHO)
40006ec4: c4 06 60 3c ld [ %i1 + 0x3c ], %g2
40006ec8: 80 88 a0 08 btst 8, %g2
40006ecc: 12 80 00 3c bne 40006fbc <iproc+0x178> <== ALWAYS TAKEN
40006ed0: 84 00 60 01 add %g1, 1, %g2
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
40006ed4: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 <== NOT EXECUTED
40006ed8: f0 28 c0 01 stb %i0, [ %g3 + %g1 ] <== NOT EXECUTED
40006edc: c4 26 60 20 st %g2, [ %i1 + 0x20 ] <== NOT EXECUTED
}
return 0;
40006ee0: 81 c7 e0 08 ret <== NOT EXECUTED
40006ee4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
40006ee8: 80 a0 60 00 cmp %g1, 0
40006eec: 02 80 00 04 be 40006efc <iproc+0xb8>
40006ef0: 90 10 00 19 mov %i1, %o0
40006ef4: 7f ff ff 5f call 40006c70 <erase.part.2>
40006ef8: 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;
40006efc: 81 c7 e0 08 ret
40006f00: 91 e8 20 00 restore %g0, 0, %o0
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
40006f04: 80 88 60 80 btst 0x80, %g1
40006f08: 12 bf ff fd bne 40006efc <iproc+0xb8> <== NEVER TAKEN
40006f0c: 80 88 61 00 btst 0x100, %g1
return 0;
if (tty->termios.c_iflag & ICRNL)
40006f10: 32 80 00 02 bne,a 40006f18 <iproc+0xd4> <== ALWAYS TAKEN
40006f14: 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)) {
40006f18: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
40006f1c: 80 88 60 02 btst 2, %g1
40006f20: 22 bf ff e3 be,a 40006eac <iproc+0x68>
40006f24: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
if (c == tty->termios.c_cc[VERASE]) {
40006f28: c4 0e 60 43 ldub [ %i1 + 0x43 ], %g2
40006f2c: 80 a0 80 18 cmp %g2, %i0
40006f30: 22 bf ff ee be,a 40006ee8 <iproc+0xa4>
40006f34: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
40006f38: c4 0e 60 44 ldub [ %i1 + 0x44 ], %g2
40006f3c: 80 a0 80 18 cmp %g2, %i0
40006f40: 22 80 00 2d be,a 40006ff4 <iproc+0x1b0>
40006f44: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
40006f48: c4 0e 60 45 ldub [ %i1 + 0x45 ], %g2
40006f4c: 80 a0 80 18 cmp %g2, %i0
40006f50: 02 80 00 42 be 40007058 <iproc+0x214> <== NEVER TAKEN
40006f54: 80 a6 20 0a cmp %i0, 0xa
return 1;
} else if (c == '\n') {
40006f58: 02 80 00 33 be 40007024 <iproc+0x1e0>
40006f5c: 80 88 60 48 btst 0x48, %g1
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
40006f60: c4 0e 60 4c ldub [ %i1 + 0x4c ], %g2
40006f64: 80 a0 80 18 cmp %g2, %i0
40006f68: 02 80 00 07 be 40006f84 <iproc+0x140> <== NEVER TAKEN
40006f6c: 80 88 60 08 btst 8, %g1
40006f70: c4 0e 60 51 ldub [ %i1 + 0x51 ], %g2
40006f74: 80 a0 80 18 cmp %g2, %i0
40006f78: 32 bf ff cd bne,a 40006eac <iproc+0x68> <== ALWAYS TAKEN
40006f7c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
40006f80: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
40006f84: 12 80 00 18 bne 40006fe4 <iproc+0x1a0> <== NOT EXECUTED
40006f88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
40006f8c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
40006f90: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 <== NOT EXECUTED
40006f94: 84 00 60 01 add %g1, 1, %g2 <== NOT EXECUTED
40006f98: f0 28 c0 01 stb %i0, [ %g3 + %g1 ] <== NOT EXECUTED
40006f9c: c4 26 60 20 st %g2, [ %i1 + 0x20 ] <== NOT EXECUTED
return 1;
40006fa0: 81 c7 e0 08 ret <== NOT EXECUTED
40006fa4: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
40006fa8: 80 88 60 40 btst 0x40, %g1
40006fac: 32 bf ff db bne,a 40006f18 <iproc+0xd4> <== NEVER TAKEN
40006fb0: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
40006fb4: 10 bf ff da b 40006f1c <iproc+0xd8>
40006fb8: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
40006fbc: 90 10 00 18 mov %i0, %o0
40006fc0: 7f ff ff 0b call 40006bec <echo>
40006fc4: 92 10 00 19 mov %i1, %o1
40006fc8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
tty->cbuf[tty->ccount++] = c;
40006fcc: c6 06 60 1c ld [ %i1 + 0x1c ], %g3
40006fd0: 84 00 60 01 add %g1, 1, %g2
40006fd4: f0 28 c0 01 stb %i0, [ %g3 + %g1 ]
40006fd8: c4 26 60 20 st %g2, [ %i1 + 0x20 ]
}
return 0;
40006fdc: 81 c7 e0 08 ret
40006fe0: 91 e8 20 00 restore %g0, 0, %o0
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
40006fe4: 7f ff ff 02 call 40006bec <echo> <== NOT EXECUTED
40006fe8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
40006fec: 10 bf ff e9 b 40006f90 <iproc+0x14c> <== NOT EXECUTED
40006ff0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
40006ff4: 80 a0 a0 00 cmp %g2, 0
40006ff8: 02 bf ff c1 be 40006efc <iproc+0xb8> <== NEVER TAKEN
40006ffc: 80 88 60 08 btst 8, %g1
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
40007000: 02 80 00 18 be 40007060 <iproc+0x21c> <== NEVER TAKEN
40007004: 80 88 60 10 btst 0x10, %g1
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
40007008: 02 80 00 19 be 4000706c <iproc+0x228> <== NEVER TAKEN
4000700c: 90 10 00 19 mov %i1, %o0
40007010: 92 10 20 01 mov 1, %o1
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
40007014: 7f ff ff 17 call 40006c70 <erase.part.2>
40007018: b0 10 20 00 clr %i0
4000701c: 81 c7 e0 08 ret
40007020: 81 e8 00 00 restore
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
40007024: 22 80 00 06 be,a 4000703c <iproc+0x1f8> <== NEVER TAKEN
40007028: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
4000702c: 90 10 20 0a mov 0xa, %o0
40007030: 7f ff fe ef call 40006bec <echo>
40007034: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
40007038: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
4000703c: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
40007040: 86 10 20 0a mov 0xa, %g3
40007044: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
40007048: 82 00 60 01 inc %g1
4000704c: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
return 1;
40007050: 81 c7 e0 08 ret
40007054: 91 e8 20 01 restore %g0, 1, %o0
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
}
40007058: 81 c7 e0 08 ret <== NOT EXECUTED
4000705c: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
40007060: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
40007064: 81 c7 e0 08 ret <== NOT EXECUTED
40007068: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
4000706c: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
40007070: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40007074: 7f ff fe de call 40006bec <echo> <== NOT EXECUTED
40007078: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
4000707c: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
40007080: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
40007084: 02 bf ff 9e be 40006efc <iproc+0xb8> <== NOT EXECUTED
40007088: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
echo ('\n', tty);
4000708c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40007090: 7f ff fe d7 call 40006bec <echo> <== NOT EXECUTED
40007094: b0 10 20 00 clr %i0 <== NOT EXECUTED
40007098: 81 c7 e0 08 ret <== NOT EXECUTED
4000709c: 81 e8 00 00 restore <== NOT EXECUTED
4001cbb8 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
4001cbb8: 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() )
4001cbbc: 7f ff ff 10 call 4001c7fc <getpid>
4001cbc0: 01 00 00 00 nop
4001cbc4: 80 a2 00 18 cmp %o0, %i0
4001cbc8: 12 80 00 af bne 4001ce84 <killinfo+0x2cc>
4001cbcc: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
4001cbd0: 02 80 00 b3 be 4001ce9c <killinfo+0x2e4>
4001cbd4: 82 06 7f ff add %i1, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
4001cbd8: 80 a0 60 1f cmp %g1, 0x1f
4001cbdc: 18 80 00 b0 bgu 4001ce9c <killinfo+0x2e4>
4001cbe0: a1 2e 60 02 sll %i1, 2, %l0
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
4001cbe4: 31 10 00 82 sethi %hi(0x40020800), %i0
4001cbe8: a3 2e 60 04 sll %i1, 4, %l1
4001cbec: b0 16 20 20 or %i0, 0x20, %i0
4001cbf0: 84 24 40 10 sub %l1, %l0, %g2
4001cbf4: 84 06 00 02 add %i0, %g2, %g2
4001cbf8: c4 00 a0 08 ld [ %g2 + 8 ], %g2
4001cbfc: 80 a0 a0 01 cmp %g2, 1
4001cc00: 02 80 00 9f be 4001ce7c <killinfo+0x2c4>
4001cc04: 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 ) )
4001cc08: 02 80 00 41 be 4001cd0c <killinfo+0x154>
4001cc0c: 80 a6 60 08 cmp %i1, 8
4001cc10: 02 80 00 3f be 4001cd0c <killinfo+0x154>
4001cc14: 80 a6 60 0b cmp %i1, 0xb
4001cc18: 02 80 00 3d be 4001cd0c <killinfo+0x154>
4001cc1c: ba 10 20 01 mov 1, %i5
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
4001cc20: f2 27 bf f4 st %i1, [ %fp + -12 ]
siginfo->si_code = SI_USER;
4001cc24: fa 27 bf f8 st %i5, [ %fp + -8 ]
if ( !value ) {
4001cc28: 80 a6 a0 00 cmp %i2, 0
4001cc2c: 02 80 00 3e be 4001cd24 <killinfo+0x16c>
4001cc30: bb 2f 40 01 sll %i5, %g1, %i5
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
4001cc34: c2 06 80 00 ld [ %i2 ], %g1
4001cc38: 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;
4001cc3c: 03 10 00 80 sethi %hi(0x40020000), %g1
4001cc40: c4 00 62 b0 ld [ %g1 + 0x2b0 ], %g2 ! 400202b0 <_Thread_Dispatch_disable_level>
++level;
4001cc44: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
4001cc48: c4 20 62 b0 st %g2, [ %g1 + 0x2b0 ]
*/
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 );
4001cc4c: 11 10 00 7d sethi %hi(0x4001f400), %o0
4001cc50: 7f ff b0 ca call 40008f78 <_API_extensions_Add_post_switch>
4001cc54: 90 12 22 ac or %o0, 0x2ac, %o0 ! 4001f6ac <_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;
4001cc58: 03 10 00 81 sethi %hi(0x40020400), %g1
4001cc5c: d0 00 63 d0 ld [ %g1 + 0x3d0 ], %o0 ! 400207d0 <_Per_CPU_Information+0x10>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
4001cc60: c2 02 21 50 ld [ %o0 + 0x150 ], %g1
4001cc64: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1
4001cc68: 80 af 40 01 andncc %i5, %g1, %g0
4001cc6c: 12 80 00 17 bne 4001ccc8 <killinfo+0x110>
4001cc70: 09 10 00 82 sethi %hi(0x40020800), %g4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4001cc74: c2 01 21 ac ld [ %g4 + 0x1ac ], %g1 ! 400209ac <_POSIX_signals_Wait_queue>
4001cc78: 88 11 21 ac or %g4, 0x1ac, %g4
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
4001cc7c: 88 01 20 04 add %g4, 4, %g4
4001cc80: 80 a0 40 04 cmp %g1, %g4
4001cc84: 32 80 00 0d bne,a 4001ccb8 <killinfo+0x100>
4001cc88: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
4001cc8c: 10 80 00 28 b 4001cd2c <killinfo+0x174>
4001cc90: 03 10 00 7d sethi %hi(0x4001f400), %g1
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
4001cc94: c4 00 e0 d0 ld [ %g3 + 0xd0 ], %g2
4001cc98: 80 af 40 02 andncc %i5, %g2, %g0
4001cc9c: 12 80 00 0b bne 4001ccc8 <killinfo+0x110>
4001cca0: 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 ) {
4001cca4: 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 );
4001cca8: 80 a0 40 04 cmp %g1, %g4
4001ccac: 22 80 00 20 be,a 4001cd2c <killinfo+0x174> <== ALWAYS TAKEN
4001ccb0: 03 10 00 7d sethi %hi(0x4001f400), %g1
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
4001ccb4: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 ! 4001f430 <__clz_tab+0xc8><== NOT EXECUTED
4001ccb8: 80 8f 40 02 btst %i5, %g2
4001ccbc: 02 bf ff f6 be 4001cc94 <killinfo+0xdc>
4001ccc0: c6 00 61 50 ld [ %g1 + 0x150 ], %g3
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
4001ccc4: 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 ) ) {
4001ccc8: 92 10 00 19 mov %i1, %o1
4001cccc: 40 00 00 8b call 4001cef8 <_POSIX_signals_Unblock_thread>
4001ccd0: 94 07 bf f4 add %fp, -12, %o2
4001ccd4: 80 8a 20 ff btst 0xff, %o0
4001ccd8: 12 80 00 09 bne 4001ccfc <killinfo+0x144>
4001ccdc: 01 00 00 00 nop
/*
* We may have woken up a thread but we definitely need to post the
* signal to the process wide information set.
*/
_POSIX_signals_Set_process_signals( mask );
4001cce0: 40 00 00 7d call 4001ced4 <_POSIX_signals_Set_process_signals>
4001cce4: 90 10 00 1d mov %i5, %o0
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
4001cce8: a0 24 40 10 sub %l1, %l0, %l0
4001ccec: c2 06 00 10 ld [ %i0 + %l0 ], %g1
4001ccf0: 80 a0 60 02 cmp %g1, 2
4001ccf4: 02 80 00 4f be 4001ce30 <killinfo+0x278>
4001ccf8: 11 10 00 82 sethi %hi(0x40020800), %o0
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
_Thread_Enable_dispatch();
4001ccfc: 7f ff b8 f3 call 4000b0c8 <_Thread_Enable_dispatch>
4001cd00: b0 10 20 00 clr %i0
4001cd04: 81 c7 e0 08 ret
4001cd08: 81 e8 00 00 restore
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
return pthread_kill( pthread_self(), sig );
4001cd0c: 40 00 01 13 call 4001d158 <pthread_self>
4001cd10: 01 00 00 00 nop
4001cd14: 40 00 00 d2 call 4001d05c <pthread_kill>
4001cd18: 92 10 00 19 mov %i1, %o1
4001cd1c: 81 c7 e0 08 ret
4001cd20: 91 e8 00 08 restore %g0, %o0, %o0
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
4001cd24: 10 bf ff c6 b 4001cc3c <killinfo+0x84>
4001cd28: c0 27 bf fc clr [ %fp + -4 ]
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
4001cd2c: f8 08 60 dc ldub [ %g1 + 0xdc ], %i4
4001cd30: 1b 10 00 80 sethi %hi(0x40020000), %o5
4001cd34: b8 07 20 01 inc %i4
4001cd38: 9a 13 62 1c or %o5, 0x21c, %o5
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
4001cd3c: 90 10 20 00 clr %o0
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
4001cd40: 98 03 60 08 add %o5, 8, %o4
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
4001cd44: 17 04 00 00 sethi %hi(0x10000000), %o3
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
4001cd48: c2 03 40 00 ld [ %o5 ], %g1
4001cd4c: 80 a0 60 00 cmp %g1, 0
4001cd50: 22 80 00 31 be,a 4001ce14 <killinfo+0x25c> <== NEVER TAKEN
4001cd54: 9a 03 60 04 add %o5, 4, %o5 <== NOT EXECUTED
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
4001cd58: c2 00 60 04 ld [ %g1 + 4 ], %g1
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
4001cd5c: f6 10 60 10 lduh [ %g1 + 0x10 ], %i3
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
4001cd60: 80 a6 e0 00 cmp %i3, 0
4001cd64: 02 80 00 2b be 4001ce10 <killinfo+0x258>
4001cd68: f4 00 60 1c ld [ %g1 + 0x1c ], %i2
4001cd6c: 84 10 20 01 mov 1, %g2
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
4001cd70: 87 28 a0 02 sll %g2, 2, %g3
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
the_thread = (Thread_Control *) object_table[ index ];
4001cd74: c6 06 80 03 ld [ %i2 + %g3 ], %g3
if ( !the_thread )
4001cd78: 80 a0 e0 00 cmp %g3, 0
4001cd7c: 22 80 00 22 be,a 4001ce04 <killinfo+0x24c>
4001cd80: 84 00 a0 01 inc %g2
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
4001cd84: c8 00 e0 14 ld [ %g3 + 0x14 ], %g4
4001cd88: 80 a1 00 1c cmp %g4, %i4
4001cd8c: 38 80 00 1e bgu,a 4001ce04 <killinfo+0x24c>
4001cd90: 84 00 a0 01 inc %g2
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
4001cd94: de 00 e1 50 ld [ %g3 + 0x150 ], %o7
4001cd98: de 03 e0 d0 ld [ %o7 + 0xd0 ], %o7
4001cd9c: 80 af 40 0f andncc %i5, %o7, %g0
4001cda0: 22 80 00 19 be,a 4001ce04 <killinfo+0x24c>
4001cda4: 84 00 a0 01 inc %g2
*
* NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1
* so we never have to worry about deferencing a NULL
* interested thread.
*/
if ( the_thread->current_priority < interested_priority ) {
4001cda8: 80 a1 00 1c cmp %g4, %i4
4001cdac: 2a 80 00 14 bcs,a 4001cdfc <killinfo+0x244>
4001cdb0: b8 10 00 04 mov %g4, %i4
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
4001cdb4: 80 a2 20 00 cmp %o0, 0
4001cdb8: 22 80 00 13 be,a 4001ce04 <killinfo+0x24c> <== NEVER TAKEN
4001cdbc: 84 00 a0 01 inc %g2 <== NOT EXECUTED
4001cdc0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4001cdc4: 80 a0 60 00 cmp %g1, 0
4001cdc8: 22 80 00 0f be,a 4001ce04 <killinfo+0x24c> <== NEVER TAKEN
4001cdcc: 84 00 a0 01 inc %g2 <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
4001cdd0: de 00 e0 10 ld [ %g3 + 0x10 ], %o7
4001cdd4: 80 a3 e0 00 cmp %o7, 0
4001cdd8: 22 80 00 09 be,a 4001cdfc <killinfo+0x244>
4001cddc: b8 10 00 04 mov %g4, %i4
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
4001cde0: 80 88 40 0b btst %g1, %o3
4001cde4: 32 80 00 08 bne,a 4001ce04 <killinfo+0x24c>
4001cde8: 84 00 a0 01 inc %g2
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
4001cdec: 80 8b c0 0b btst %o7, %o3
4001cdf0: 22 80 00 05 be,a 4001ce04 <killinfo+0x24c>
4001cdf4: 84 00 a0 01 inc %g2
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
4001cdf8: b8 10 00 04 mov %g4, %i4
4001cdfc: 90 10 00 03 mov %g3, %o0
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
4001ce00: 84 00 a0 01 inc %g2
4001ce04: 80 a6 c0 02 cmp %i3, %g2
4001ce08: 1a bf ff db bcc 4001cd74 <killinfo+0x1bc>
4001ce0c: 87 28 a0 02 sll %g2, 2, %g3
4001ce10: 9a 03 60 04 add %o5, 4, %o5
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
4001ce14: 80 a3 40 0c cmp %o5, %o4
4001ce18: 32 bf ff cd bne,a 4001cd4c <killinfo+0x194>
4001ce1c: c2 03 40 00 ld [ %o5 ], %g1
}
}
}
}
if ( interested ) {
4001ce20: 80 a2 20 00 cmp %o0, 0
4001ce24: 12 bf ff aa bne 4001cccc <killinfo+0x114>
4001ce28: 92 10 00 19 mov %i1, %o1
4001ce2c: 30 bf ff ad b,a 4001cce0 <killinfo+0x128>
*/
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
4001ce30: 7f ff b0 b7 call 4000910c <_Chain_Get>
4001ce34: 90 12 21 a0 or %o0, 0x1a0, %o0
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
4001ce38: 92 92 20 00 orcc %o0, 0, %o1
4001ce3c: 02 80 00 1e be 4001ceb4 <killinfo+0x2fc>
4001ce40: c2 07 bf f4 ld [ %fp + -12 ], %g1
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
4001ce44: 11 10 00 82 sethi %hi(0x40020800), %o0
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
4001ce48: c2 22 60 08 st %g1, [ %o1 + 8 ]
4001ce4c: c2 07 bf f8 ld [ %fp + -8 ], %g1
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
4001ce50: 90 12 22 18 or %o0, 0x218, %o0
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
4001ce54: c2 22 60 0c st %g1, [ %o1 + 0xc ]
4001ce58: c2 07 bf fc ld [ %fp + -4 ], %g1
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
4001ce5c: 90 02 00 10 add %o0, %l0, %o0
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
4001ce60: c2 22 60 10 st %g1, [ %o1 + 0x10 ]
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
4001ce64: 7f ff b0 9f call 400090e0 <_Chain_Append>
4001ce68: b0 10 20 00 clr %i0
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
_Thread_Enable_dispatch();
4001ce6c: 7f ff b8 97 call 4000b0c8 <_Thread_Enable_dispatch>
4001ce70: 01 00 00 00 nop
4001ce74: 81 c7 e0 08 ret
4001ce78: 81 e8 00 00 restore
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
4001ce7c: 81 c7 e0 08 ret
4001ce80: 91 e8 20 00 restore %g0, 0, %o0
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
4001ce84: 7f ff ce af call 40010940 <__errno>
4001ce88: b0 10 3f ff mov -1, %i0
4001ce8c: 82 10 20 03 mov 3, %g1
4001ce90: c2 22 00 00 st %g1, [ %o0 ]
4001ce94: 81 c7 e0 08 ret
4001ce98: 81 e8 00 00 restore
*/
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
4001ce9c: 7f ff ce a9 call 40010940 <__errno>
4001cea0: b0 10 3f ff mov -1, %i0
4001cea4: 82 10 20 16 mov 0x16, %g1
4001cea8: c2 22 00 00 st %g1, [ %o0 ]
4001ceac: 81 c7 e0 08 ret
4001ceb0: 81 e8 00 00 restore
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
_Thread_Enable_dispatch();
4001ceb4: 7f ff b8 85 call 4000b0c8 <_Thread_Enable_dispatch>
4001ceb8: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EAGAIN );
4001cebc: 7f ff ce a1 call 40010940 <__errno>
4001cec0: 01 00 00 00 nop
4001cec4: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
4001cec8: c2 22 00 00 st %g1, [ %o0 ]
4001cecc: 81 c7 e0 08 ret
4001ced0: 81 e8 00 00 restore
40004ad4 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
40004ad4: 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()))
40004ad8: 03 10 00 81 sethi %hi(0x40020400), %g1
40004adc: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 400207b8 <_System_state_Current>
40004ae0: 80 a0 60 03 cmp %g1, 3
40004ae4: 02 80 00 04 be 40004af4 <libc_wrapup+0x20> <== ALWAYS TAKEN
40004ae8: 3b 10 00 7d sethi %hi(0x4001f400), %i5
40004aec: 81 c7 e0 08 ret <== NOT EXECUTED
40004af0: 81 e8 00 00 restore <== NOT EXECUTED
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
40004af4: 05 10 00 7a sethi %hi(0x4001e800), %g2
40004af8: c2 07 63 68 ld [ %i5 + 0x368 ], %g1
40004afc: f8 00 a2 a8 ld [ %g2 + 0x2a8 ], %i4
40004b00: 80 a0 40 1c cmp %g1, %i4
40004b04: 02 80 00 05 be 40004b18 <libc_wrapup+0x44>
40004b08: 01 00 00 00 nop
_wrapup_reent(_global_impure_ptr);
40004b0c: 40 00 32 bc call 400115fc <_wrapup_reent>
40004b10: 90 10 00 1c mov %i4, %o0
/* Don't reclaim this one, just in case we do printfs
* on the way out to ROM.
*/
_reclaim_reent(&libc_global_reent);
#endif
_REENT = _global_impure_ptr;
40004b14: f8 27 63 68 st %i4, [ %i5 + 0x368 ]
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
40004b18: 40 00 2f dc call 40010a88 <fclose>
40004b1c: d0 07 20 04 ld [ %i4 + 4 ], %o0
fclose (stdout);
40004b20: c2 07 63 68 ld [ %i5 + 0x368 ], %g1
40004b24: 40 00 2f d9 call 40010a88 <fclose>
40004b28: d0 00 60 08 ld [ %g1 + 8 ], %o0
fclose (stderr);
40004b2c: c2 07 63 68 ld [ %i5 + 0x368 ], %g1
40004b30: f0 00 60 0c ld [ %g1 + 0xc ], %i0
40004b34: 40 00 2f d5 call 40010a88 <fclose>
40004b38: 81 e8 00 00 restore
40004570 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
40004570: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
MSBUMP(malloc_calls, 1);
40004574: 03 10 00 80 sethi %hi(0x40020000), %g1
40004578: 82 10 61 30 or %g1, 0x130, %g1 ! 40020130 <rtems_malloc_statistics>
4000457c: c4 00 60 04 ld [ %g1 + 4 ], %g2
40004580: 84 00 a0 01 inc %g2
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
40004584: 7f ff ff b8 call 40004464 <malloc_deferred_frees_process>
40004588: c4 20 60 04 st %g2, [ %g1 + 4 ]
/*
* Validate the parameters
*/
if ( !size )
4000458c: 80 a6 20 00 cmp %i0, 0
40004590: 02 80 00 25 be 40004624 <malloc+0xb4>
40004594: 03 10 00 81 sethi %hi(0x40020400), %g1
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
40004598: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 400207b8 <_System_state_Current>
4000459c: 80 a0 60 03 cmp %g1, 3
400045a0: 02 80 00 1c be 40004610 <malloc+0xa0>
400045a4: 39 10 00 7d sethi %hi(0x4001f400), %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 );
400045a8: d0 07 21 60 ld [ %i4 + 0x160 ], %o0 ! 4001f560 <RTEMS_Malloc_Heap>
400045ac: 92 10 00 18 mov %i0, %o1
400045b0: 94 10 20 00 clr %o2
400045b4: 40 00 17 ac call 4000a464 <_Protected_heap_Allocate_aligned_with_boundary>
400045b8: 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 ) {
400045bc: ba 92 20 00 orcc %o0, 0, %i5
400045c0: 02 80 00 1c be 40004630 <malloc+0xc0>
400045c4: d0 07 21 60 ld [ %i4 + 0x160 ], %o0
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
400045c8: 03 10 00 7f sethi %hi(0x4001fc00), %g1
400045cc: c2 00 60 8c ld [ %g1 + 0x8c ], %g1 ! 4001fc8c <rtems_malloc_dirty_helper>
400045d0: 80 a0 60 00 cmp %g1, 0
400045d4: 02 80 00 04 be 400045e4 <malloc+0x74>
400045d8: 90 10 00 1d mov %i5, %o0
(*rtems_malloc_dirty_helper)( return_this, size );
400045dc: 9f c0 40 00 call %g1
400045e0: 92 10 00 18 mov %i0, %o1
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
400045e4: 03 10 00 7f sethi %hi(0x4001fc00), %g1
400045e8: c2 00 60 90 ld [ %g1 + 0x90 ], %g1 ! 4001fc90 <rtems_malloc_statistics_helpers>
400045ec: 80 a0 60 00 cmp %g1, 0
400045f0: 22 80 00 06 be,a 40004608 <malloc+0x98>
400045f4: b0 10 00 1d mov %i5, %i0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
400045f8: c2 00 60 04 ld [ %g1 + 4 ], %g1
400045fc: 9f c0 40 00 call %g1
40004600: 90 10 00 1d mov %i5, %o0
return return_this;
}
40004604: b0 10 00 1d mov %i5, %i0
40004608: 81 c7 e0 08 ret
4000460c: 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() )
40004610: 7f ff ff 88 call 40004430 <malloc_is_system_state_OK>
40004614: 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()) &&
40004618: 80 8a 20 ff btst 0xff, %o0
4000461c: 12 bf ff e3 bne 400045a8 <malloc+0x38> <== ALWAYS TAKEN
40004620: 01 00 00 00 nop
/*
* Validate the parameters
*/
if ( !size )
return (void *) 0;
40004624: ba 10 20 00 clr %i5 ! 0 <PROM_START>
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
return return_this;
}
40004628: 81 c7 e0 08 ret
4000462c: 91 e8 00 1d restore %g0, %i5, %o0
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
return_this = (*rtems_malloc_extend_handler)( RTEMS_Malloc_Heap, size );
40004630: 03 10 00 75 sethi %hi(0x4001d400), %g1
40004634: c2 00 62 60 ld [ %g1 + 0x260 ], %g1 ! 4001d660 <rtems_malloc_extend_handler>
40004638: 9f c0 40 00 call %g1
4000463c: 92 10 00 18 mov %i0, %o1
if ( !return_this ) {
40004640: ba 92 20 00 orcc %o0, 0, %i5
40004644: 12 bf ff e2 bne 400045cc <malloc+0x5c> <== NEVER TAKEN
40004648: 03 10 00 7f sethi %hi(0x4001fc00), %g1
errno = ENOMEM;
4000464c: 40 00 30 bd call 40010940 <__errno>
40004650: b0 10 00 1d mov %i5, %i0
40004654: 82 10 20 0c mov 0xc, %g1
40004658: c2 22 00 00 st %g1, [ %o0 ]
4000465c: 81 c7 e0 08 ret
40004660: 81 e8 00 00 restore
4000eecc <memfile_alloc_block>:
* Allocate a block for an in-memory file.
*/
int memfile_blocks_allocated = 0;
void *memfile_alloc_block(void)
{
4000eecc: 9d e3 bf a0 save %sp, -96, %sp
void *memory;
memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);
4000eed0: 03 10 00 7f sethi %hi(0x4001fc00), %g1
4000eed4: d2 00 61 28 ld [ %g1 + 0x128 ], %o1 ! 4001fd28 <imfs_memfile_bytes_per_block>
4000eed8: 7f ff d4 1d call 40003f4c <calloc>
4000eedc: 90 10 20 01 mov 1, %o0
if ( memory )
4000eee0: b0 92 20 00 orcc %o0, 0, %i0
4000eee4: 02 80 00 05 be 4000eef8 <memfile_alloc_block+0x2c> <== NEVER TAKEN
4000eee8: 03 10 00 7f sethi %hi(0x4001fc00), %g1
memfile_blocks_allocated++;
4000eeec: c4 00 62 3c ld [ %g1 + 0x23c ], %g2 ! 4001fe3c <memfile_blocks_allocated>
4000eef0: 84 00 a0 01 inc %g2
4000eef4: c4 20 62 3c st %g2, [ %g1 + 0x23c ]
return memory;
}
4000eef8: 81 c7 e0 08 ret
4000eefc: 81 e8 00 00 restore
4000f444 <memfile_free_blocks_in_table>:
*/
static void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
4000f444: 9d e3 bf a0 save %sp, -96, %sp
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
4000f448: 80 a6 60 00 cmp %i1, 0
4000f44c: 04 80 00 0f ble 4000f488 <memfile_free_blocks_in_table+0x44><== NEVER TAKEN
4000f450: d0 06 00 00 ld [ %i0 ], %o0
4000f454: ba 10 00 08 mov %o0, %i5
4000f458: b8 10 20 00 clr %i4
if ( b[i] ) {
4000f45c: d0 07 40 00 ld [ %i5 ], %o0
4000f460: 80 a2 20 00 cmp %o0, 0
4000f464: 02 80 00 05 be 4000f478 <memfile_free_blocks_in_table+0x34>
4000f468: b8 07 20 01 inc %i4
memfile_free_block( b[i] );
4000f46c: 7f ff ff ed call 4000f420 <memfile_free_block>
4000f470: 01 00 00 00 nop
b[i] = 0;
4000f474: c0 27 40 00 clr [ %i5 ]
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
4000f478: 80 a7 00 19 cmp %i4, %i1
4000f47c: 12 bf ff f8 bne 4000f45c <memfile_free_blocks_in_table+0x18>
4000f480: ba 07 60 04 add %i5, 4, %i5
4000f484: d0 06 00 00 ld [ %i0 ], %o0
/*
* Now that all the blocks in the block table are free, we can
* free the block table itself.
*/
memfile_free_block( *block_table );
4000f488: 7f ff ff e6 call 4000f420 <memfile_free_block>
4000f48c: 01 00 00 00 nop
*block_table = 0;
4000f490: c0 26 00 00 clr [ %i0 ]
4000f494: 81 c7 e0 08 ret
4000f498: 81 e8 00 00 restore
4000fad8 <memfile_ftruncate>:
int memfile_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
4000fad8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
4000fadc: fa 06 20 1c ld [ %i0 + 0x1c ], %i5 <== NOT EXECUTED
* 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 )
4000fae0: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED
4000fae4: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED
4000fae8: 06 80 00 11 bl 4000fb2c <memfile_ftruncate+0x54> <== NOT EXECUTED
4000faec: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000faf0: 22 80 00 0b be,a 4000fb1c <memfile_ftruncate+0x44> <== NOT EXECUTED
4000faf4: c2 07 60 54 ld [ %i5 + 0x54 ], %g1 <== NOT EXECUTED
/*
* 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;
4000faf8: f2 27 60 50 st %i1, [ %i5 + 0x50 ] <== NOT EXECUTED
4000fafc: f4 27 60 54 st %i2, [ %i5 + 0x54 ] <== NOT EXECUTED
IMFS_update_atime( the_jnode );
4000fb00: 90 07 bf f8 add %fp, -8, %o0 <== NOT EXECUTED
4000fb04: 7f ff d1 eb call 400042b0 <gettimeofday> <== NOT EXECUTED
4000fb08: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000fb0c: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
4000fb10: c2 27 60 40 st %g1, [ %i5 + 0x40 ] <== NOT EXECUTED
return 0;
}
4000fb14: 81 c7 e0 08 ret <== NOT EXECUTED
4000fb18: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
* 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 )
4000fb1c: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED
4000fb20: 3a bf ff f7 bcc,a 4000fafc <memfile_ftruncate+0x24> <== NOT EXECUTED
4000fb24: f2 27 60 50 st %i1, [ %i5 + 0x50 ] <== NOT EXECUTED
return IMFS_memfile_extend( the_jnode, true, length );
4000fb28: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000fb2c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4000fb30: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4000fb34: 7f ff fe c4 call 4000f644 <IMFS_memfile_extend> <== NOT EXECUTED
4000fb38: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
4000fb3c: 81 c7 e0 08 ret <== NOT EXECUTED
4000fb40: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4000fa5c <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
4000fa5c: 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)
4000fa60: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4000fa64: 80 88 60 04 btst 4, %g1
4000fa68: 02 80 00 07 be 4000fa84 <memfile_open+0x28>
4000fa6c: d0 06 20 1c ld [ %i0 + 0x1c ], %o0
4000fa70: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
4000fa74: c2 00 40 00 ld [ %g1 ], %g1
4000fa78: 80 a0 60 05 cmp %g1, 5
4000fa7c: 22 80 00 04 be,a 4000fa8c <memfile_open+0x30> <== NEVER TAKEN
4000fa80: d8 02 20 54 ld [ %o0 + 0x54 ], %o4 <== NOT EXECUTED
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
return 0;
4000fa84: 81 c7 e0 08 ret
4000fa88: 91 e8 20 00 restore %g0, 0, %o0
* Perform 'copy on write' for linear files
*/
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
4000fa8c: d6 02 20 58 ld [ %o0 + 0x58 ], %o3 <== NOT EXECUTED
the_jnode->control = &IMFS_node_control_memfile;
4000fa90: 03 10 00 79 sethi %hi(0x4001e400), %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
4000fa94: 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;
4000fa98: 82 10 60 d4 or %g1, 0xd4, %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
4000fa9c: c0 22 20 54 clr [ %o0 + 0x54 ] <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
4000faa0: c0 22 20 58 clr [ %o0 + 0x58 ] <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->control = &IMFS_node_control_memfile;
4000faa4: c2 22 20 4c st %g1, [ %o0 + 0x4c ] <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
4000faa8: c0 22 20 5c clr [ %o0 + 0x5c ] <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
4000faac: 80 a3 20 00 cmp %o4, 0 <== NOT EXECUTED
4000fab0: 02 bf ff f5 be 4000fa84 <memfile_open+0x28> <== NOT EXECUTED
4000fab4: c0 22 20 60 clr [ %o0 + 0x60 ] <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
4000fab8: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000fabc: 7f ff ff 53 call 4000f808 <IMFS_memfile_write> <== NOT EXECUTED
4000fac0: 94 10 20 00 clr %o2 <== NOT EXECUTED
return -1;
4000fac4: 90 38 00 08 xnor %g0, %o0, %o0 <== NOT EXECUTED
4000fac8: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
4000facc: b0 40 3f ff addx %g0, -1, %i0 <== NOT EXECUTED
}
return 0;
}
4000fad0: 81 c7 e0 08 ret <== NOT EXECUTED
4000fad4: 81 e8 00 00 restore <== NOT EXECUTED
40004788 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
40004788: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
4000478c: 80 a6 e0 01 cmp %i3, 1
40004790: 18 80 00 9a bgu 400049f8 <mount+0x270>
40004794: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
40004798: 40 00 22 e5 call 4000d32c <rtems_filesystem_get_mount_handler>
4000479c: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
400047a0: a4 92 20 00 orcc %o0, 0, %l2
400047a4: 02 80 00 95 be 400049f8 <mount+0x270>
400047a8: 80 a6 60 00 cmp %i1, 0
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
400047ac: 02 80 00 7b be 40004998 <mount+0x210>
400047b0: 01 00 00 00 nop
}
return rv;
}
int mount(
400047b4: 40 00 35 c8 call 40011ed4 <strlen>
400047b8: 90 10 00 19 mov %i1, %o0
400047bc: a6 02 20 01 add %o0, 1, %l3
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
400047c0: 40 00 35 c5 call 40011ed4 <strlen>
400047c4: 90 10 00 1a mov %i2, %o0
}
return rv;
}
int mount(
400047c8: aa 10 00 19 mov %i1, %l5
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
400047cc: ba 10 00 08 mov %o0, %i5
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
400047d0: 80 a6 20 00 cmp %i0, 0
400047d4: 02 80 00 7a be 400049bc <mount+0x234>
400047d8: a8 02 20 01 add %o0, 1, %l4
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
400047dc: ba 07 40 13 add %i5, %l3, %i5
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
400047e0: 40 00 35 bd call 40011ed4 <strlen>
400047e4: 90 10 00 18 mov %i0, %o0
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
400047e8: 92 07 60 65 add %i5, 0x65, %o1
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
400047ec: a2 02 20 01 add %o0, 1, %l1
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
400047f0: 90 10 20 01 mov 1, %o0
400047f4: 7f ff fd d6 call 40003f4c <calloc>
400047f8: 92 02 40 11 add %o1, %l1, %o1
if ( mt_entry != NULL ) {
400047fc: ba 92 20 00 orcc %o0, 0, %i5
40004800: 02 80 00 78 be 400049e0 <mount+0x258> <== NEVER TAKEN
40004804: a0 07 60 64 add %i5, 0x64, %l0
rtems_filesystem_global_location_t *mt_fs_root =
(rtems_filesystem_global_location_t *)
((char *) mt_entry + sizeof( *mt_entry ));
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
memcpy( str, filesystemtype, filesystemtype_size );
40004808: 92 10 00 1a mov %i2, %o1
4000480c: 90 10 00 10 mov %l0, %o0
40004810: 40 00 32 9d call 40011284 <memcpy>
40004814: 94 10 00 14 mov %l4, %o2
mt_entry->type = str;
40004818: e0 27 60 34 st %l0, [ %i5 + 0x34 ]
+ filesystemtype_size + source_size + target_size
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
if ( mt_entry != NULL ) {
rtems_filesystem_global_location_t *mt_fs_root =
4000481c: ac 07 60 40 add %i5, 0x40, %l6
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
if ( source_or_null != NULL ) {
40004820: 80 a6 20 00 cmp %i0, 0
40004824: 02 80 00 08 be 40004844 <mount+0xbc>
40004828: b4 04 00 14 add %l0, %l4, %i2
memcpy( str, source_or_null, source_size );
4000482c: 90 10 00 1a mov %i2, %o0
40004830: 92 10 00 18 mov %i0, %o1
40004834: 40 00 32 94 call 40011284 <memcpy>
40004838: 94 10 00 11 mov %l1, %o2
mt_entry->dev = str;
4000483c: f4 27 60 38 st %i2, [ %i5 + 0x38 ]
str += source_size;
40004840: b4 06 80 11 add %i2, %l1, %i2
}
memcpy( str, target, target_size );
40004844: 92 10 00 15 mov %l5, %o1
40004848: 94 10 00 13 mov %l3, %o2
4000484c: 40 00 32 8e call 40011284 <memcpy>
40004850: 90 10 00 1a mov %i2, %o0
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
40004854: 82 10 20 01 mov 1, %g1
40004858: 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;
4000485c: 03 10 00 77 sethi %hi(0x4001dc00), %g1
40004860: 82 10 63 54 or %g1, 0x354, %g1 ! 4001df54 <rtems_filesystem_default_pathconf>
40004864: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->location.mt_entry = mt_entry;
mt_fs_root->reference_count = 1;
40004868: 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 );
4000486c: 90 07 60 14 add %i5, 0x14, %o0
40004870: 92 10 00 16 mov %l6, %o1
40004874: 94 10 20 01 mov 1, %o2
40004878: 96 10 20 24 mov 0x24, %o3
4000487c: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
mt_entry->dev = str;
str += source_size;
}
memcpy( str, target, target_size );
mt_entry->target = str;
40004880: f4 27 60 30 st %i2, [ %i5 + 0x30 ]
str += target_size;
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
40004884: ec 27 60 24 st %l6, [ %i5 + 0x24 ]
40004888: 40 00 12 31 call 4000914c <_Chain_Initialize>
4000488c: fa 27 60 54 st %i5, [ %i5 + 0x54 ]
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
rv = (*fsmount_me_h)( mt_entry, data );
40004890: 90 10 00 1d mov %i5, %o0
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
40004894: b6 0e e0 01 and %i3, 1, %i3
rv = (*fsmount_me_h)( mt_entry, data );
40004898: 92 10 00 1c mov %i4, %o1
4000489c: 9f c4 80 00 call %l2
400048a0: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
if ( rv == 0 ) {
400048a4: b0 92 20 00 orcc %o0, 0, %i0
400048a8: 12 80 00 29 bne 4000494c <mount+0x1c4>
400048ac: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
400048b0: 02 80 00 58 be 40004a10 <mount+0x288>
400048b4: 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 =
400048b8: 94 10 20 1f mov 0x1f, %o2
400048bc: 40 00 02 e8 call 4000545c <rtems_filesystem_eval_path_start>
400048c0: 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;
400048c4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
return (*mt_entry->ops->are_nodes_equal_h)(
400048c8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400048cc: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
400048d0: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1
400048d4: 9f c0 40 00 call %g1
400048d8: 01 00 00 00 nop
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
400048dc: 80 8a 20 ff btst 0xff, %o0
400048e0: 12 80 00 70 bne 40004aa0 <mount+0x318>
400048e4: 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(
400048e8: 40 00 03 d6 call 40005840 <rtems_filesystem_location_copy_and_detach>
400048ec: 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 );
400048f0: 40 00 04 63 call 40005a7c <rtems_filesystem_location_transform_to_global>
400048f4: 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 );
400048f8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
400048fc: 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 );
40004900: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
mt_entry->mt_point_node = mt_point_node;
40004904: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40004908: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
4000490c: 9f c0 40 00 call %g1
40004910: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40004914: b0 92 20 00 orcc %o0, 0, %i0
40004918: 22 80 00 11 be,a 4000495c <mount+0x1d4>
4000491c: 39 10 00 80 sethi %hi(0x40020000), %i4
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
40004920: 40 00 03 fd call 40005914 <rtems_filesystem_global_location_release>
40004924: 90 10 00 1c mov %i4, %o0
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40004928: 40 00 03 0d call 4000555c <rtems_filesystem_eval_path_cleanup>
4000492c: 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 ) {
40004930: 80 a6 20 00 cmp %i0, 0
40004934: 02 80 00 59 be 40004a98 <mount+0x310>
40004938: 01 00 00 00 nop
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
4000493c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40004940: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
40004944: 9f c0 40 00 call %g1
40004948: 90 10 00 1d mov %i5, %o0
}
}
if ( rv != 0 ) {
free( mt_entry );
4000494c: 7f ff fe 2f call 40004208 <free>
40004950: 90 10 00 1d mov %i5, %o0
errno = EINVAL;
rv = -1;
}
return rv;
}
40004954: 81 c7 e0 08 ret
40004958: 81 e8 00 00 restore
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000495c: d0 07 21 2c ld [ %i4 + 0x12c ], %o0
40004960: 92 10 20 00 clr %o1
40004964: 40 00 0f 0a call 4000858c <rtems_semaphore_obtain>
40004968: 94 10 20 00 clr %o2
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4000496c: d0 07 21 2c ld [ %i4 + 0x12c ], %o0
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
40004970: 03 10 00 7d sethi %hi(0x4001f400), %g1
40004974: 82 10 61 d0 or %g1, 0x1d0, %g1 ! 4001f5d0 <rtems_filesystem_mount_table>
40004978: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
4000497c: 86 00 60 04 add %g1, 4, %g3
40004980: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
40004984: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
40004988: fa 20 80 00 st %i5, [ %g2 ]
4000498c: 40 00 0f 4f call 400086c8 <rtems_semaphore_release>
40004990: c4 27 60 04 st %g2, [ %i5 + 4 ]
40004994: 30 bf ff e5 b,a 40004928 <mount+0x1a0>
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
40004998: 40 00 35 4f call 40011ed4 <strlen>
4000499c: 90 10 00 1a mov %i2, %o0
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
400049a0: 2b 10 00 77 sethi %hi(0x4001dc00), %l5
400049a4: a6 10 20 02 mov 2, %l3
400049a8: aa 15 63 50 or %l5, 0x350, %l5
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
400049ac: ba 10 00 08 mov %o0, %i5
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
400049b0: 80 a6 20 00 cmp %i0, 0
400049b4: 12 bf ff 8a bne 400047dc <mount+0x54> <== NEVER TAKEN
400049b8: a8 02 20 01 add %o0, 1, %l4
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
400049bc: ba 07 40 13 add %i5, %l3, %i5
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
400049c0: a2 10 20 00 clr %l1
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
400049c4: 92 07 60 65 add %i5, 0x65, %o1
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
400049c8: 90 10 20 01 mov 1, %o0
400049cc: 7f ff fd 60 call 40003f4c <calloc>
400049d0: 92 02 40 11 add %o1, %l1, %o1
if ( mt_entry != NULL ) {
400049d4: ba 92 20 00 orcc %o0, 0, %i5
400049d8: 12 bf ff 8c bne 40004808 <mount+0x80> <== ALWAYS TAKEN
400049dc: a0 07 60 64 add %i5, 0x64, %l0
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
400049e0: 40 00 2f d8 call 40010940 <__errno> <== NOT EXECUTED
400049e4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400049e8: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
400049ec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400049f0: 81 c7 e0 08 ret <== NOT EXECUTED
400049f4: 81 e8 00 00 restore <== NOT EXECUTED
} else {
errno = EINVAL;
rv = -1;
}
} else {
errno = EINVAL;
400049f8: 40 00 2f d2 call 40010940 <__errno>
400049fc: b0 10 3f ff mov -1, %i0
40004a00: 82 10 20 16 mov 0x16, %g1
40004a04: c2 22 00 00 st %g1, [ %o0 ]
40004a08: 81 c7 e0 08 ret
40004a0c: 81 e8 00 00 restore
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
40004a10: 39 10 00 80 sethi %hi(0x40020000), %i4
40004a14: d0 07 21 2c ld [ %i4 + 0x12c ], %o0 ! 4002012c <rtems_libio_semaphore>
40004a18: 92 10 20 00 clr %o1
40004a1c: 40 00 0e dc call 4000858c <rtems_semaphore_obtain>
40004a20: 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;
40004a24: 03 10 00 7d sethi %hi(0x4001f400), %g1
)
{
int rv = 0;
rtems_filesystem_mt_lock();
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
40004a28: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 4001f5d0 <rtems_filesystem_mount_table>
40004a2c: 82 10 61 d0 or %g1, 0x1d0, %g1
40004a30: 86 00 60 04 add %g1, 4, %g3
40004a34: 80 a0 80 03 cmp %g2, %g3
40004a38: 12 80 00 1f bne 40004ab4 <mount+0x32c> <== NEVER TAKEN
40004a3c: 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;
40004a40: c6 00 60 08 ld [ %g1 + 8 ], %g3
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
40004a44: d0 07 21 2c ld [ %i4 + 0x12c ], %o0
the_node->next = tail;
40004a48: c4 27 40 00 st %g2, [ %i5 ]
tail->previous = the_node;
40004a4c: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
40004a50: fa 20 c0 00 st %i5, [ %g3 ]
40004a54: 40 00 0f 1d call 400086c8 <rtems_semaphore_release>
40004a58: c6 27 60 04 st %g3, [ %i5 + 4 ]
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
40004a5c: 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 =
40004a60: 40 00 03 cd call 40005994 <rtems_filesystem_global_location_obtain>
40004a64: 90 10 00 1d mov %i5, %o0
40004a68: 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 =
40004a6c: 40 00 03 ca call 40005994 <rtems_filesystem_global_location_obtain>
40004a70: 90 10 00 1d mov %i5, %o0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
40004a74: 39 10 00 7d sethi %hi(0x4001f400), %i4
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_t *new_fs_current =
40004a78: ba 10 00 08 mov %o0, %i5
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
40004a7c: d0 07 21 f0 ld [ %i4 + 0x1f0 ], %o0
40004a80: 92 10 00 1b mov %i3, %o1
40004a84: 40 00 03 ba call 4000596c <rtems_filesystem_global_location_assign>
40004a88: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_fs_root
);
rtems_filesystem_global_location_assign(
40004a8c: d0 07 21 f0 ld [ %i4 + 0x1f0 ], %o0
40004a90: 40 00 03 b7 call 4000596c <rtems_filesystem_global_location_assign>
40004a94: 92 10 00 1d mov %i5, %o1
40004a98: 81 c7 e0 08 ret
40004a9c: 81 e8 00 00 restore
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
}
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
40004aa0: 90 07 bf c8 add %fp, -56, %o0
40004aa4: 92 10 20 10 mov 0x10, %o1
40004aa8: 40 00 01 b1 call 4000516c <rtems_filesystem_eval_path_error>
40004aac: b0 10 3f ff mov -1, %i0
40004ab0: 30 bf ff 9e b,a 40004928 <mount+0x1a0>
rtems_chain_append_unprotected(
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
} else {
errno = EINVAL;
40004ab4: 40 00 2f a3 call 40010940 <__errno> <== NOT EXECUTED
40004ab8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40004abc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40004ac0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40004ac4: 40 00 0f 01 call 400086c8 <rtems_semaphore_release> <== NOT EXECUTED
40004ac8: d0 07 21 2c ld [ %i4 + 0x12c ], %o0 <== NOT EXECUTED
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40004acc: 10 bf ff 9d b 40004940 <mount+0x1b8> <== NOT EXECUTED
40004ad0: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
400099b4 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
400099b4: 9d e3 bf a0 save %sp, -96, %sp
int rv = -1;
if (target != NULL) {
400099b8: 90 96 60 00 orcc %i1, 0, %o0
400099bc: 02 80 00 0b be 400099e8 <mount_and_make_target_path+0x34>
400099c0: 01 00 00 00 nop
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
400099c4: 40 00 02 ea call 4000a56c <rtems_mkdir>
400099c8: 92 10 21 ff mov 0x1ff, %o1 ! 1ff <PROM_START+0x1ff>
if (rv == 0) {
400099cc: 82 92 20 00 orcc %o0, 0, %g1
400099d0: 02 80 00 04 be 400099e0 <mount_and_make_target_path+0x2c> <== ALWAYS TAKEN
400099d4: 01 00 00 00 nop
} else {
errno = EINVAL;
}
return rv;
}
400099d8: 81 c7 e0 08 ret
400099dc: 91 e8 00 01 restore %g0, %g1, %o0
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
400099e0: 40 00 00 08 call 40009a00 <mount>
400099e4: 81 e8 00 00 restore
options,
data
);
}
} else {
errno = EINVAL;
400099e8: 40 00 68 54 call 40023b38 <__errno>
400099ec: 01 00 00 00 nop
400099f0: 84 10 20 16 mov 0x16, %g2 ! 16 <PROM_START+0x16>
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
400099f4: 82 10 3f ff mov -1, %g1
options,
data
);
}
} else {
errno = EINVAL;
400099f8: 10 bf ff f8 b 400099d8 <mount_and_make_target_path+0x24>
400099fc: c4 22 00 00 st %g2, [ %o0 ]
40008778 <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
40008778: 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;
4000877c: 03 10 00 93 sethi %hi(0x40024c00), %g1
40008780: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 40024cb0 <_Thread_Dispatch_disable_level>
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40008784: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
++level;
40008788: 84 00 a0 01 inc %g2
4000878c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40008790: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40008794: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
_Thread_Dispatch_disable_level = level;
40008798: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ]
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
4000879c: a2 8e 62 00 andcc %i1, 0x200, %l1
400087a0: 12 80 00 36 bne 40008878 <mq_open+0x100>
400087a4: a0 10 20 00 clr %l0
*/
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
400087a8: 39 10 00 94 sethi %hi(0x40025000), %i4
400087ac: 40 00 0c 21 call 4000b830 <_Objects_Allocate>
400087b0: 90 17 21 80 or %i4, 0x180, %o0 ! 40025180 <_POSIX_Message_queue_Information_fds>
attr = va_arg( arg, struct mq_attr * );
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
400087b4: ba 92 20 00 orcc %o0, 0, %i5
400087b8: 02 80 00 39 be 4000889c <mq_open+0x124> <== NEVER TAKEN
400087bc: 01 00 00 00 nop
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq_fd->oflag = oflag;
400087c0: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Message_queue_Information, name, id, len );
400087c4: 35 10 00 93 sethi %hi(0x40024c00), %i2
400087c8: 92 10 00 18 mov %i0, %o1
400087cc: 90 16 a3 f4 or %i2, 0x3f4, %o0
400087d0: 94 07 bf f0 add %fp, -16, %o2
400087d4: 40 00 01 42 call 40008cdc <_POSIX_Name_to_id>
400087d8: 96 07 bf fc add %fp, -4, %o3
* If the name to id translation worked, then the message queue exists
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "message queue does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
400087dc: b6 92 20 00 orcc %o0, 0, %i3
400087e0: 22 80 00 0f be,a 4000881c <mq_open+0xa4>
400087e4: 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) ) ) {
400087e8: 80 a6 e0 02 cmp %i3, 2
400087ec: 02 80 00 3f be 400088e8 <mq_open+0x170>
400087f0: 80 a4 60 00 cmp %l1, 0
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
400087f4: 90 17 21 80 or %i4, 0x180, %o0
400087f8: 40 00 0d 06 call 4000bc10 <_Objects_Free>
400087fc: 92 10 00 1d mov %i5, %o1
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
40008800: 40 00 11 58 call 4000cd60 <_Thread_Enable_dispatch>
40008804: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
40008808: 40 00 28 15 call 4001285c <__errno>
4000880c: 01 00 00 00 nop
40008810: f6 22 00 00 st %i3, [ %o0 ]
40008814: 81 c7 e0 08 ret
40008818: 81 e8 00 00 restore
} else { /* name -> ID translation succeeded */
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
4000881c: 80 a6 6a 00 cmp %i1, 0xa00
40008820: 02 80 00 27 be 400088bc <mq_open+0x144>
40008824: d2 07 bf f0 ld [ %fp + -16 ], %o1
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control *)
40008828: 94 07 bf f8 add %fp, -8, %o2
4000882c: 40 00 0d 5f call 4000bda8 <_Objects_Get>
40008830: 90 16 a3 f4 or %i2, 0x3f4, %o0
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
the_mq->open_count += 1;
40008834: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
40008838: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
4000883c: 84 00 a0 01 inc %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008840: b8 17 21 80 or %i4, 0x180, %i4
40008844: c4 22 20 18 st %g2, [ %o0 + 0x18 ]
40008848: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
4000884c: d0 27 bf f4 st %o0, [ %fp + -12 ]
the_mq->open_count += 1;
the_mq_fd->Queue = the_mq;
40008850: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
40008854: 83 28 60 02 sll %g1, 2, %g1
40008858: fa 20 80 01 st %i5, [ %g2 + %g1 ]
_Objects_Open_string(
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
4000885c: 40 00 11 41 call 4000cd60 <_Thread_Enable_dispatch>
40008860: c0 27 60 0c clr [ %i5 + 0xc ]
_Thread_Enable_dispatch();
40008864: 40 00 11 3f call 4000cd60 <_Thread_Enable_dispatch>
40008868: 01 00 00 00 nop
return (mqd_t)the_mq_fd->Object.id;
4000886c: f0 07 60 08 ld [ %i5 + 8 ], %i0
40008870: 81 c7 e0 08 ret
40008874: 81 e8 00 00 restore
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40008878: 82 07 a0 4c add %fp, 0x4c, %g1
mode = va_arg( arg, mode_t );
attr = va_arg( arg, struct mq_attr * );
4000887c: e0 07 a0 50 ld [ %fp + 0x50 ], %l0
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40008880: c2 27 bf ec st %g1, [ %fp + -20 ]
*/
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
40008884: 39 10 00 94 sethi %hi(0x40025000), %i4
40008888: 40 00 0b ea call 4000b830 <_Objects_Allocate>
4000888c: 90 17 21 80 or %i4, 0x180, %o0 ! 40025180 <_POSIX_Message_queue_Information_fds>
attr = va_arg( arg, struct mq_attr * );
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
40008890: ba 92 20 00 orcc %o0, 0, %i5
40008894: 32 bf ff cc bne,a 400087c4 <mq_open+0x4c>
40008898: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
_Thread_Enable_dispatch();
4000889c: 40 00 11 31 call 4000cd60 <_Thread_Enable_dispatch>
400088a0: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( ENFILE );
400088a4: 40 00 27 ee call 4001285c <__errno>
400088a8: 01 00 00 00 nop
400088ac: 82 10 20 17 mov 0x17, %g1 ! 17 <PROM_START+0x17>
400088b0: c2 22 00 00 st %g1, [ %o0 ]
400088b4: 81 c7 e0 08 ret
400088b8: 81 e8 00 00 restore
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
400088bc: 90 17 21 80 or %i4, 0x180, %o0
400088c0: 40 00 0c d4 call 4000bc10 <_Objects_Free>
400088c4: 92 10 00 1d mov %i5, %o1
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
400088c8: 40 00 11 26 call 4000cd60 <_Thread_Enable_dispatch>
400088cc: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
400088d0: 40 00 27 e3 call 4001285c <__errno>
400088d4: 01 00 00 00 nop
400088d8: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
400088dc: c2 22 00 00 st %g1, [ %o0 ]
400088e0: 81 c7 e0 08 ret
400088e4: 81 e8 00 00 restore
if ( status ) {
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
400088e8: 02 bf ff c4 be 400087f8 <mq_open+0x80>
400088ec: 90 17 21 80 or %i4, 0x180, %o0
/*
* At this point, the message queue does not exist and everything has been
* checked. We should go ahead and create a message queue.
*/
status = _POSIX_Message_queue_Create_support(
400088f0: d2 07 bf fc ld [ %fp + -4 ], %o1
400088f4: 90 10 00 18 mov %i0, %o0
400088f8: 94 10 20 01 mov 1, %o2
400088fc: 96 10 00 10 mov %l0, %o3
40008900: 40 00 1b d1 call 4000f844 <_POSIX_Message_queue_Create_support>
40008904: 98 07 bf f4 add %fp, -12, %o4
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
40008908: 80 a2 3f ff cmp %o0, -1
4000890c: 02 80 00 0d be 40008940 <mq_open+0x1c8>
40008910: c6 07 bf f4 ld [ %fp + -12 ], %g3
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
40008914: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008918: b8 17 21 80 or %i4, 0x180, %i4
4000891c: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
return (mqd_t) -1;
}
the_mq_fd->Queue = the_mq;
40008920: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
40008924: 83 28 60 02 sll %g1, 2, %g1
40008928: fa 20 80 01 st %i5, [ %g2 + %g1 ]
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
4000892c: 40 00 11 0d call 4000cd60 <_Thread_Enable_dispatch>
40008930: c0 27 60 0c clr [ %i5 + 0xc ]
return (mqd_t) the_mq_fd->Object.id;
40008934: f0 07 60 08 ld [ %i5 + 8 ], %i0
}
40008938: 81 c7 e0 08 ret
4000893c: 81 e8 00 00 restore
40008940: 90 17 21 80 or %i4, 0x180, %o0
40008944: 92 10 00 1d mov %i5, %o1
40008948: 40 00 0c b2 call 4000bc10 <_Objects_Free>
4000894c: b0 10 3f ff mov -1, %i0
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
40008950: 40 00 11 04 call 4000cd60 <_Thread_Enable_dispatch>
40008954: 01 00 00 00 nop
40008958: 81 c7 e0 08 ret
4000895c: 81 e8 00 00 restore
40019258 <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
40019258: 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;
4001925c: 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);
40019260: b8 07 bf 80 add %fp, -128, %i4
mode_t mode,
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
40019264: e0 00 60 08 ld [ %g1 + 8 ], %l0
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
40019268: c0 27 bf 6c clr [ %fp + -148 ]
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4001926c: 82 10 3f ff mov -1, %g1
time_t time_ret = 0;
uint16_t time_val = 0;
40019270: c0 37 bf 68 clrh [ %fp + -152 ]
uint16_t date = 0;
40019274: 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;
40019278: c0 27 bf 70 clr [ %fp + -144 ]
dir_pos->sname.ofs = 0;
4001927c: c0 27 bf 74 clr [ %fp + -140 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40019280: c2 27 bf 78 st %g1, [ %fp + -136 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40019284: c2 27 bf 7c st %g1, [ %fp + -132 ]
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
40019288: c0 27 bf 80 clr [ %fp + -128 ]
4001928c: c0 27 bf 84 clr [ %fp + -124 ]
40019290: c0 27 20 08 clr [ %i4 + 8 ]
40019294: c0 27 20 0c clr [ %i4 + 0xc ]
40019298: c0 27 20 10 clr [ %i4 + 0x10 ]
4001929c: c0 27 20 14 clr [ %i4 + 0x14 ]
400192a0: c0 27 20 18 clr [ %i4 + 0x18 ]
400192a4: c0 27 20 1c clr [ %i4 + 0x1c ]
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
400192a8: c0 27 bf c0 clr [ %fp + -64 ]
400192ac: c0 27 bf c4 clr [ %fp + -60 ]
400192b0: c0 27 bf c8 clr [ %fp + -56 ]
400192b4: c0 27 bf cc clr [ %fp + -52 ]
400192b8: c0 27 bf d0 clr [ %fp + -48 ]
400192bc: c0 27 bf d4 clr [ %fp + -44 ]
400192c0: c0 27 bf d8 clr [ %fp + -40 ]
400192c4: c0 27 bf dc clr [ %fp + -36 ]
400192c8: c0 27 bf e0 clr [ %fp + -32 ]
400192cc: c0 27 bf e4 clr [ %fp + -28 ]
400192d0: c0 27 bf e8 clr [ %fp + -24 ]
400192d4: c0 27 bf ec clr [ %fp + -20 ]
400192d8: c0 27 bf f0 clr [ %fp + -16 ]
400192dc: c0 27 bf f4 clr [ %fp + -12 ]
400192e0: c0 27 bf f8 clr [ %fp + -8 ]
400192e4: c0 27 bf fc clr [ %fp + -4 ]
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
400192e8: 80 a6 e1 04 cmp %i3, 0x104
400192ec: 14 80 00 e3 bg 40019678 <msdos_creat_node+0x420> <== NEVER TAKEN
400192f0: e2 06 20 08 ld [ %i0 + 8 ], %l1
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
}
name_type = msdos_long_to_short (name, name_len,
400192f4: 90 10 00 1a mov %i2, %o0
400192f8: 92 10 00 1b mov %i3, %o1
400192fc: 94 10 00 1c mov %i4, %o2
40019300: 40 00 01 37 call 400197dc <msdos_long_to_short>
40019304: 96 10 20 0b mov 0xb, %o3
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
40019308: a4 92 20 00 orcc %o0, 0, %l2
4001930c: 02 80 00 e0 be 4001968c <msdos_creat_node+0x434> <== NEVER TAKEN
40019310: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EINVAL);
}
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
40019314: c0 2f bf 8c clrb [ %fp + -116 ]
/* set up last write date and time */
time_ret = time(NULL);
40019318: 40 00 22 21 call 40021b9c <time>
4001931c: 90 10 20 00 clr %o0
if ( time_ret == -1 )
40019320: 80 a2 3f ff cmp %o0, -1
40019324: 02 80 00 df be 400196a0 <msdos_creat_node+0x448> <== NEVER TAKEN
40019328: 92 07 bf 6a add %fp, -150, %o1
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
4001932c: 40 00 0c 87 call 4001c548 <msdos_date_unix2dos>
40019330: 94 07 bf 68 add %fp, -152, %o2
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
40019334: c8 17 bf 68 lduh [ %fp + -152 ], %g4
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40019338: 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);
4001933c: 89 29 20 10 sll %g4, 0x10, %g4
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40019340: 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);
40019344: 85 31 20 08 srl %g4, 8, %g2
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40019348: 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);
4001934c: 89 31 20 18 srl %g4, 0x18, %g4
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40019350: 87 30 e0 18 srl %g3, 0x18, %g3
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
40019354: 84 10 80 04 or %g2, %g4, %g2
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
40019358: 82 10 40 03 or %g1, %g3, %g1
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
4001935c: c4 37 bf 8e sth %g2, [ %fp + -114 ]
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
40019360: 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);
40019364: 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);
40019368: c2 37 bf 98 sth %g1, [ %fp + -104 ]
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
4001936c: c2 37 bf 92 sth %g1, [ %fp + -110 ]
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
40019370: 80 a6 60 00 cmp %i1, 0
40019374: 02 80 00 12 be 400193bc <msdos_creat_node+0x164>
40019378: c0 27 bf 9c clr [ %fp + -100 ]
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == MSDOS_HARD_LINK) {
4001937c: 80 a6 60 02 cmp %i1, 2
40019380: 02 80 00 89 be 400195a4 <msdos_creat_node+0x34c> <== NEVER TAKEN
40019384: c2 0f bf 8b ldub [ %fp + -117 ], %g1
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
40019388: 82 10 60 20 or %g1, 0x20, %g1
4001938c: 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,
40019390: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
40019394: 90 10 00 18 mov %i0, %o0
40019398: 92 10 20 01 mov 1, %o1
4001939c: 94 10 00 1a mov %i2, %o2
400193a0: 96 10 00 1b mov %i3, %o3
400193a4: 98 10 00 12 mov %l2, %o4
400193a8: 40 00 06 b8 call 4001ae88 <msdos_get_name_node>
400193ac: 9a 07 bf 70 add %fp, -144, %o5
400193b0: ba 10 00 08 mov %o0, %i5
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
400193b4: 81 c7 e0 08 ret
400193b8: 91 e8 00 1d restore %g0, %i5, %o0
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
400193bc: c2 0f bf 8b ldub [ %fp + -117 ], %g1
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
400193c0: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
400193c4: 82 10 60 10 or %g1, 0x10, %g1
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
400193c8: 90 10 00 18 mov %i0, %o0
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
400193cc: 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,
400193d0: 92 10 20 01 mov 1, %o1
400193d4: 94 10 00 1a mov %i2, %o2
400193d8: 96 10 00 1b mov %i3, %o3
400193dc: 98 10 00 12 mov %l2, %o4
400193e0: 40 00 06 aa call 4001ae88 <msdos_get_name_node>
400193e4: 9a 07 bf 70 add %fp, -144, %o5
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
400193e8: ba 92 20 00 orcc %o0, 0, %i5
400193ec: 12 bf ff f2 bne 400193b4 <msdos_creat_node+0x15c> <== NEVER TAKEN
400193f0: 90 10 00 10 mov %l0, %o0
* to do
*/
if (type == MSDOS_DIRECTORY)
{
/* open new directory as fat-file */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
400193f4: 92 07 bf 70 add %fp, -144, %o1
400193f8: 7f ff e8 ac call 400136a8 <fat_file_open>
400193fc: 94 07 bf 6c add %fp, -148, %o2
if (rc != RC_OK)
40019400: ba 92 20 00 orcc %o0, 0, %i5
40019404: 32 80 00 62 bne,a 4001958c <msdos_creat_node+0x334> <== NEVER TAKEN
40019408: 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;
4001940c: f2 07 bf 6c ld [ %fp + -148 ], %i1
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
40019410: 03 00 08 00 sethi %hi(0x200000), %g1
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
40019414: c0 26 60 18 clr [ %i1 + 0x18 ]
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
40019418: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
fat_fd->fat_file_type = FAT_DIRECTORY;
4001941c: c0 26 60 10 clr [ %i1 + 0x10 ]
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
40019420: 03 10 00 b8 sethi %hi(0x4002e000), %g1
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
40019424: d8 1f bf 80 ldd [ %fp + -128 ], %o4
40019428: c4 1f bf 98 ldd [ %fp + -104 ], %g2
4001942c: f4 1f bf 88 ldd [ %fp + -120 ], %i2
40019430: f8 1f bf 90 ldd [ %fp + -112 ], %i4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
40019434: d2 00 63 ac ld [ %g1 + 0x3ac ], %o1
40019438: 94 10 20 0b mov 0xb, %o2
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
4001943c: d8 3f bf c0 std %o4, [ %fp + -64 ]
40019440: c4 3f bf d8 std %g2, [ %fp + -40 ]
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
40019444: d8 3f bf e0 std %o4, [ %fp + -32 ]
40019448: c4 3f bf f8 std %g2, [ %fp + -8 ]
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
4001944c: f4 3f bf c8 std %i2, [ %fp + -56 ]
40019450: f8 3f bf d0 std %i4, [ %fp + -48 ]
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
40019454: f4 3f bf e8 std %i2, [ %fp + -24 ]
40019458: f8 3f bf f0 std %i4, [ %fp + -16 ]
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
4001945c: 40 00 12 f2 call 4001e024 <memcpy>
40019460: 90 07 bf c0 add %fp, -64, %o0
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
40019464: 03 10 00 b8 sethi %hi(0x4002e000), %g1
40019468: d2 00 63 a8 ld [ %g1 + 0x3a8 ], %o1 ! 4002e3a8 <MSDOS_DOTDOT_NAME>
4001946c: 90 07 bf e0 add %fp, -32, %o0
40019470: 40 00 12 ed call 4001e024 <memcpy>
40019474: 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)) &&
40019478: c2 04 60 20 ld [ %l1 + 0x20 ], %g1
4001947c: 80 a0 60 01 cmp %g1, 1
40019480: 22 80 00 73 be,a 4001964c <msdos_creat_node+0x3f4>
40019484: c2 04 60 24 ld [ %l1 + 0x24 ], %g1
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
40019488: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
4001948c: 07 00 00 3f sethi %hi(0xfc00), %g3
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
40019490: 85 30 60 10 srl %g1, 0x10, %g2
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
40019494: 86 10 e3 ff or %g3, 0x3ff, %g3
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
40019498: 89 28 60 10 sll %g1, 0x10, %g4
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
4001949c: 82 08 40 03 and %g1, %g3, %g1
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
400194a0: 89 31 20 18 srl %g4, 0x18, %g4
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
400194a4: 86 08 80 03 and %g2, %g3, %g3
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
400194a8: 83 28 60 08 sll %g1, 8, %g1
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
400194ac: 87 28 e0 08 sll %g3, 8, %g3
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
400194b0: 82 10 40 04 or %g1, %g4, %g1
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
400194b4: 85 30 a0 08 srl %g2, 8, %g2
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
400194b8: c2 37 bf fa sth %g1, [ %fp + -6 ]
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
400194bc: 84 10 c0 02 or %g3, %g2, %g2
400194c0: c4 37 bf f4 sth %g2, [ %fp + -12 ]
/*
* write dot and dotdot entries to new fat-file: currently fat-file
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
400194c4: 90 10 00 10 mov %l0, %o0
400194c8: 92 10 00 19 mov %i1, %o1
400194cc: 94 10 20 00 clr %o2
400194d0: 96 10 20 40 mov 0x40, %o3
400194d4: 7f ff ea e7 call 40014070 <fat_file_write>
400194d8: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
400194dc: 80 a2 20 00 cmp %o0, 0
400194e0: 06 80 00 26 bl 40019578 <msdos_creat_node+0x320> <== NEVER TAKEN
400194e4: 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;
400194e8: c4 14 20 06 lduh [ %l0 + 6 ], %g2
400194ec: c6 02 60 18 ld [ %o1 + 0x18 ], %g3
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
400194f0: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
400194f4: 84 00 c0 02 add %g3, %g2, %g2
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
400194f8: bb 28 60 10 sll %g1, 0x10, %i5
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
400194fc: 87 30 60 10 srl %g1, 0x10, %g3
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
40019500: c4 22 60 18 st %g2, [ %o1 + 0x18 ]
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
40019504: 89 30 e0 08 srl %g3, 8, %g4
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
40019508: bb 37 60 18 srl %i5, 0x18, %i5
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
4001950c: 05 00 00 3f sethi %hi(0xfc00), %g2
40019510: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <PROM_START+0xffff>
40019514: 82 08 40 02 and %g1, %g2, %g1
40019518: 84 08 c0 02 and %g3, %g2, %g2
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
4001951c: 83 28 60 08 sll %g1, 8, %g1
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
40019520: 85 28 a0 08 sll %g2, 8, %g2
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
40019524: 82 10 40 1d or %g1, %i5, %g1
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
40019528: 84 10 80 04 or %g2, %g4, %g2
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
4001952c: 90 10 00 10 mov %l0, %o0
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
40019530: c2 37 bf da sth %g1, [ %fp + -38 ]
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
40019534: c4 37 bf d4 sth %g2, [ %fp + -44 ]
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
40019538: 94 10 20 00 clr %o2
4001953c: 96 10 20 20 mov 0x20, %o3
40019540: 7f ff ea cc call 40014070 <fat_file_write>
40019544: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
40019548: 80 a2 20 00 cmp %o0, 0
4001954c: 06 80 00 0c bl 4001957c <msdos_creat_node+0x324> <== NEVER TAKEN
40019550: 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);
40019554: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
40019558: 40 00 01 74 call 40019b28 <msdos_set_first_cluster_num>
4001955c: d2 07 bf 6c ld [ %fp + -148 ], %o1
if (rc != RC_OK)
40019560: ba 92 20 00 orcc %o0, 0, %i5
40019564: 12 80 00 07 bne 40019580 <msdos_creat_node+0x328> <== NEVER TAKEN
40019568: d2 07 bf 6c ld [ %fp + -148 ], %o1
goto error;
fat_file_close(&fs_info->fat, fat_fd);
4001956c: 7f ff e9 c9 call 40013c90 <fat_file_close>
40019570: 90 10 00 10 mov %l0, %o0
40019574: 30 bf ff 90 b,a 400193b4 <msdos_creat_node+0x15c>
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
{
rc = -1;
40019578: 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);
4001957c: d2 07 bf 6c ld [ %fp + -148 ], %o1 <== NOT EXECUTED
40019580: 7f ff e9 c4 call 40013c90 <fat_file_close> <== NOT EXECUTED
40019584: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
40019588: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 <== NOT EXECUTED
4001958c: 92 07 bf 70 add %fp, -144, %o1 <== NOT EXECUTED
40019590: 94 10 20 e5 mov 0xe5, %o2 <== NOT EXECUTED
40019594: 40 00 01 c9 call 40019cb8 <msdos_set_first_char4file_name><== NOT EXECUTED
40019598: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
}
4001959c: 81 c7 e0 08 ret <== NOT EXECUTED
400195a0: 81 e8 00 00 restore <== NOT EXECUTED
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
400195a4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
400195a8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400195ac: 32 80 00 07 bne,a 400195c8 <msdos_creat_node+0x370> <== NOT EXECUTED
400195b0: c6 0c 20 05 ldub [ %l0 + 5 ], %g3 <== NOT EXECUTED
400195b4: c4 0c 20 0e ldub [ %l0 + 0xe ], %g2 <== NOT EXECUTED
400195b8: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
400195bc: 32 80 00 07 bne,a 400195d8 <msdos_creat_node+0x380> <== NOT EXECUTED
400195c0: d2 04 20 20 ld [ %l0 + 0x20 ], %o1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
400195c4: c6 0c 20 05 ldub [ %l0 + 5 ], %g3 <== NOT EXECUTED
400195c8: c4 04 20 34 ld [ %l0 + 0x34 ], %g2 <== NOT EXECUTED
400195cc: 92 00 7f fe add %g1, -2, %o1 <== NOT EXECUTED
400195d0: 93 2a 40 03 sll %o1, %g3, %o1 <== NOT EXECUTED
400195d4: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
400195d8: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
400195dc: c4 0c 20 02 ldub [ %l0 + 2 ], %g2 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
400195e0: d4 14 00 00 lduh [ %l0 ], %o2 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
400195e4: 85 30 40 02 srl %g1, %g2, %g2 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
400195e8: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
400195ec: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
400195f0: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
400195f4: 94 0a 80 01 and %o2, %g1, %o2 <== NOT EXECUTED
400195f8: 96 10 20 20 mov 0x20, %o3 <== NOT EXECUTED
400195fc: 7f ff ec 37 call 400146d8 <_fat_block_read> <== NOT EXECUTED
40019600: 98 07 bf a0 add %fp, -96, %o4 <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
40019604: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40019608: 06 80 00 26 bl 400196a0 <msdos_creat_node+0x448> <== NOT EXECUTED
4001960c: c4 0f bf ad ldub [ %fp + -83 ], %g2 <== NOT EXECUTED
return -1;
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
40019610: c2 0f bf ab ldub [ %fp + -85 ], %g1 <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
40019614: c4 2f bf 8d stb %g2, [ %fp + -115 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
40019618: c4 17 bf ae lduh [ %fp + -82 ], %g2 <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
4001961c: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
40019620: c4 37 bf 8e sth %g2, [ %fp + -114 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
40019624: c4 17 bf b0 lduh [ %fp + -80 ], %g2 <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
40019628: c2 2f bf 8b stb %g1, [ %fp + -117 ] <== NOT EXECUTED
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
4001962c: c4 37 bf 90 sth %g2, [ %fp + -112 ] <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
40019630: c4 07 bf bc ld [ %fp + -68 ], %g2 <== NOT EXECUTED
40019634: c4 27 bf 9c st %g2, [ %fp + -100 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
40019638: c4 17 bf ba lduh [ %fp + -70 ], %g2 <== NOT EXECUTED
4001963c: c4 37 bf 9a sth %g2, [ %fp + -102 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
40019640: c4 17 bf b4 lduh [ %fp + -76 ], %g2 <== NOT EXECUTED
40019644: 10 bf ff 53 b 40019390 <msdos_creat_node+0x138> <== NOT EXECUTED
40019648: c4 37 bf 94 sth %g2, [ %fp + -108 ] <== NOT EXECUTED
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
4001964c: 80 a0 60 00 cmp %g1, 0
40019650: 32 bf ff 8f bne,a 4001948c <msdos_creat_node+0x234> <== NEVER TAKEN
40019654: c2 04 60 1c ld [ %l1 + 0x1c ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & FAT_FAT32))
40019658: c2 0c 20 0e ldub [ %l0 + 0xe ], %g1
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
4001965c: 82 08 60 04 and %g1, 4, %g1
40019660: 80 88 60 ff btst 0xff, %g1
40019664: 22 bf ff 8a be,a 4001948c <msdos_creat_node+0x234> <== ALWAYS TAKEN
40019668: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
(fs_info->fat.vol.type & FAT_FAT32))
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
4001966c: c0 37 bf fa clrh [ %fp + -6 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
40019670: 10 bf ff 95 b 400194c4 <msdos_creat_node+0x26c> <== NOT EXECUTED
40019674: c0 37 bf f4 clrh [ %fp + -12 ] <== NOT EXECUTED
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
40019678: 40 00 0f c6 call 4001d590 <__errno> <== NOT EXECUTED
4001967c: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
40019680: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
40019684: 10 bf ff 4c b 400193b4 <msdos_creat_node+0x15c> <== NOT EXECUTED
40019688: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
name_type = msdos_long_to_short (name, name_len,
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
rtems_set_errno_and_return_minus_one(EINVAL);
4001968c: 40 00 0f c1 call 4001d590 <__errno> <== NOT EXECUTED
40019690: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
40019694: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40019698: 10 bf ff 47 b 400193b4 <msdos_creat_node+0x15c> <== NOT EXECUTED
4001969c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
/* set up last write date and time */
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
400196a0: 10 bf ff 45 b 400193b4 <msdos_creat_node+0x15c> <== NOT EXECUTED
400196a4: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
4001c6c0 <msdos_date_dos2unix>:
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
4001c6c0: 09 10 00 bd sethi %hi(0x4002f400), %g4
4001c6c4: da 11 20 ea lduh [ %g4 + 0xea ], %o5 ! 4002f4ea <lastdosdate>
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
4001c6c8: 86 0a 67 e0 and %o1, 0x7e0, %g3
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
4001c6cc: 85 32 60 0b srl %o1, 0xb, %g2
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
4001c6d0: 83 30 e0 04 srl %g3, 4, %g1
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
4001c6d4: 84 08 a0 1f and %g2, 0x1f, %g2
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
4001c6d8: 86 20 c0 01 sub %g3, %g1, %g3
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
4001c6dc: 99 28 a0 03 sll %g2, 3, %o4
4001c6e0: 83 28 a0 07 sll %g2, 7, %g1
uint32_t m, month;
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
4001c6e4: 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;
4001c6e8: 82 20 40 0c sub %g1, %o4, %g1
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
4001c6ec: 80 a3 40 08 cmp %o5, %o0
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
4001c6f0: 85 28 60 04 sll %g1, 4, %g2
4001c6f4: 82 20 80 01 sub %g2, %g1, %g1
4001c6f8: 82 00 40 03 add %g1, %g3, %g1
4001c6fc: 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) {
4001c700: 02 80 00 3a be 4001c7e8 <msdos_date_dos2unix+0x128>
4001c704: 93 2a 60 01 sll %o1, 1, %o1
lastdosdate = dd;
4001c708: d0 31 20 ea sth %o0, [ %g4 + 0xea ]
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
4001c70c: 82 10 20 00 clr %g1
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
4001c710: 89 32 20 09 srl %o0, 9, %g4
for (y = 0; y < year; y++)
4001c714: 84 10 20 00 clr %g2
4001c718: 88 89 20 7f andcc %g4, 0x7f, %g4
4001c71c: 12 80 00 08 bne 4001c73c <msdos_date_dos2unix+0x7c> <== ALWAYS TAKEN
4001c720: 86 10 21 6e mov 0x16e, %g3
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
4001c724: 10 80 00 2f b 4001c7e0 <msdos_date_dos2unix+0x120> <== NOT EXECUTED
4001c728: 09 10 00 bb sethi %hi(0x4002ec00), %g4 <== NOT EXECUTED
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
days += y & 0x03 ? 365 : 366;
4001c72c: 86 08 a0 03 and %g2, 3, %g3
4001c730: 80 a0 00 03 cmp %g0, %g3
4001c734: 86 60 3f ff subx %g0, -1, %g3
4001c738: 86 00 e1 6d add %g3, 0x16d, %g3
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
4001c73c: 84 00 a0 01 inc %g2
4001c740: 80 a0 80 04 cmp %g2, %g4
4001c744: 12 bf ff fa bne 4001c72c <msdos_date_dos2unix+0x6c>
4001c748: 82 00 40 03 add %g1, %g3, %g1
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
4001c74c: 80 88 a0 03 btst 3, %g2
4001c750: 02 80 00 24 be 4001c7e0 <msdos_date_dos2unix+0x120> <== ALWAYS TAKEN
4001c754: 09 10 00 bb sethi %hi(0x4002ec00), %g4
4001c758: 09 10 00 bb sethi %hi(0x4002ec00), %g4 <== NOT EXECUTED
4001c75c: 88 11 21 18 or %g4, 0x118, %g4 ! 4002ed18 <regyear> <== NOT EXECUTED
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
4001c760: 9a 0a 21 e0 and %o0, 0x1e0, %o5
4001c764: 9b 33 60 05 srl %o5, 5, %o5
if (month == 0) {
4001c768: 80 a3 60 00 cmp %o5, 0
4001c76c: 22 80 00 0d be,a 4001c7a0 <msdos_date_dos2unix+0xe0> <== NEVER TAKEN
4001c770: 90 0a 20 1f and %o0, 0x1f, %o0 <== NOT EXECUTED
month = 1;
}
for (m = 0; m < month - 1; m++)
4001c774: 80 a3 60 01 cmp %o5, 1
4001c778: 02 80 00 09 be 4001c79c <msdos_date_dos2unix+0xdc> <== ALWAYS TAKEN
4001c77c: 84 10 20 00 clr %g2
* Convert from dos' idea of time to unix'. This will probably only be
* called from the stat(), and fstat() system calls and so probably need
* not be too efficient.
*/
unsigned int
msdos_date_dos2unix(unsigned int dd, unsigned int dt)
4001c780: 9a 03 7f ff add %o5, -1, %o5 <== NOT EXECUTED
4001c784: 9b 2b 60 01 sll %o5, 1, %o5 <== NOT EXECUTED
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
days += months[m];
4001c788: c6 11 00 02 lduh [ %g4 + %g2 ], %g3 <== NOT EXECUTED
4001c78c: 84 00 a0 02 add %g2, 2, %g2 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
4001c790: 80 a0 80 0d cmp %g2, %o5 <== NOT EXECUTED
4001c794: 12 bf ff fd bne 4001c788 <msdos_date_dos2unix+0xc8> <== NOT EXECUTED
4001c798: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
4001c79c: 90 0a 20 1f and %o0, 0x1f, %o0
4001c7a0: 90 02 3f ff add %o0, -1, %o0
4001c7a4: 82 02 00 01 add %o0, %g1, %g1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
4001c7a8: 85 28 60 07 sll %g1, 7, %g2
4001c7ac: 83 28 60 09 sll %g1, 9, %g1
4001c7b0: 82 20 40 02 sub %g1, %g2, %g1
4001c7b4: 85 28 60 04 sll %g1, 4, %g2
4001c7b8: 82 20 80 01 sub %g2, %g1, %g1
4001c7bc: 85 28 60 04 sll %g1, 4, %g2
4001c7c0: 82 20 80 01 sub %g2, %g1, %g1
4001c7c4: 05 04 b3 a9 sethi %hi(0x12cea400), %g2
4001c7c8: 84 10 a2 00 or %g2, 0x200, %g2 ! 12cea600 <RAM_SIZE+0x128ea600>
4001c7cc: 90 00 40 02 add %g1, %g2, %o0
4001c7d0: 05 10 00 bd sethi %hi(0x4002f400), %g2
4001c7d4: d0 20 a0 ec st %o0, [ %g2 + 0xec ] ! 4002f4ec <lastseconds>
}
return seconds + lastseconds;
}
4001c7d8: 81 c3 e0 08 retl
4001c7dc: 90 02 00 09 add %o0, %o1, %o0
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
4001c7e0: 10 bf ff e0 b 4001c760 <msdos_date_dos2unix+0xa0>
4001c7e4: 88 11 21 30 or %g4, 0x130, %g4
4001c7e8: 03 10 00 bd sethi %hi(0x4002f400), %g1
4001c7ec: d0 00 60 ec ld [ %g1 + 0xec ], %o0 ! 4002f4ec <lastseconds>
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
}
return seconds + lastseconds;
}
4001c7f0: 81 c3 e0 08 retl
4001c7f4: 90 02 00 09 add %o0, %o1, %o0
4001c548 <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)
{
4001c548: 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) {
4001c54c: 03 10 00 bd sethi %hi(0x4002f400), %g1
4001c550: c4 00 60 dc ld [ %g1 + 0xdc ], %g2 ! 4002f4dc <lasttime>
4001c554: 80 a0 80 18 cmp %g2, %i0
4001c558: 02 80 00 4d be 4001c68c <msdos_date_unix2dos+0x144>
4001c55c: 92 10 20 3c mov 0x3c, %o1
lasttime = t;
4001c560: f0 20 60 dc st %i0, [ %g1 + 0xdc ]
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
4001c564: 7f ff 98 44 call 40002674 <.udiv>
4001c568: 90 10 00 18 mov %i0, %o0
4001c56c: 40 00 38 63 call 4002a6f8 <.urem>
4001c570: 92 10 20 3c mov 0x3c, %o1
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
4001c574: 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)
4001c578: bb 2a 20 05 sll %o0, 5, %i5
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
4001c57c: 7f ff 98 3e call 40002674 <.udiv>
4001c580: 90 10 00 18 mov %i0, %o0
4001c584: 40 00 38 5d call 4002a6f8 <.urem>
4001c588: 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)
4001c58c: 83 2a 20 0b sll %o0, 0xb, %g1
4001c590: 92 10 20 3c mov 0x3c, %o1
4001c594: ba 07 40 01 add %i5, %g1, %i5
4001c598: 40 00 38 58 call 4002a6f8 <.urem>
4001c59c: 90 10 00 18 mov %i0, %o0
4001c5a0: 05 10 00 bd sethi %hi(0x4002f400), %g2
4001c5a4: 91 32 20 01 srl %o0, 1, %o0
4001c5a8: 82 07 40 08 add %i5, %o0, %g1
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
4001c5ac: 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)
4001c5b0: c2 30 a0 e0 sth %g1, [ %g2 + 0xe0 ]
4001c5b4: ba 10 00 01 mov %g1, %i5
/*
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
4001c5b8: 90 10 00 18 mov %i0, %o0
4001c5bc: 7f ff 98 2e call 40002674 <.udiv>
4001c5c0: 92 12 61 80 or %o1, 0x180, %o1
if (days != lastday) {
4001c5c4: 03 10 00 bd sethi %hi(0x4002f400), %g1
4001c5c8: c4 00 60 e4 ld [ %g1 + 0xe4 ], %g2 ! 4002f4e4 <lastday>
4001c5cc: 80 a2 00 02 cmp %o0, %g2
4001c5d0: 22 80 00 37 be,a 4001c6ac <msdos_date_unix2dos+0x164>
4001c5d4: 03 10 00 bd sethi %hi(0x4002f400), %g1
lastday = days;
4001c5d8: d0 20 60 e4 st %o0, [ %g1 + 0xe4 ] ! 4002f4e4 <lastday>
for (year = 1970;; year++) {
4001c5dc: 10 80 00 03 b 4001c5e8 <msdos_date_unix2dos+0xa0>
4001c5e0: 82 10 27 b2 mov 0x7b2, %g1
4001c5e4: 82 00 60 01 inc %g1
inc = year & 0x03 ? 365 : 366;
4001c5e8: 86 08 60 03 and %g1, 3, %g3
4001c5ec: 80 a0 00 03 cmp %g0, %g3
4001c5f0: 84 60 3f ff subx %g0, -1, %g2
4001c5f4: 84 00 a1 6d add %g2, 0x16d, %g2
if (days < inc)
4001c5f8: 80 a2 00 02 cmp %o0, %g2
4001c5fc: 3a bf ff fa bcc,a 4001c5e4 <msdos_date_unix2dos+0x9c>
4001c600: 90 22 00 02 sub %o0, %g2, %o0
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
4001c604: 80 a0 e0 00 cmp %g3, 0
4001c608: 02 80 00 1d be 4001c67c <msdos_date_unix2dos+0x134> <== ALWAYS TAKEN
4001c60c: 09 10 00 bb sethi %hi(0x4002ec00), %g4
4001c610: 09 10 00 bb sethi %hi(0x4002ec00), %g4 <== NOT EXECUTED
4001c614: 88 11 21 18 or %g4, 0x118, %g4 ! 4002ed18 <regyear> <== NOT EXECUTED
for (month = 0; month < 12; month++) {
4001c618: 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,
4001c61c: 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])
4001c620: c6 11 00 03 lduh [ %g4 + %g3 ], %g3
4001c624: 80 a0 c0 08 cmp %g3, %o0
4001c628: 18 80 00 17 bgu 4001c684 <msdos_date_unix2dos+0x13c> <== ALWAYS TAKEN
4001c62c: 84 00 a0 01 inc %g2
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
4001c630: 80 a0 a0 0c cmp %g2, 0xc <== NOT EXECUTED
4001c634: 12 bf ff fa bne 4001c61c <msdos_date_unix2dos+0xd4> <== NOT EXECUTED
4001c638: 90 22 00 03 sub %o0, %g3, %o0 <== NOT EXECUTED
4001c63c: 84 10 21 a0 mov 0x1a0, %g2 <== NOT EXECUTED
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
4001c640: 84 00 a0 01 inc %g2
* Remember dos's idea of time is relative to 1980.
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
4001c644: 80 a0 67 bc cmp %g1, 0x7bc
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
4001c648: 90 00 80 08 add %g2, %o0, %o0
* Remember dos's idea of time is relative to 1980.
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
4001c64c: 08 80 00 06 bleu 4001c664 <msdos_date_unix2dos+0x11c> <== NEVER TAKEN
4001c650: 84 10 00 08 mov %o0, %g2
lastddate += (year - 1980) <<
4001c654: 82 00 78 44 add %g1, -1980, %g1
4001c658: 83 28 60 09 sll %g1, 9, %g1
4001c65c: 90 02 00 01 add %o0, %g1, %o0
4001c660: 84 10 00 08 mov %o0, %g2
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
4001c664: fa 36 80 00 sth %i5, [ %i2 ]
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
lastddate += (year - 1980) <<
4001c668: 03 10 00 bd sethi %hi(0x4002f400), %g1
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
*ddp = lastddate;
4001c66c: c4 36 40 00 sth %g2, [ %i1 ]
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
lastddate += (year - 1980) <<
4001c670: d0 30 60 e8 sth %o0, [ %g1 + 0xe8 ]
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
*ddp = lastddate;
4001c674: 81 c7 e0 08 ret
4001c678: 81 e8 00 00 restore
inc = year & 0x03 ? 365 : 366;
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
4001c67c: 10 bf ff e7 b 4001c618 <msdos_date_unix2dos+0xd0>
4001c680: 88 11 21 30 or %g4, 0x130, %g4
4001c684: 10 bf ff ef b 4001c640 <msdos_date_unix2dos+0xf8>
4001c688: 85 28 a0 05 sll %g2, 5, %g2
4001c68c: 03 10 00 bd sethi %hi(0x4002f400), %g1
4001c690: fa 10 60 e0 lduh [ %g1 + 0xe0 ], %i5 ! 4002f4e0 <lastdtime>
4001c694: 03 10 00 bd sethi %hi(0x4002f400), %g1
4001c698: c4 10 60 e8 lduh [ %g1 + 0xe8 ], %g2 ! 4002f4e8 <lastddate>
if (year > 1980)
lastddate += (year - 1980) <<
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
4001c69c: fa 36 80 00 sth %i5, [ %i2 ]
*ddp = lastddate;
4001c6a0: c4 36 40 00 sth %g2, [ %i1 ]
4001c6a4: 81 c7 e0 08 ret
4001c6a8: 81 e8 00 00 restore
4001c6ac: c4 10 60 e8 lduh [ %g1 + 0xe8 ], %g2
if (year > 1980)
lastddate += (year - 1980) <<
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
4001c6b0: fa 36 80 00 sth %i5, [ %i2 ]
*ddp = lastddate;
4001c6b4: c4 36 40 00 sth %g2, [ %i1 ]
4001c6b8: 81 c7 e0 08 ret
4001c6bc: 81 e8 00 00 restore
40019e68 <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
)
{
40019e68: 9d e3 bf a0 save %sp, -96, %sp
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40019e6c: e0 06 20 08 ld [ %i0 + 8 ], %l0
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
40019e70: 25 10 00 b8 sethi %hi(0x4002e000), %l2
40019e74: e2 14 00 00 lduh [ %l0 ], %l1
40019e78: ea 04 20 a0 ld [ %l0 + 0xa0 ], %l5
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
40019e7c: 29 10 00 b8 sethi %hi(0x4002e000), %l4
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
40019e80: 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;
40019e84: a6 10 20 00 clr %l3
40019e88: a3 2c 60 10 sll %l1, 0x10, %l1
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
40019e8c: a4 14 a3 68 or %l2, 0x368, %l2
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
40019e90: a8 15 23 78 or %l4, 0x378, %l4
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
40019e94: a3 34 60 10 srl %l1, 0x10, %l1
40019e98: 92 10 00 13 mov %l3, %o1
40019e9c: 7f ff a1 bc call 4000258c <.umul>
40019ea0: 90 10 00 11 mov %l1, %o0
40019ea4: 92 10 00 19 mov %i1, %o1
40019ea8: 94 10 00 08 mov %o0, %o2
40019eac: 96 10 00 11 mov %l1, %o3
40019eb0: 90 10 00 10 mov %l0, %o0
40019eb4: 7f ff e6 b1 call 40013978 <fat_file_read>
40019eb8: 98 10 00 15 mov %l5, %o4
40019ebc: 80 a2 20 00 cmp %o0, 0
40019ec0: 02 80 00 34 be 40019f90 <msdos_dir_is_empty+0x128> <== NEVER TAKEN
40019ec4: 80 a2 20 1f cmp %o0, 0x1f
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40019ec8: 04 80 00 27 ble 40019f64 <msdos_dir_is_empty+0xfc> <== NEVER TAKEN
40019ecc: b0 10 3f ff mov -1, %i0
return -1;
assert(ret == fs_info->fat.vol.bps);
40019ed0: e2 14 00 00 lduh [ %l0 ], %l1
40019ed4: a3 2c 60 10 sll %l1, 0x10, %l1
40019ed8: b1 34 60 10 srl %l1, 0x10, %i0
40019edc: 80 a6 00 08 cmp %i0, %o0
40019ee0: 12 80 00 2e bne 40019f98 <msdos_dir_is_empty+0x130> <== NEVER TAKEN
40019ee4: 80 a6 20 00 cmp %i0, 0
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
40019ee8: 02 80 00 27 be 40019f84 <msdos_dir_is_empty+0x11c> <== NEVER TAKEN
40019eec: b8 10 20 00 clr %i4
40019ef0: ea 04 20 a0 ld [ %l0 + 0xa0 ], %l5
40019ef4: ba 10 00 15 mov %l5, %i5
* then consider it as empty.
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
40019ef8: f6 0f 40 00 ldub [ %i5 ], %i3
40019efc: 80 a6 e0 e5 cmp %i3, 0xe5
40019f00: 22 80 00 1c be,a 40019f70 <msdos_dir_is_empty+0x108> <== NEVER TAKEN
40019f04: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
40019f08: c2 0f 60 0b ldub [ %i5 + 0xb ], %g1
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
40019f0c: 82 08 60 3f and %g1, 0x3f, %g1
40019f10: 80 a0 60 0f cmp %g1, 0xf
40019f14: 02 80 00 16 be 40019f6c <msdos_dir_is_empty+0x104> <== NEVER TAKEN
40019f18: 90 10 00 1d mov %i5, %o0
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
40019f1c: 92 10 00 12 mov %l2, %o1
40019f20: 40 00 14 91 call 4001f164 <strncmp>
40019f24: 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) ||
40019f28: 80 a2 20 00 cmp %o0, 0
40019f2c: 22 80 00 11 be,a 40019f70 <msdos_dir_is_empty+0x108>
40019f30: 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)),
40019f34: 90 10 00 1d mov %i5, %o0
40019f38: 92 10 00 14 mov %l4, %o1
40019f3c: 40 00 14 8a call 4001f164 <strncmp>
40019f40: 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) ||
40019f44: 80 a2 20 00 cmp %o0, 0
40019f48: 22 80 00 0a be,a 40019f70 <msdos_dir_is_empty+0x108>
40019f4c: b8 07 20 20 add %i4, 0x20, %i4
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
40019f50: 80 a6 e0 00 cmp %i3, 0
40019f54: 12 80 00 04 bne 40019f64 <msdos_dir_is_empty+0xfc>
40019f58: b0 10 20 00 clr %i0
*/
return RC_OK;
}
j++;
}
*ret_val = true;
40019f5c: 82 10 20 01 mov 1, %g1
40019f60: c2 2e 80 00 stb %g1, [ %i2 ]
return RC_OK;
40019f64: 81 c7 e0 08 ret
40019f68: 81 e8 00 00 restore
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
i < fs_info->fat.vol.bps;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
40019f6c: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
40019f70: 80 a7 00 18 cmp %i4, %i0
40019f74: 0a bf ff e1 bcs 40019ef8 <msdos_dir_is_empty+0x90> <== ALWAYS TAKEN
40019f78: ba 07 60 20 add %i5, 0x20, %i5
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
40019f7c: 10 bf ff c6 b 40019e94 <msdos_dir_is_empty+0x2c> <== NOT EXECUTED
40019f80: a6 04 e0 01 inc %l3 <== NOT EXECUTED
40019f84: ea 04 20 a0 ld [ %l0 + 0xa0 ], %l5 <== NOT EXECUTED
40019f88: 10 bf ff c3 b 40019e94 <msdos_dir_is_empty+0x2c> <== NOT EXECUTED
40019f8c: a6 04 e0 01 inc %l3 <== NOT EXECUTED
}
*ret_val = true;
return RC_OK;
40019f90: 10 bf ff f3 b 40019f5c <msdos_dir_is_empty+0xf4> <== NOT EXECUTED
40019f94: b0 10 20 00 clr %i0 <== NOT EXECUTED
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
assert(ret == fs_info->fat.vol.bps);
40019f98: 11 10 00 b8 sethi %hi(0x4002e000), %o0 <== NOT EXECUTED
40019f9c: 15 10 00 b8 sethi %hi(0x4002e000), %o2 <== NOT EXECUTED
40019fa0: 17 10 00 b8 sethi %hi(0x4002e000), %o3 <== NOT EXECUTED
40019fa4: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
40019fa8: 92 10 23 65 mov 0x365, %o1 <== NOT EXECUTED
40019fac: 94 12 a3 b0 or %o2, 0x3b0, %o2 <== NOT EXECUTED
40019fb0: 7f ff af 13 call 40005bfc <__assert_func> <== NOT EXECUTED
40019fb4: 96 12 e3 48 or %o3, 0x348, %o3 <== NOT EXECUTED
4001c9fc <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)
{
4001c9fc: 9d e3 be 60 save %sp, -416, %sp <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
4001ca00: 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);
4001ca04: d0 1e 20 08 ldd [ %i0 + 8 ], %o0 <== NOT EXECUTED
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001ca08: ea 06 20 1c ld [ %i0 + 0x1c ], %l5 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
4001ca0c: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001ca10: 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)
{
4001ca14: a4 10 00 18 mov %i0, %l2 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
fat_file_fd_t *tmp_fat_fd = NULL;
4001ca18: c0 27 be d0 clr [ %fp + -304 ] <== NOT EXECUTED
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
4001ca1c: f0 00 60 08 ld [ %g1 + 8 ], %i0 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
4001ca20: 7f ff 95 f0 call 400021e0 <__divdi3> <== NOT EXECUTED
4001ca24: c0 27 be d4 clr [ %fp + -300 ] <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
4001ca28: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
4001ca2c: b6 10 00 09 mov %o1, %i3 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
4001ca30: 7f ff 97 11 call 40002674 <.udiv> <== NOT EXECUTED
4001ca34: 92 10 21 18 mov 0x118, %o1 <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
4001ca38: c2 05 60 20 ld [ %l5 + 0x20 ], %g1 <== NOT EXECUTED
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
4001ca3c: a3 2a 20 03 sll %o0, 3, %l1 <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
4001ca40: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
4001ca44: 91 2a 20 05 sll %o0, 5, %o0 <== NOT EXECUTED
4001ca48: 90 04 40 08 add %l1, %o0, %o0 <== NOT EXECUTED
4001ca4c: a3 2a 20 03 sll %o0, 3, %l1 <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
4001ca50: 02 80 00 f2 be 4001ce18 <msdos_dir_read+0x41c> <== NOT EXECUTED
4001ca54: a2 24 40 08 sub %l1, %o0, %l1 <== NOT EXECUTED
4001ca58: c2 16 20 06 lduh [ %i0 + 6 ], %g1 <== NOT EXECUTED
4001ca5c: c2 27 be c4 st %g1, [ %fp + -316 ] <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001ca60: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 <== NOT EXECUTED
4001ca64: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001ca68: 7f ff b6 e4 call 4000a5f8 <rtems_semaphore_obtain> <== NOT EXECUTED
4001ca6c: 94 10 20 00 clr %o2 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001ca70: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001ca74: 12 80 01 37 bne 4001cf50 <msdos_dir_read+0x554> <== NOT EXECUTED
4001ca78: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
4001ca7c: 02 80 00 3a be 4001cb64 <msdos_dir_read+0x168> <== NOT EXECUTED
4001ca80: b8 10 20 00 clr %i4 <== NOT EXECUTED
4001ca84: a6 10 20 00 clr %l3 <== NOT EXECUTED
4001ca88: a8 10 20 00 clr %l4 <== NOT EXECUTED
4001ca8c: c0 2f be cf clrb [ %fp + -305 ] <== NOT EXECUTED
4001ca90: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
4001ca94: a0 10 20 00 clr %l0 <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
4001ca98: d8 06 20 a0 ld [ %i0 + 0xa0 ], %o4 <== NOT EXECUTED
4001ca9c: d6 07 be c4 ld [ %fp + -316 ], %o3 <== NOT EXECUTED
4001caa0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001caa4: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
4001caa8: 7f ff db b4 call 40013978 <fat_file_read> <== NOT EXECUTED
4001caac: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001cab0: 80 a2 20 1f cmp %o0, 0x1f <== NOT EXECUTED
4001cab4: 04 80 01 1e ble 4001cf2c <msdos_dir_read+0x530> <== NOT EXECUTED
4001cab8: ac 10 00 08 mov %o0, %l6 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
4001cabc: fa 06 20 a0 ld [ %i0 + 0xa0 ], %i5 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
4001cac0: c4 0f 40 00 ldub [ %i5 ], %g2 <== NOT EXECUTED
4001cac4: 86 88 a0 ff andcc %g2, 0xff, %g3 <== NOT EXECUTED
4001cac8: 02 80 00 ce be 4001ce00 <msdos_dir_read+0x404> <== NOT EXECUTED
4001cacc: ae 10 20 00 clr %l7 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
4001cad0: 10 80 00 0f b 4001cb0c <msdos_dir_read+0x110> <== NOT EXECUTED
4001cad4: 80 a0 e0 e5 cmp %g3, 0xe5 <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
4001cad8: 80 a0 e0 0f cmp %g3, 0xf <== NOT EXECUTED
4001cadc: 02 80 00 28 be 4001cb7c <msdos_dir_read+0x180> <== NOT EXECUTED
4001cae0: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001cae4: ae 05 e0 20 add %l7, 0x20, %l7 <== NOT EXECUTED
4001cae8: 80 a5 c0 16 cmp %l7, %l6 <== NOT EXECUTED
4001caec: 1a 80 00 1a bcc 4001cb54 <msdos_dir_read+0x158> <== NOT EXECUTED
4001caf0: c2 07 be c4 ld [ %fp + -316 ], %g1 <== NOT EXECUTED
{
char* entry = (char*) fs_info->cl_buf + i;
4001caf4: fa 06 20 a0 ld [ %i0 + 0xa0 ], %i5 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
4001caf8: c4 0f 40 17 ldub [ %i5 + %l7 ], %g2 <== NOT EXECUTED
4001cafc: 86 88 a0 ff andcc %g2, 0xff, %g3 <== NOT EXECUTED
4001cb00: 02 80 00 c0 be 4001ce00 <msdos_dir_read+0x404> <== NOT EXECUTED
4001cb04: ba 07 40 17 add %i5, %l7, %i5 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
4001cb08: 80 a0 e0 e5 cmp %g3, 0xe5 <== NOT EXECUTED
4001cb0c: 22 bf ff f7 be,a 4001cae8 <msdos_dir_read+0xec> <== NOT EXECUTED
4001cb10: ae 05 e0 20 add %l7, 0x20, %l7 <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
4001cb14: c6 0f 60 0b ldub [ %i5 + 0xb ], %g3 <== NOT EXECUTED
4001cb18: b8 08 e0 08 and %g3, 8, %i4 <== NOT EXECUTED
4001cb1c: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
4001cb20: 12 bf ff ee bne 4001cad8 <msdos_dir_read+0xdc> <== NOT EXECUTED
4001cb24: 86 08 e0 3f and %g3, 0x3f, %g3 <== NOT EXECUTED
/*
* Check the attribute to see if the entry is for a long file
* name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
4001cb28: 80 a0 e0 0f cmp %g3, 0xf <== NOT EXECUTED
4001cb2c: 02 80 00 13 be 4001cb78 <msdos_dir_read+0x17c> <== NOT EXECUTED
4001cb30: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
4001cb34: 02 80 00 3c be 4001cc24 <msdos_dir_read+0x228> <== NOT EXECUTED
4001cb38: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001cb3c: ae 05 e0 20 add %l7, 0x20, %l7 <== NOT EXECUTED
* Skip active entries until get the entry to start from.
*/
if (start)
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
4001cb40: b6 06 ff ff add %i3, -1, %i3 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001cb44: 80 a5 c0 16 cmp %l7, %l6 <== NOT EXECUTED
4001cb48: 0a bf ff eb bcs 4001caf4 <msdos_dir_read+0xf8> <== NOT EXECUTED
4001cb4c: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
4001cb50: c2 07 be c4 ld [ %fp + -316 ], %g1 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
4001cb54: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
4001cb58: 12 bf ff d0 bne 4001ca98 <msdos_dir_read+0x9c> <== NOT EXECUTED
4001cb5c: a6 04 c0 01 add %l3, %g1, %l3 <== NOT EXECUTED
4001cb60: b8 10 00 10 mov %l0, %i4 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
4001cb64: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 <== NOT EXECUTED
4001cb68: 7f ff b6 f3 call 4000a734 <rtems_semaphore_release> <== NOT EXECUTED
4001cb6c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
return cmpltd;
}
4001cb70: 81 c7 e0 08 ret <== NOT EXECUTED
4001cb74: 81 e8 00 00 restore <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
4001cb78: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
4001cb7c: 02 80 00 93 be 4001cdc8 <msdos_dir_read+0x3cc> <== NOT EXECUTED
4001cb80: 86 08 a0 40 and %g2, 0x40, %g3 <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
4001cb84: c4 0f 40 00 ldub [ %i5 ], %g2 <== NOT EXECUTED
4001cb88: 84 08 a0 3f and %g2, 0x3f, %g2 <== NOT EXECUTED
4001cb8c: 80 a0 80 14 cmp %g2, %l4 <== NOT EXECUTED
4001cb90: 22 80 00 04 be,a 4001cba0 <msdos_dir_read+0x1a4> <== NOT EXECUTED
4001cb94: d8 0f 60 0d ldub [ %i5 + 0xd ], %o4 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
lfn_start = FAT_FILE_SHORT_NAME;
4001cb98: 10 bf ff d3 b 4001cae4 <msdos_dir_read+0xe8> <== NOT EXECUTED
4001cb9c: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
4001cba0: c4 0f be cf ldub [ %fp + -305 ], %g2 <== NOT EXECUTED
4001cba4: 86 0b 20 ff and %o4, 0xff, %g3 <== NOT EXECUTED
4001cba8: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
4001cbac: 32 bf ff ce bne,a 4001cae4 <msdos_dir_read+0xe8> <== NOT EXECUTED
4001cbb0: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
* The DOS maximum length is 255 characters without the
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
4001cbb4: a8 05 3f ff add %l4, -1, %l4 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
4001cbb8: 85 2d 20 02 sll %l4, 2, %g2 <== NOT EXECUTED
4001cbbc: 95 2d 20 04 sll %l4, 4, %o2 <== NOT EXECUTED
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
4001cbc0: ba 07 60 01 inc %i5 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
4001cbc4: 94 22 80 02 sub %o2, %g2, %o2 <== NOT EXECUTED
4001cbc8: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
4001cbcc: 94 02 80 14 add %o2, %l4, %o2 <== NOT EXECUTED
4001cbd0: 84 10 00 0a mov %o2, %g2 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001cbd4: 82 07 be e8 add %fp, -280, %g1 <== NOT EXECUTED
4001cbd8: 86 20 80 0a sub %g2, %o2, %g3 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
4001cbdc: 80 a0 a0 fe cmp %g2, 0xfe <== NOT EXECUTED
4001cbe0: 18 80 00 99 bgu 4001ce44 <msdos_dir_read+0x448> <== NOT EXECUTED
4001cbe4: 9e 00 40 02 add %g1, %g2, %o7 <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
4001cbe8: d6 0f 40 00 ldub [ %i5 ], %o3 <== NOT EXECUTED
4001cbec: d6 2b e0 14 stb %o3, [ %o7 + 0x14 ] <== NOT EXECUTED
if (*p == '\0')
4001cbf0: de 4f 40 00 ldsb [ %i5 ], %o7 <== NOT EXECUTED
4001cbf4: 80 a3 e0 00 cmp %o7, 0 <== NOT EXECUTED
4001cbf8: 02 80 00 93 be 4001ce44 <msdos_dir_read+0x448> <== NOT EXECUTED
4001cbfc: 84 00 a0 01 inc %g2 <== NOT EXECUTED
break;
switch (q)
4001cc00: 80 a0 e0 04 cmp %g3, 4 <== NOT EXECUTED
4001cc04: 02 80 00 92 be 4001ce4c <msdos_dir_read+0x450> <== NOT EXECUTED
4001cc08: 80 a0 e0 0a cmp %g3, 0xa <== NOT EXECUTED
4001cc0c: 02 80 00 93 be 4001ce58 <msdos_dir_read+0x45c> <== NOT EXECUTED
4001cc10: 80 a7 20 0d cmp %i4, 0xd <== NOT EXECUTED
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
4001cc14: 02 80 00 8c be 4001ce44 <msdos_dir_read+0x448> <== NOT EXECUTED
4001cc18: ba 07 60 02 add %i5, 2, %i5 <== NOT EXECUTED
4001cc1c: 10 bf ff ef b 4001cbd8 <msdos_dir_read+0x1dc> <== NOT EXECUTED
4001cc20: b8 07 20 01 inc %i4 <== NOT EXECUTED
* unfortunately there is no method to extract ino except to
* open fat-file descriptor :( ... so, open it
*/
/* get number of cluster we are working with */
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
4001cc24: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
4001cc28: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
4001cc2c: 96 10 00 13 mov %l3, %o3 <== NOT EXECUTED
4001cc30: 7f ff dc 46 call 40013d48 <fat_file_ioctl> <== NOT EXECUTED
4001cc34: 98 07 be d4 add %fp, -300, %o4 <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
4001cc38: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4001cc3c: 12 bf ff ca bne 4001cb64 <msdos_dir_read+0x168> <== NOT EXECUTED
4001cc40: c4 07 be d4 ld [ %fp + -300 ], %g2 <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4001cc44: 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;
4001cc48: c4 27 be d8 st %g2, [ %fp + -296 ] <== NOT EXECUTED
4001cc4c: c2 27 be e0 st %g1, [ %fp + -288 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4001cc50: c2 27 be e4 st %g1, [ %fp + -284 ] <== NOT EXECUTED
dir_pos.sname.ofs = i;
4001cc54: ee 27 be dc st %l7, [ %fp + -292 ] <== NOT EXECUTED
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
4001cc58: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001cc5c: 92 07 be d8 add %fp, -296, %o1 <== NOT EXECUTED
4001cc60: 7f ff da 92 call 400136a8 <fat_file_open> <== NOT EXECUTED
4001cc64: 94 07 be d0 add %fp, -304, %o2 <== NOT EXECUTED
if (rc != RC_OK)
4001cc68: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4001cc6c: 12 bf ff be bne 4001cb64 <msdos_dir_read+0x168> <== NOT EXECUTED
4001cc70: c4 07 be d0 ld [ %fp + -304 ], %g2 <== NOT EXECUTED
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
4001cc74: 82 10 21 18 mov 0x118, %g1 <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
4001cc78: c4 00 a0 0c ld [ %g2 + 0xc ], %g2 <== NOT EXECUTED
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
4001cc7c: c0 27 be f0 clr [ %fp + -272 ] <== NOT EXECUTED
4001cc80: e0 27 be f4 st %l0, [ %fp + -268 ] <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
4001cc84: 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)
4001cc88: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
4001cc8c: 02 80 00 35 be 4001cd60 <msdos_dir_read+0x364> <== NOT EXECUTED
4001cc90: c4 27 be e8 st %g2, [ %fp + -280 ] <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001cc94: 9e 07 60 0b add %i5, 0xb, %o7 <== NOT EXECUTED
4001cc98: 84 10 00 1d mov %i5, %g2 <== NOT EXECUTED
4001cc9c: b8 10 20 00 clr %i4 <== NOT EXECUTED
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
4001cca0: 10 80 00 06 b 4001ccb8 <msdos_dir_read+0x2bc> <== NOT EXECUTED
4001cca4: 86 10 20 00 clr %g3 <== NOT EXECUTED
4001cca8: 80 a0 00 0c cmp %g0, %o4 <== NOT EXECUTED
4001ccac: 86 40 3f ff addx %g0, -1, %g3 <== NOT EXECUTED
4001ccb0: 86 08 e0 80 and %g3, 0x80, %g3 <== NOT EXECUTED
4001ccb4: 86 00 ff 80 add %g3, -128, %g3 <== NOT EXECUTED
4001ccb8: d8 08 80 00 ldub [ %g2 ], %o4 <== NOT EXECUTED
4001ccbc: b8 0f 20 ff and %i4, 0xff, %i4 <== NOT EXECUTED
4001ccc0: b9 37 20 01 srl %i4, 1, %i4 <== NOT EXECUTED
4001ccc4: b8 03 00 1c add %o4, %i4, %i4 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
4001ccc8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
4001cccc: 86 07 00 03 add %i4, %g3, %g3 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
4001ccd0: 80 a0 80 0f cmp %g2, %o7 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
4001ccd4: 98 08 e0 01 and %g3, 1, %o4 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
4001ccd8: 12 bf ff f4 bne 4001cca8 <msdos_dir_read+0x2ac> <== NOT EXECUTED
4001ccdc: b8 10 00 03 mov %g3, %i4 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
4001cce0: c2 0f be cf ldub [ %fp + -305 ], %g1 <== NOT EXECUTED
4001cce4: b8 18 40 1c xor %g1, %i4, %i4 <== NOT EXECUTED
4001cce8: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
4001ccec: 12 80 00 1e bne 4001cd64 <msdos_dir_read+0x368> <== NOT EXECUTED
4001ccf0: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001ccf4: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
4001ccf8: 32 80 00 1c bne,a 4001cd68 <msdos_dir_read+0x36c> <== NOT EXECUTED
4001ccfc: b4 07 40 09 add %i5, %o1, %i2 <== NOT EXECUTED
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
tmp_dirent.d_name, entry); /* src text */
}
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
4001cd00: 40 00 08 e7 call 4001f09c <strlen> <== NOT EXECUTED
4001cd04: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
4001cd08: d0 37 be fa sth %o0, [ %fp + -262 ] <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
4001cd0c: 90 06 40 10 add %i1, %l0, %o0 <== NOT EXECUTED
4001cd10: 92 07 be e8 add %fp, -280, %o1 <== NOT EXECUTED
4001cd14: 40 00 04 c4 call 4001e024 <memcpy> <== NOT EXECUTED
4001cd18: 94 10 21 18 mov 0x118, %o2 <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
4001cd1c: c4 1c a0 08 ldd [ %l2 + 8 ], %g2 <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
4001cd20: 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);
4001cd24: ba 80 e1 18 addcc %g3, 0x118, %i5 <== NOT EXECUTED
4001cd28: b8 40 a0 00 addx %g2, 0, %i4 <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
4001cd2c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
4001cd30: f8 3c a0 08 std %i4, [ %l2 + 8 ] <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
4001cd34: 7f ff db d7 call 40013c90 <fat_file_close> <== NOT EXECUTED
4001cd38: a0 04 21 18 add %l0, 0x118, %l0 <== NOT EXECUTED
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
4001cd3c: a2 04 7e e8 add %l1, -280, %l1 <== NOT EXECUTED
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
if (rc != RC_OK)
4001cd40: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001cd44: 12 bf ff 88 bne 4001cb64 <msdos_dir_read+0x168> <== NOT EXECUTED
4001cd48: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
4001cd4c: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
4001cd50: 32 bf ff 66 bne,a 4001cae8 <msdos_dir_read+0xec> <== NOT EXECUTED
4001cd54: ae 05 e0 20 add %l7, 0x20, %l7 <== NOT EXECUTED
4001cd58: 10 bf ff 83 b 4001cb64 <msdos_dir_read+0x168> <== NOT EXECUTED
4001cd5c: b8 10 00 10 mov %l0, %i4 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
4001cd60: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001cd64: b4 07 40 09 add %i5, %o1, %i2 <== NOT EXECUTED
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
4001cd68: c4 4e bf ff ldsb [ %i2 + -1 ], %g2 <== NOT EXECUTED
4001cd6c: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
4001cd70: 12 80 00 3d bne 4001ce64 <msdos_dir_read+0x468> <== NOT EXECUTED
4001cd74: 03 10 00 bb sethi %hi(0x4002ec00), %g1 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
4001cd78: 92 82 7f ff addcc %o1, -1, %o1 <== NOT EXECUTED
4001cd7c: 32 bf ff fb bne,a 4001cd68 <msdos_dir_read+0x36c> <== NOT EXECUTED
4001cd80: b4 07 40 09 add %i5, %o1, %i2 <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
4001cd84: 86 07 be fc add %fp, -260, %g3 <== NOT EXECUTED
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
4001cd88: c4 4f 60 0a ldsb [ %i5 + 0xa ], %g2 <== NOT EXECUTED
4001cd8c: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
4001cd90: 12 80 00 46 bne 4001cea8 <msdos_dir_read+0x4ac> <== NOT EXECUTED
4001cd94: 98 10 20 03 mov 3, %o4 <== NOT EXECUTED
4001cd98: c4 4f 60 09 ldsb [ %i5 + 9 ], %g2 <== NOT EXECUTED
4001cd9c: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
4001cda0: 32 80 00 42 bne,a 4001cea8 <msdos_dir_read+0x4ac> <== NOT EXECUTED
4001cda4: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
4001cda8: c4 4f 60 08 ldsb [ %i5 + 8 ], %g2 <== NOT EXECUTED
4001cdac: 80 a0 a0 20 cmp %g2, 0x20 <== NOT EXECUTED
4001cdb0: 12 80 00 3e bne 4001cea8 <msdos_dir_read+0x4ac> <== NOT EXECUTED
4001cdb4: 98 10 20 01 mov 1, %o4 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
4001cdb8: c0 28 c0 00 clrb [ %g3 ] <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
4001cdbc: d2 37 be fa sth %o1, [ %fp + -262 ] <== NOT EXECUTED
4001cdc0: 10 bf ff d3 b 4001cd0c <msdos_dir_read+0x310> <== NOT EXECUTED
4001cdc4: b4 10 3f ff mov -1, %i2 <== NOT EXECUTED
if (lfn_start == FAT_FILE_SHORT_NAME)
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
4001cdc8: 80 88 e0 ff btst 0xff, %g3 <== NOT EXECUTED
4001cdcc: 22 bf ff 47 be,a 4001cae8 <msdos_dir_read+0xec> <== NOT EXECUTED
4001cdd0: ae 05 e0 20 add %l7, 0x20, %l7 <== NOT EXECUTED
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
4001cdd4: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001cdd8: b4 05 c0 13 add %l7, %l3, %i2 <== NOT EXECUTED
/*
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
4001cddc: a8 08 a0 3f and %g2, 0x3f, %l4 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
4001cde0: b5 36 a0 05 srl %i2, 5, %i2 <== NOT EXECUTED
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
4001cde4: c2 2f be cf stb %g1, [ %fp + -305 ] <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
4001cde8: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
4001cdec: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001cdf0: 40 00 04 ca call 4001e118 <memset> <== NOT EXECUTED
4001cdf4: 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) &
4001cdf8: 10 bf ff 64 b 4001cb88 <msdos_dir_read+0x18c> <== NOT EXECUTED
4001cdfc: c4 0f 40 00 ldub [ %i5 ], %g2 <== NOT EXECUTED
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
rtems_semaphore_release(fs_info->vol_sema);
4001ce00: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 <== NOT EXECUTED
4001ce04: 7f ff b6 4c call 4000a734 <rtems_semaphore_release> <== NOT EXECUTED
4001ce08: b8 10 00 10 mov %l0, %i4 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
4001ce0c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
4001ce10: 81 c7 e0 08 ret <== NOT EXECUTED
4001ce14: 81 e8 00 00 restore <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
4001ce18: c2 05 60 24 ld [ %l5 + 0x24 ], %g1 <== NOT EXECUTED
4001ce1c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001ce20: 32 bf ff 0f bne,a 4001ca5c <msdos_dir_read+0x60> <== NOT EXECUTED
4001ce24: c2 16 20 06 lduh [ %i0 + 6 ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
4001ce28: c2 0e 20 0e ldub [ %i0 + 0xe ], %g1 <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
4001ce2c: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
4001ce30: 22 bf ff 0b be,a 4001ca5c <msdos_dir_read+0x60> <== NOT EXECUTED
4001ce34: c2 16 20 06 lduh [ %i0 + 6 ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
4001ce38: c2 05 60 18 ld [ %l5 + 0x18 ], %g1 <== NOT EXECUTED
4001ce3c: 10 bf ff 09 b 4001ca60 <msdos_dir_read+0x64> <== NOT EXECUTED
4001ce40: c2 27 be c4 st %g1, [ %fp + -316 ] <== NOT EXECUTED
if (o >= (sizeof(tmp_dirent.d_name) - 1))
break;
tmp_dirent.d_name[o++] = *p;
if (*p == '\0')
4001ce44: 10 bf ff c2 b 4001cd4c <msdos_dir_read+0x350> <== NOT EXECUTED
4001ce48: d8 2f be cf stb %o4, [ %fp + -305 ] <== NOT EXECUTED
break;
switch (q)
{
case 4:
p += 5;
4001ce4c: ba 07 60 05 add %i5, 5, %i5 <== NOT EXECUTED
4001ce50: 10 bf ff 61 b 4001cbd4 <msdos_dir_read+0x1d8> <== NOT EXECUTED
4001ce54: b8 07 20 01 inc %i4 <== NOT EXECUTED
break;
case 10:
p += 4;
4001ce58: ba 07 60 04 add %i5, 4, %i5 <== NOT EXECUTED
4001ce5c: 10 bf ff 5e b 4001cbd4 <msdos_dir_read+0x1d8> <== NOT EXECUTED
4001ce60: b8 07 20 01 inc %i4 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001ce64: 84 10 00 1d mov %i5, %g2 <== NOT EXECUTED
4001ce68: d8 00 61 48 ld [ %g1 + 0x148 ], %o4 <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
4001ce6c: 10 80 00 06 b 4001ce84 <msdos_dir_read+0x488> <== NOT EXECUTED
4001ce70: 86 07 be fc add %fp, -260, %g3 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
4001ce74: f8 28 c0 00 stb %i4, [ %g3 ] <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
4001ce78: 80 a0 80 1a cmp %g2, %i2 <== NOT EXECUTED
4001ce7c: 02 bf ff c3 be 4001cd88 <msdos_dir_read+0x38c> <== NOT EXECUTED
4001ce80: 86 00 e0 01 inc %g3 <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
4001ce84: f8 08 80 00 ldub [ %g2 ], %i4 <== NOT EXECUTED
4001ce88: 9e 03 00 1c add %o4, %i4, %o7 <== NOT EXECUTED
4001ce8c: de 0b e0 01 ldub [ %o7 + 1 ], %o7 <== NOT EXECUTED
4001ce90: 9e 0b e0 03 and %o7, 3, %o7 <== NOT EXECUTED
4001ce94: 80 a3 e0 01 cmp %o7, 1 <== NOT EXECUTED
4001ce98: 12 bf ff f7 bne 4001ce74 <msdos_dir_read+0x478> <== NOT EXECUTED
4001ce9c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
4001cea0: 10 bf ff f5 b 4001ce74 <msdos_dir_read+0x478> <== NOT EXECUTED
4001cea4: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
4001cea8: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED
4001ceac: 96 00 e0 01 add %g3, 1, %o3 <== NOT EXECUTED
4001ceb0: c2 28 c0 00 stb %g1, [ %g3 ] <== NOT EXECUTED
len += i + 1; /* extension + dot */
4001ceb4: 94 03 20 01 add %o4, 1, %o2 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001ceb8: b8 03 20 08 add %o4, 8, %i4 <== NOT EXECUTED
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
4001cebc: 94 02 40 0a add %o1, %o2, %o2 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN;
4001cec0: 84 07 60 08 add %i5, 8, %g2 <== NOT EXECUTED
4001cec4: 03 10 00 bb sethi %hi(0x4002ec00), %g1 <== NOT EXECUTED
while (i-- > 0) {
4001cec8: 92 03 3f ff add %o4, -1, %o1 <== NOT EXECUTED
4001cecc: de 00 61 48 ld [ %g1 + 0x148 ], %o7 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001ced0: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
4001ced4: 10 80 00 06 b 4001ceec <msdos_dir_read+0x4f0> <== NOT EXECUTED
4001ced8: 86 10 00 0b mov %o3, %g3 <== NOT EXECUTED
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
4001cedc: f8 28 c0 00 stb %i4, [ %g3 ] <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
4001cee0: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED
4001cee4: 02 80 00 0e be 4001cf1c <msdos_dir_read+0x520> <== NOT EXECUTED
4001cee8: 86 00 e0 01 inc %g3 <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
4001ceec: f8 08 80 00 ldub [ %g2 ], %i4 <== NOT EXECUTED
4001cef0: b4 03 c0 1c add %o7, %i4, %i2 <== NOT EXECUTED
4001cef4: f4 0e a0 01 ldub [ %i2 + 1 ], %i2 <== NOT EXECUTED
4001cef8: b4 0e a0 03 and %i2, 3, %i2 <== NOT EXECUTED
4001cefc: 80 a6 a0 01 cmp %i2, 1 <== NOT EXECUTED
4001cf00: 12 bf ff f7 bne 4001cedc <msdos_dir_read+0x4e0> <== NOT EXECUTED
4001cf04: 84 00 a0 01 inc %g2 <== NOT EXECUTED
4001cf08: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
4001cf0c: f8 28 c0 00 stb %i4, [ %g3 ] <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
4001cf10: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED
4001cf14: 12 bf ff f6 bne 4001ceec <msdos_dir_read+0x4f0> <== NOT EXECUTED
4001cf18: 86 00 e0 01 inc %g3 <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
4001cf1c: 94 02 a0 01 inc %o2 <== NOT EXECUTED
4001cf20: 86 02 c0 0c add %o3, %o4, %g3 <== NOT EXECUTED
4001cf24: 10 bf ff a5 b 4001cdb8 <msdos_dir_read+0x3bc> <== NOT EXECUTED
4001cf28: 92 02 80 09 add %o2, %o1, %o1 <== NOT EXECUTED
*/
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
rtems_semaphore_release(fs_info->vol_sema);
4001cf2c: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 <== NOT EXECUTED
4001cf30: 7f ff b6 01 call 4000a734 <rtems_semaphore_release> <== NOT EXECUTED
4001cf34: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4001cf38: 40 00 01 96 call 4001d590 <__errno> <== NOT EXECUTED
4001cf3c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
4001cf40: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001cf44: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001cf48: 81 c7 e0 08 ret <== NOT EXECUTED
4001cf4c: 81 e8 00 00 restore <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
4001cf50: 40 00 01 90 call 4001d590 <__errno> <== NOT EXECUTED
4001cf54: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
4001cf58: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001cf5c: 10 bf ff ac b 4001ce0c <msdos_dir_read+0x410> <== NOT EXECUTED
4001cf60: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001cf64 <msdos_dir_stat>:
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
4001cf64: 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;
4001cf68: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
4001cf6c: 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;
4001cf70: 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,
4001cf74: 92 10 20 00 clr %o1
4001cf78: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
4001cf7c: 7f ff b5 9f call 4000a5f8 <rtems_semaphore_obtain>
4001cf80: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001cf84: 80 a2 20 00 cmp %o0, 0
4001cf88: 12 80 00 1a bne 4001cff0 <msdos_dir_stat+0x8c> <== NEVER TAKEN
4001cf8c: 01 00 00 00 nop
static inline dev_t rtems_disk_get_device_identifier(
const rtems_disk_device *dd
)
{
return dd->dev;
4001cf90: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
4001cf94: f6 17 40 00 lduh [ %i5 ], %i3
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
4001cf98: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
4001cf9c: f4 07 20 0c ld [ %i4 + 0xc ], %i2
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4001cfa0: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
buf->st_mtime = fat_fd->mtime;
4001cfa4: c8 07 20 40 ld [ %i4 + 0x40 ], %g4
rtems_semaphore_release(fs_info->vol_sema);
4001cfa8: 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);
4001cfac: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
4001cfb0: 05 00 00 10 sethi %hi(0x4000), %g2
4001cfb4: 84 10 a1 ff or %g2, 0x1ff, %g2 ! 41ff <PROM_START+0x41ff>
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
4001cfb8: bb 30 60 09 srl %g1, 9, %i5
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
4001cfbc: f4 26 60 08 st %i2, [ %i1 + 8 ]
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
4001cfc0: c0 26 60 18 clr [ %i1 + 0x18 ]
4001cfc4: c0 26 60 1c clr [ %i1 + 0x1c ]
buf->st_size = fat_fd->fat_file_size;
4001cfc8: c0 26 60 20 clr [ %i1 + 0x20 ]
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
4001cfcc: c4 26 60 0c st %g2, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4001cfd0: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
4001cfd4: fa 26 60 44 st %i5, [ %i1 + 0x44 ]
buf->st_blksize = fs_info->fat.vol.bps;
4001cfd8: f6 26 60 40 st %i3, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
4001cfdc: c8 26 60 30 st %g4, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
4001cfe0: 7f ff b5 d5 call 4000a734 <rtems_semaphore_release>
4001cfe4: b0 10 20 00 clr %i0
return RC_OK;
}
4001cfe8: 81 c7 e0 08 ret
4001cfec: 81 e8 00 00 restore
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
4001cff0: 40 00 01 68 call 4001d590 <__errno> <== NOT EXECUTED
4001cff4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001cff8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001cffc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001d000: 81 c7 e0 08 ret <== NOT EXECUTED
4001d004: 81 e8 00 00 restore <== NOT EXECUTED
400196bc <msdos_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
400196bc: 9d e3 bf a0 save %sp, -96, %sp
400196c0: 80 a6 e0 01 cmp %i3, 1
400196c4: 02 80 00 17 be 40019720 <msdos_eval_token+0x64>
400196c8: ba 10 00 18 mov %i0, %i5
rtems_filesystem_eval_path_clear_token(ctx);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
} else {
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc(ctx);
int rc = msdos_find_name(currentloc, token, tokenlen);
400196cc: 90 07 60 18 add %i5, 0x18, %o0
400196d0: 92 10 00 1a mov %i2, %o1
400196d4: 40 00 06 2e call 4001af8c <msdos_find_name>
400196d8: 94 10 00 1b mov %i3, %o2
if (rc == RC_OK) {
400196dc: 80 a2 20 00 cmp %o0, 0
400196e0: 12 80 00 17 bne 4001973c <msdos_eval_token+0x80>
400196e4: 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)
400196e8: 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;
400196ec: 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)
400196f0: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
400196f4: c0 27 60 0c clr [ %i5 + 0xc ]
400196f8: 80 a0 a0 00 cmp %g2, 0
400196fc: 12 80 00 1a bne 40019764 <msdos_eval_token+0xa8>
40019700: c2 00 60 08 ld [ %g1 + 8 ], %g1
loc->handlers = fs_info->directory_handlers;
40019704: c2 00 60 94 ld [ %g1 + 0x94 ], %g1
40019708: 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)) {
4001970c: c2 07 60 04 ld [ %i5 + 4 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
40019710: 80 a0 00 01 cmp %g0, %g1
40019714: b0 60 3f ff subx %g0, -1, %i0
40019718: 81 c7 e0 08 ret
4001971c: 81 e8 00 00 restore
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
40019720: c2 4e 80 00 ldsb [ %i2 ], %g1
40019724: 80 a0 60 2e cmp %g1, 0x2e
40019728: 12 bf ff ea bne 400196d0 <msdos_eval_token+0x14>
4001972c: 90 07 60 18 add %i5, 0x18, %o0
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
40019730: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_filesystem_eval_path_error(ctx, 0);
}
}
return status;
}
40019734: 81 c7 e0 08 ret
40019738: 91 e8 20 00 restore %g0, 0, %o0
rtems_filesystem_eval_path_clear_token(ctx);
msdos_set_handlers(currentloc);
if (rtems_filesystem_eval_path_has_path(ctx)) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else if (rc == MSDOS_NAME_NOT_FOUND_ERR) {
4001973c: 82 10 61 01 or %g1, 0x101, %g1
40019740: 80 a2 00 01 cmp %o0, %g1
40019744: 02 bf ff f5 be 40019718 <msdos_eval_token+0x5c> <== ALWAYS TAKEN
40019748: b0 10 20 02 mov 2, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
} else {
rtems_filesystem_eval_path_error(ctx, 0);
4001974c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40019750: 92 10 20 00 clr %o1 <== NOT EXECUTED
40019754: 7f ff b6 11 call 40006f98 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40019758: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
4001975c: 81 c7 e0 08 ret <== NOT EXECUTED
40019760: 81 e8 00 00 restore <== NOT EXECUTED
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
loc->handlers = fs_info->directory_handlers;
else
loc->handlers = fs_info->file_handlers;
40019764: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
40019768: 10 bf ff e9 b 4001970c <msdos_eval_token+0x50>
4001976c: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
4001d064 <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)
{
4001d064: 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;
4001d068: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001d06c: 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;
4001d070: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001d074: 94 10 20 00 clr %o2
4001d078: 7f ff b5 60 call 4000a5f8 <rtems_semaphore_obtain>
4001d07c: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001d080: 80 a2 20 00 cmp %o0, 0
4001d084: 12 80 00 09 bne 4001d0a8 <msdos_file_close+0x44> <== NEVER TAKEN
4001d088: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
rc = msdos_file_update(iop);
4001d08c: 7f ff ff df call 4001d008 <msdos_file_update>
4001d090: 90 10 00 18 mov %i0, %o0
4001d094: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
4001d098: 7f ff b5 a7 call 4000a734 <rtems_semaphore_release>
4001d09c: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
4001d0a0: 81 c7 e0 08 ret
4001d0a4: 81 e8 00 00 restore
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
4001d0a8: 40 00 01 3a call 4001d590 <__errno> <== NOT EXECUTED
4001d0ac: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001d0b0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001d0b4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001d0b8: 81 c7 e0 08 ret <== NOT EXECUTED
4001d0bc: 81 e8 00 00 restore <== NOT EXECUTED
4001d2c8 <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)
{
4001d2c8: 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;
4001d2cc: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001d2d0: 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;
4001d2d4: 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,
4001d2d8: 92 10 20 00 clr %o1
4001d2dc: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
4001d2e0: 7f ff b4 c6 call 4000a5f8 <rtems_semaphore_obtain>
4001d2e4: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001d2e8: 80 a2 20 00 cmp %o0, 0
4001d2ec: 12 80 00 31 bne 4001d3b0 <msdos_file_ftruncate+0xe8> <== NEVER TAKEN
4001d2f0: 80 a2 00 19 cmp %o0, %i1
rtems_set_errno_and_return_minus_one(EIO);
old_length = fat_fd->fat_file_size;
if (length < old_length) {
4001d2f4: 14 80 00 1f bg 4001d370 <msdos_file_ftruncate+0xa8> <== NEVER TAKEN
4001d2f8: f6 07 20 18 ld [ %i4 + 0x18 ], %i3
4001d2fc: 80 a2 00 19 cmp %o0, %i1
4001d300: 12 80 00 06 bne 4001d318 <msdos_file_ftruncate+0x50> <== NEVER TAKEN
4001d304: 90 10 00 1d mov %i5, %o0
4001d308: 80 a6 c0 1a cmp %i3, %i2
4001d30c: 18 80 00 1b bgu 4001d378 <msdos_file_ftruncate+0xb0>
4001d310: 92 10 00 1c mov %i4, %o1
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
} else {
uint32_t new_length;
rc = fat_file_extend(&fs_info->fat,
4001d314: 90 10 00 1d mov %i5, %o0
4001d318: 92 10 00 1c mov %i4, %o1
4001d31c: 94 10 20 01 mov 1, %o2
4001d320: 96 10 00 1a mov %i2, %o3
4001d324: 7f ff da be call 40013e1c <fat_file_extend>
4001d328: 98 07 bf fc add %fp, -4, %o4
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
4001d32c: b0 92 20 00 orcc %o0, 0, %i0
4001d330: 12 80 00 17 bne 4001d38c <msdos_file_ftruncate+0xc4> <== NEVER TAKEN
4001d334: 80 a6 00 19 cmp %i0, %i1
4001d338: 02 80 00 19 be 4001d39c <msdos_file_ftruncate+0xd4> <== ALWAYS TAKEN
4001d33c: c2 07 bf fc ld [ %fp + -4 ], %g1
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
4001d340: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001d344: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4001d348: 7f ff da 11 call 40013b8c <fat_file_truncate> <== NOT EXECUTED
4001d34c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
errno = ENOSPC;
4001d350: 40 00 00 90 call 4001d590 <__errno> <== NOT EXECUTED
4001d354: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001d358: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
4001d35c: 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);
4001d360: 7f ff b4 f5 call 4000a734 <rtems_semaphore_release> <== NOT EXECUTED
4001d364: d0 07 60 9c ld [ %i5 + 0x9c ], %o0 <== NOT EXECUTED
return rc;
}
4001d368: 81 c7 e0 08 ret <== NOT EXECUTED
4001d36c: 81 e8 00 00 restore <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
old_length = fat_fd->fat_file_size;
if (length < old_length) {
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
4001d370: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001d374: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001d378: 7f ff da 05 call 40013b8c <fat_file_truncate>
4001d37c: 94 10 00 1a mov %i2, %o2
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK) {
4001d380: b0 92 20 00 orcc %o0, 0, %i0
4001d384: 22 80 00 02 be,a 4001d38c <msdos_file_ftruncate+0xc4> <== ALWAYS TAKEN
4001d388: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
fat_fd->fat_file_size = length;
}
rtems_semaphore_release(fs_info->vol_sema);
4001d38c: 7f ff b4 ea call 4000a734 <rtems_semaphore_release>
4001d390: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
4001d394: 81 c7 e0 08 ret
4001d398: 81 e8 00 00 restore
rc = fat_file_extend(&fs_info->fat,
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
4001d39c: 80 a0 40 1a cmp %g1, %i2
4001d3a0: 12 bf ff e9 bne 4001d344 <msdos_file_ftruncate+0x7c> <== NEVER TAKEN
4001d3a4: 92 10 00 1c mov %i4, %o1
rc = -1;
}
}
if (rc == RC_OK) {
fat_fd->fat_file_size = length;
4001d3a8: 10 bf ff f9 b 4001d38c <msdos_file_ftruncate+0xc4>
4001d3ac: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
uint32_t old_length;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
4001d3b0: 40 00 00 78 call 4001d590 <__errno> <== NOT EXECUTED
4001d3b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001d3b8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001d3bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001d3c0: 81 c7 e0 08 ret <== NOT EXECUTED
4001d3c4: 81 e8 00 00 restore <== NOT EXECUTED
4001d0c0 <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)
{
4001d0c0: 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;
4001d0c4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001d0c8: 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;
4001d0cc: 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,
4001d0d0: 92 10 20 00 clr %o1
4001d0d4: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
4001d0d8: 7f ff b5 48 call 4000a5f8 <rtems_semaphore_obtain>
4001d0dc: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001d0e0: 80 a2 20 00 cmp %o0, 0
4001d0e4: 12 80 00 12 bne 4001d12c <msdos_file_read+0x6c> <== NEVER TAKEN
4001d0e8: 98 10 00 19 mov %i1, %o4
rtems_set_errno_and_return_minus_one(EIO);
ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
4001d0ec: d4 06 20 0c ld [ %i0 + 0xc ], %o2
4001d0f0: 90 10 00 10 mov %l0, %o0
4001d0f4: 92 10 00 1d mov %i5, %o1
4001d0f8: 7f ff da 20 call 40013978 <fat_file_read>
4001d0fc: 96 10 00 1a mov %i2, %o3
buffer);
if (ret > 0)
4001d100: b2 92 20 00 orcc %o0, 0, %i1
4001d104: 04 80 00 06 ble 4001d11c <msdos_file_read+0x5c>
4001d108: 85 3e 60 1f sra %i1, 0x1f, %g2
iop->offset += ret;
4001d10c: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
4001d110: b6 87 40 19 addcc %i5, %i1, %i3
4001d114: b4 47 00 02 addx %i4, %g2, %i2
4001d118: f4 3e 20 08 std %i2, [ %i0 + 8 ]
rtems_semaphore_release(fs_info->vol_sema);
4001d11c: 7f ff b5 86 call 4000a734 <rtems_semaphore_release>
4001d120: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
return ret;
}
4001d124: 81 c7 e0 08 ret
4001d128: 91 e8 00 19 restore %g0, %i1, %o0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
4001d12c: 40 00 01 19 call 4001d590 <__errno> <== NOT EXECUTED
4001d130: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
4001d134: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001d138: 10 bf ff fb b 4001d124 <msdos_file_read+0x64> <== NOT EXECUTED
4001d13c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001d218 <msdos_file_stat>:
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
4001d218: 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;
4001d21c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
4001d220: 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;
4001d224: 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,
4001d228: 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;
4001d22c: f6 17 60 06 lduh [ %i5 + 6 ], %i3
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001d230: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
4001d234: 94 10 20 00 clr %o2
4001d238: 7f ff b4 f0 call 4000a5f8 <rtems_semaphore_obtain>
4001d23c: b6 06 ff ff add %i3, -1, %i3
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001d240: 80 a2 20 00 cmp %o0, 0
4001d244: 12 80 00 1b bne 4001d2b0 <msdos_file_stat+0x98> <== NEVER TAKEN
4001d248: 01 00 00 00 nop
4001d24c: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
4001d250: f0 07 20 0c ld [ %i4 + 0xc ], %i0
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
4001d254: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
4001d258: f4 17 60 06 lduh [ %i5 + 6 ], %i2
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4001d25c: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
buf->st_mtime = fat_fd->mtime;
4001d260: c8 07 20 40 ld [ %i4 + 0x40 ], %g4
rtems_semaphore_release(fs_info->vol_sema);
4001d264: 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);
4001d268: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
4001d26c: 05 00 00 20 sethi %hi(0x8000), %g2
4001d270: 84 10 a1 ff or %g2, 0x1ff, %g2 ! 81ff <PROM_START+0x81ff>
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
4001d274: ba 06 c0 01 add %i3, %g1, %i5
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
4001d278: f0 26 60 08 st %i0, [ %i1 + 8 ]
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
4001d27c: b6 2f 40 1b andn %i5, %i3, %i3
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
4001d280: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
4001d284: b7 36 e0 09 srl %i3, 9, %i3
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
4001d288: c0 26 60 1c clr [ %i1 + 0x1c ]
buf->st_size = fat_fd->fat_file_size;
4001d28c: c0 26 60 20 clr [ %i1 + 0x20 ]
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
4001d290: c4 26 60 0c st %g2, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4001d294: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
4001d298: f4 3e 60 40 std %i2, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
4001d29c: c8 26 60 30 st %g4, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
4001d2a0: 7f ff b5 25 call 4000a734 <rtems_semaphore_release>
4001d2a4: b0 10 20 00 clr %i0
return RC_OK;
}
4001d2a8: 81 c7 e0 08 ret
4001d2ac: 81 e8 00 00 restore
uint32_t cl_mask = fs_info->fat.vol.bpc - 1;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
4001d2b0: 40 00 00 b8 call 4001d590 <__errno> <== NOT EXECUTED
4001d2b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001d2b8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001d2bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001d2c0: 81 c7 e0 08 ret <== NOT EXECUTED
4001d2c4: 81 e8 00 00 restore <== NOT EXECUTED
4001d3c8 <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
4001d3c8: 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;
4001d3cc: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001d3d0: 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;
4001d3d4: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001d3d8: 94 10 20 00 clr %o2
4001d3dc: 7f ff b4 87 call 4000a5f8 <rtems_semaphore_obtain>
4001d3e0: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001d3e4: 80 a2 20 00 cmp %o0, 0
4001d3e8: 12 80 00 0d bne 4001d41c <msdos_file_sync+0x54> <== NEVER TAKEN
4001d3ec: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
rc = msdos_file_update(iop);
4001d3f0: 7f ff ff 06 call 4001d008 <msdos_file_update>
4001d3f4: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
4001d3f8: b0 92 20 00 orcc %o0, 0, %i0
4001d3fc: 12 80 00 04 bne 4001d40c <msdos_file_sync+0x44> <== NEVER TAKEN
4001d400: 01 00 00 00 nop
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = fat_sync(&fs_info->fat);
4001d404: 7f ff df c8 call 40015324 <fat_sync>
4001d408: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release(fs_info->vol_sema);
4001d40c: 7f ff b4 ca call 4000a734 <rtems_semaphore_release>
4001d410: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return RC_OK;
}
4001d414: 81 c7 e0 08 ret
4001d418: 81 e8 00 00 restore
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
4001d41c: 40 00 00 5d call 4001d590 <__errno> <== NOT EXECUTED
4001d420: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001d424: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001d428: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001d42c: 81 c7 e0 08 ret <== NOT EXECUTED
4001d430: 81 e8 00 00 restore <== NOT EXECUTED
4001d008 <msdos_file_update>:
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
4001d008: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001d00c: 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))
4001d010: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
4001d014: 80 88 60 01 btst 1, %g1
4001d018: 02 80 00 04 be 4001d028 <msdos_file_update+0x20> <== ALWAYS TAKEN
4001d01c: 90 10 20 00 clr %o0
return rc;
}
}
return rc;
}
4001d020: 81 c7 e0 08 ret <== NOT EXECUTED
4001d024: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
4001d028: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4001d02c: 7f ff f2 bf call 40019b28 <msdos_set_first_cluster_num>
4001d030: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
4001d034: 80 a2 20 00 cmp %o0, 0
4001d038: 12 bf ff fa bne 4001d020 <msdos_file_update+0x18> <== NEVER TAKEN
4001d03c: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
4001d040: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4001d044: 7f ff f2 f4 call 40019c14 <msdos_set_file_size>
4001d048: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
4001d04c: 80 a2 20 00 cmp %o0, 0
4001d050: 12 bf ff f4 bne 4001d020 <msdos_file_update+0x18> <== NEVER TAKEN
4001d054: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
4001d058: f0 06 20 28 ld [ %i0 + 0x28 ], %i0
4001d05c: 7f ff f2 6e call 40019a14 <msdos_set_dir_wrt_time_and_date>
4001d060: 81 e8 00 00 restore
4001d140 <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)
{
4001d140: 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;
4001d144: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
4001d148: 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;
4001d14c: 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,
4001d150: 92 10 20 00 clr %o1
4001d154: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
4001d158: 7f ff b5 28 call 4000a5f8 <rtems_semaphore_obtain>
4001d15c: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001d160: 80 a2 20 00 cmp %o0, 0
4001d164: 12 80 00 24 bne 4001d1f4 <msdos_file_write+0xb4> <== NEVER TAKEN
4001d168: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
4001d16c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4001d170: 80 88 62 00 btst 0x200, %g1
4001d174: 32 80 00 1b bne,a 4001d1e0 <msdos_file_write+0xa0>
4001d178: d4 04 60 18 ld [ %l1 + 0x18 ], %o2
4001d17c: d4 06 20 0c ld [ %i0 + 0xc ], %o2
iop->offset = fat_fd->fat_file_size;
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
4001d180: 98 10 00 19 mov %i1, %o4
4001d184: 90 10 00 10 mov %l0, %o0
4001d188: 92 10 00 11 mov %l1, %o1
4001d18c: 7f ff db b9 call 40014070 <fat_file_write>
4001d190: 96 10 00 1a mov %i2, %o3
buffer);
if (ret < 0)
4001d194: b2 92 20 00 orcc %o0, 0, %i1
4001d198: 06 80 00 1c bl 4001d208 <msdos_file_write+0xc8> <== NEVER TAKEN
4001d19c: b9 3e 60 1f sra %i1, 0x1f, %i4
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
4001d1a0: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
4001d1a4: 86 86 40 1b addcc %i1, %i3, %g3
4001d1a8: 84 47 00 1a addx %i4, %i2, %g2
4001d1ac: c4 3e 20 08 std %g2, [ %i0 + 8 ]
if (iop->offset > fat_fd->fat_file_size)
4001d1b0: 80 a0 a0 00 cmp %g2, 0
4001d1b4: 14 80 00 0e bg 4001d1ec <msdos_file_write+0xac> <== NEVER TAKEN
4001d1b8: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
4001d1bc: 80 a0 a0 00 cmp %g2, 0
4001d1c0: 12 80 00 04 bne 4001d1d0 <msdos_file_write+0x90> <== NEVER TAKEN
4001d1c4: 80 a0 c0 01 cmp %g3, %g1
4001d1c8: 38 80 00 02 bgu,a 4001d1d0 <msdos_file_write+0x90>
4001d1cc: c6 24 60 18 st %g3, [ %l1 + 0x18 ]
fat_fd->fat_file_size = iop->offset;
rtems_semaphore_release(fs_info->vol_sema);
4001d1d0: 7f ff b5 59 call 4000a734 <rtems_semaphore_release>
4001d1d4: d0 04 20 9c ld [ %l0 + 0x9c ], %o0
return ret;
}
4001d1d8: 81 c7 e0 08 ret
4001d1dc: 91 e8 00 19 restore %g0, %i1, %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
iop->offset = fat_fd->fat_file_size;
4001d1e0: c0 26 20 08 clr [ %i0 + 8 ]
4001d1e4: 10 bf ff e7 b 4001d180 <msdos_file_write+0x40>
4001d1e8: d4 26 20 0c st %o2, [ %i0 + 0xc ]
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
if (iop->offset > fat_fd->fat_file_size)
fat_fd->fat_file_size = iop->offset;
4001d1ec: 10 bf ff f9 b 4001d1d0 <msdos_file_write+0x90> <== NOT EXECUTED
4001d1f0: c6 24 60 18 st %g3, [ %l1 + 0x18 ] <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
4001d1f4: 40 00 00 e7 call 4001d590 <__errno> <== NOT EXECUTED
4001d1f8: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
4001d1fc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001d200: 10 bf ff f6 b 4001d1d8 <msdos_file_write+0x98> <== NOT EXECUTED
4001d204: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
buffer);
if (ret < 0)
{
rtems_semaphore_release(fs_info->vol_sema);
4001d208: d0 04 20 9c ld [ %l0 + 0x9c ], %o0 <== NOT EXECUTED
4001d20c: 7f ff b5 4a call 4000a734 <rtems_semaphore_release> <== NOT EXECUTED
4001d210: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
return -1;
4001d214: 30 bf ff f1 b,a 4001d1d8 <msdos_file_write+0x98> <== NOT EXECUTED
4001c7f8 <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
4001c7f8: 82 10 20 00 clr %g1
dn[i] = ' ';
4001c7fc: 84 10 20 20 mov 0x20, %g2
4001c800: 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++)
4001c804: 82 00 60 01 inc %g1
4001c808: 80 a0 60 0b cmp %g1, 0xb
4001c80c: 32 bf ff fe bne,a 4001c804 <msdos_filename_unix2dos+0xc>
4001c810: 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) {
4001c814: c2 4a 00 00 ldsb [ %o0 ], %g1
4001c818: 80 a0 60 2e cmp %g1, 0x2e
4001c81c: 02 80 00 5f be 4001c998 <msdos_filename_unix2dos+0x1a0> <== NEVER TAKEN
4001c820: c4 0a 00 00 ldub [ %o0 ], %g2
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
4001c824: 80 a2 60 00 cmp %o1, 0
4001c828: 02 80 00 5a be 4001c990 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001c82c: 01 00 00 00 nop
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
4001c830: 82 88 a0 ff andcc %g2, 0xff, %g1
4001c834: 02 80 00 57 be 4001c990 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001c838: 09 10 00 b9 sethi %hi(0x4002e400), %g4
if (msdos_map[c] == 0)
4001c83c: 88 11 20 18 or %g4, 0x18, %g4 ! 4002e418 <msdos_map>
4001c840: c4 09 00 01 ldub [ %g4 + %g1 ], %g2
4001c844: 80 88 a0 ff btst 0xff, %g2
4001c848: 02 80 00 22 be 4001c8d0 <msdos_filename_unix2dos+0xd8>
4001c84c: 86 10 00 08 mov %o0, %g3
4001c850: 10 80 00 0f b 4001c88c <msdos_filename_unix2dos+0x94>
4001c854: 82 10 20 00 clr %g1
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
4001c858: 02 80 00 18 be 4001c8b8 <msdos_filename_unix2dos+0xc0>
4001c85c: 01 00 00 00 nop
4001c860: c4 08 c0 00 ldub [ %g3 ], %g2
4001c864: 80 a0 a0 00 cmp %g2, 0
4001c868: 02 80 00 16 be 4001c8c0 <msdos_filename_unix2dos+0xc8> <== NEVER TAKEN
4001c86c: 80 a0 a0 2e cmp %g2, 0x2e
4001c870: 22 80 00 15 be,a 4001c8c4 <msdos_filename_unix2dos+0xcc>
4001c874: c2 0a 20 01 ldub [ %o0 + 1 ], %g1
if (msdos_map[c] == 0)
4001c878: c4 09 00 02 ldub [ %g4 + %g2 ], %g2
4001c87c: 80 88 a0 ff btst 0xff, %g2
4001c880: 22 80 00 11 be,a 4001c8c4 <msdos_filename_unix2dos+0xcc>
4001c884: c2 0a 20 01 ldub [ %o0 + 1 ], %g1
break;
dn[i] = msdos_map[c];
un++;
4001c888: 90 10 00 03 mov %g3, %o0
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
4001c88c: c4 2a 80 01 stb %g2, [ %o2 + %g1 ]
un++;
4001c890: 86 02 20 01 add %o0, 1, %g3
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
4001c894: 82 00 60 01 inc %g1
4001c898: 84 10 20 01 mov 1, %g2
4001c89c: 80 a0 60 07 cmp %g1, 7
4001c8a0: 04 80 00 03 ble 4001c8ac <msdos_filename_unix2dos+0xb4>
4001c8a4: 92 02 7f ff add %o1, -1, %o1
4001c8a8: 84 10 20 00 clr %g2
4001c8ac: 80 88 a0 ff btst 0xff, %g2
4001c8b0: 12 bf ff ea bne 4001c858 <msdos_filename_unix2dos+0x60>
4001c8b4: 80 a2 60 00 cmp %o1, 0
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
4001c8b8: 02 80 00 36 be 4001c990 <msdos_filename_unix2dos+0x198>
4001c8bc: 01 00 00 00 nop
4001c8c0: c2 0a 20 01 ldub [ %o0 + 1 ], %g1
4001c8c4: 80 a0 60 00 cmp %g1, 0
4001c8c8: 02 80 00 32 be 4001c990 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001c8cc: 01 00 00 00 nop
un++;
4001c8d0: 86 00 e0 01 inc %g3
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
4001c8d4: 80 a0 60 2e cmp %g1, 0x2e
4001c8d8: 02 80 00 0c be 4001c908 <msdos_filename_unix2dos+0x110>
4001c8dc: 92 02 7f ff add %o1, -1, %o1
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
4001c8e0: 80 a2 60 00 cmp %o1, 0
4001c8e4: 02 80 00 2b be 4001c990 <msdos_filename_unix2dos+0x198>
4001c8e8: 01 00 00 00 nop
4001c8ec: c2 08 c0 00 ldub [ %g3 ], %g1
4001c8f0: 80 a0 60 00 cmp %g1, 0
4001c8f4: 02 80 00 27 be 4001c990 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001c8f8: 92 02 7f ff add %o1, -1, %o1
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
4001c8fc: 80 a0 60 2e cmp %g1, 0x2e
4001c900: 12 bf ff f8 bne 4001c8e0 <msdos_filename_unix2dos+0xe8> <== ALWAYS TAKEN
4001c904: 86 00 e0 01 inc %g3
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
4001c908: 80 a2 60 00 cmp %o1, 0
4001c90c: 02 80 00 21 be 4001c990 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001c910: 01 00 00 00 nop
4001c914: c2 08 c0 00 ldub [ %g3 ], %g1
4001c918: 80 a0 60 00 cmp %g1, 0
4001c91c: 02 80 00 1d be 4001c990 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001c920: 01 00 00 00 nop
if (msdos_map[c] == 0)
4001c924: c4 09 00 01 ldub [ %g4 + %g1 ], %g2
4001c928: 80 88 a0 ff btst 0xff, %g2
4001c92c: 02 80 00 19 be 4001c990 <msdos_filename_unix2dos+0x198>
4001c930: 82 10 20 08 mov 8, %g1
break;
dn[i] = msdos_map[c];
4001c934: 10 80 00 0d b 4001c968 <msdos_filename_unix2dos+0x170>
4001c938: c4 2a 80 01 stb %g2, [ %o2 + %g1 ]
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
4001c93c: 02 80 00 15 be 4001c990 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001c940: 01 00 00 00 nop
4001c944: c4 0b 7f f8 ldub [ %o5 + -8 ], %g2
4001c948: 80 a0 a0 00 cmp %g2, 0
4001c94c: 02 80 00 11 be 4001c990 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001c950: 01 00 00 00 nop
if (msdos_map[c] == 0)
4001c954: c4 09 00 02 ldub [ %g4 + %g2 ], %g2
4001c958: 80 88 a0 ff btst 0xff, %g2
4001c95c: 02 80 00 0d be 4001c990 <msdos_filename_unix2dos+0x198> <== NEVER TAKEN
4001c960: 01 00 00 00 nop
break;
dn[i] = msdos_map[c];
4001c964: c4 2a 80 01 stb %g2, [ %o2 + %g1 ]
un++;
unlen--;
4001c968: 92 02 7f ff add %o1, -1, %o1
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
4001c96c: 82 00 60 01 inc %g1
4001c970: 84 10 20 01 mov 1, %g2
4001c974: 80 a0 60 0a cmp %g1, 0xa
4001c978: 04 80 00 03 ble 4001c984 <msdos_filename_unix2dos+0x18c>
4001c97c: 9a 00 c0 01 add %g3, %g1, %o5
4001c980: 84 10 20 00 clr %g2
4001c984: 80 88 a0 ff btst 0xff, %g2
4001c988: 12 bf ff ed bne 4001c93c <msdos_filename_unix2dos+0x144>
4001c98c: 80 a2 60 00 cmp %o1, 0
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
4001c990: 81 c3 e0 08 retl
4001c994: 90 10 20 00 clr %o0
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
4001c998: 80 a2 60 01 cmp %o1, 1 <== NOT EXECUTED
4001c99c: 22 bf ff fd be,a 4001c990 <msdos_filename_unix2dos+0x198><== NOT EXECUTED
4001c9a0: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
4001c9a4: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
4001c9a8: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
4001c9ac: 12 80 00 05 bne 4001c9c0 <msdos_filename_unix2dos+0x1c8> <== NOT EXECUTED
4001c9b0: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
4001c9b4: 80 a2 60 02 cmp %o1, 2 <== NOT EXECUTED
4001c9b8: 02 80 00 0e be 4001c9f0 <msdos_filename_unix2dos+0x1f8> <== NOT EXECUTED
4001c9bc: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
4001c9c0: 32 80 00 08 bne,a 4001c9e0 <msdos_filename_unix2dos+0x1e8><== NOT EXECUTED
4001c9c4: 92 82 7f ff addcc %o1, -1, %o1 <== NOT EXECUTED
4001c9c8: 30 bf ff f2 b,a 4001c990 <msdos_filename_unix2dos+0x198> <== NOT EXECUTED
4001c9cc: c2 4a 00 00 ldsb [ %o0 ], %g1 <== NOT EXECUTED
4001c9d0: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
4001c9d4: 12 bf ff 97 bne 4001c830 <msdos_filename_unix2dos+0x38> <== NOT EXECUTED
4001c9d8: c4 0a 00 00 ldub [ %o0 ], %g2 <== NOT EXECUTED
4001c9dc: 92 82 7f ff addcc %o1, -1, %o1 <== NOT EXECUTED
4001c9e0: 12 bf ff fb bne 4001c9cc <msdos_filename_unix2dos+0x1d4> <== NOT EXECUTED
4001c9e4: 90 02 20 01 inc %o0 <== NOT EXECUTED
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
4001c9e8: 81 c3 e0 08 retl <== NOT EXECUTED
4001c9ec: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (un[0] == '.' && unlen == 1) {
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
dn[0] = '.';
4001c9f0: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
dn[1] = '.';
return 0;
4001c9f4: 10 bf ff e7 b 4001c990 <msdos_filename_unix2dos+0x198> <== NOT EXECUTED
4001c9f8: c2 2a a0 01 stb %g1, [ %o2 + 1 ] <== NOT EXECUTED
4001af8c <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
4001af8c: 9d e3 bf 60 save %sp, -160, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
4001af90: 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);
4001af94: ba 07 bf e0 add %fp, -32, %i5
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
4001af98: f6 00 60 08 ld [ %g1 + 8 ], %i3
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
name_type = msdos_long_to_short (name,
4001af9c: 94 10 00 1d mov %i5, %o2
4001afa0: 92 10 00 1a mov %i2, %o1
4001afa4: 96 10 20 0b mov 0xb, %o3
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
4001afa8: 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);
4001afac: c0 27 bf e0 clr [ %fp + -32 ]
4001afb0: c0 27 bf e4 clr [ %fp + -28 ]
4001afb4: c0 27 bf e8 clr [ %fp + -24 ]
4001afb8: c0 27 bf ec clr [ %fp + -20 ]
4001afbc: c0 27 bf f0 clr [ %fp + -16 ]
4001afc0: c0 27 bf f4 clr [ %fp + -12 ]
4001afc4: c0 27 bf f8 clr [ %fp + -8 ]
4001afc8: c0 27 bf fc clr [ %fp + -4 ]
name_type = msdos_long_to_short (name,
4001afcc: 7f ff fa 04 call 400197dc <msdos_long_to_short>
4001afd0: 90 10 00 19 mov %i1, %o0
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
4001afd4: b8 10 00 18 mov %i0, %i4
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
name_type = msdos_long_to_short (name,
4001afd8: 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,
4001afdc: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
4001afe0: 90 10 00 18 mov %i0, %o0
4001afe4: 92 10 20 00 clr %o1
4001afe8: 94 10 00 19 mov %i1, %o2
4001afec: 96 10 00 1a mov %i2, %o3
4001aff0: 7f ff ff a6 call 4001ae88 <msdos_get_name_node>
4001aff4: 9a 07 bf d0 add %fp, -48, %o5
&dir_pos, node_entry);
if (rc != RC_OK)
4001aff8: b0 92 20 00 orcc %o0, 0, %i0
4001affc: 12 80 00 23 bne 4001b088 <msdos_find_name+0xfc>
4001b000: 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;
4001b004: 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) ||
4001b008: 84 08 60 08 and %g1, 8, %g2
4001b00c: 80 88 a0 ff btst 0xff, %g2
4001b010: 12 80 00 1e bne 4001b088 <msdos_find_name+0xfc> <== NEVER TAKEN
4001b014: b0 16 21 01 or %i0, 0x101, %i0
4001b018: 82 08 60 3f and %g1, 0x3f, %g1
4001b01c: 80 a0 60 0f cmp %g1, 0xf
4001b020: 02 80 00 1a be 4001b088 <msdos_find_name+0xfc> <== NEVER TAKEN
4001b024: 90 10 00 1b mov %i3, %o0
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
/* open fat-file corresponded to the found node */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
4001b028: 92 07 bf d0 add %fp, -48, %o1
4001b02c: 7f ff e1 9f call 400136a8 <fat_file_open>
4001b030: 94 07 bf cc add %fp, -52, %o2
if (rc != RC_OK)
4001b034: b0 92 20 00 orcc %o0, 0, %i0
4001b038: 12 80 00 14 bne 4001b088 <msdos_find_name+0xfc> <== NEVER TAKEN
4001b03c: fa 07 bf cc ld [ %fp + -52 ], %i5
return rc;
fat_fd->dir_pos = dir_pos;
4001b040: c4 07 bf d0 ld [ %fp + -48 ], %g2
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
4001b044: c2 07 60 08 ld [ %i5 + 8 ], %g1
/* open fat-file corresponded to the found node */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->dir_pos = dir_pos;
4001b048: c4 27 60 20 st %g2, [ %i5 + 0x20 ]
4001b04c: c4 07 bf d4 ld [ %fp + -44 ], %g2
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
4001b050: 80 a0 60 01 cmp %g1, 1
/* open fat-file corresponded to the found node */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->dir_pos = dir_pos;
4001b054: c4 27 60 24 st %g2, [ %i5 + 0x24 ]
4001b058: c4 07 bf d8 ld [ %fp + -40 ], %g2
4001b05c: c4 27 60 28 st %g2, [ %i5 + 0x28 ]
4001b060: c4 07 bf dc ld [ %fp + -36 ], %g2
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
4001b064: 02 80 00 0b be 4001b090 <msdos_find_name+0x104>
4001b068: c4 27 60 2c st %g2, [ %i5 + 0x2c ]
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
4001b06c: d2 07 20 08 ld [ %i4 + 8 ], %o1
4001b070: 7f ff e3 08 call 40013c90 <fat_file_close>
4001b074: 90 10 00 1b mov %i3, %o0
if (rc != RC_OK)
4001b078: b0 92 20 00 orcc %o0, 0, %i0
4001b07c: 12 80 00 45 bne 4001b190 <msdos_find_name+0x204> <== NEVER TAKEN
4001b080: c2 07 bf cc ld [ %fp + -52 ], %g1
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
4001b084: c2 27 20 08 st %g1, [ %i4 + 8 ]
return rc;
}
4001b088: 81 c7 e0 08 ret
4001b08c: 81 e8 00 00 restore
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
4001b090: c2 17 bf f6 lduh [ %fp + -10 ], %g1
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
4001b094: c8 17 bf f4 lduh [ %fp + -12 ], %g4
4001b098: c6 17 bf fa lduh [ %fp + -6 ], %g3
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
4001b09c: c4 17 bf f8 lduh [ %fp + -8 ], %g2
4001b0a0: 83 28 60 10 sll %g1, 0x10, %g1
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
4001b0a4: 89 29 20 10 sll %g4, 0x10, %g4
4001b0a8: 87 28 e0 10 sll %g3, 0x10, %g3
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
4001b0ac: 85 28 a0 10 sll %g2, 0x10, %g2
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
4001b0b0: b1 31 20 18 srl %g4, 0x18, %i0
4001b0b4: b3 30 e0 18 srl %g3, 0x18, %i1
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
4001b0b8: 91 30 a0 18 srl %g2, 0x18, %o0
4001b0bc: 93 30 60 18 srl %g1, 0x18, %o1
4001b0c0: b5 30 60 08 srl %g1, 8, %i2
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
4001b0c4: 89 31 20 08 srl %g4, 8, %g4
4001b0c8: 87 30 e0 08 srl %g3, 8, %g3
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
4001b0cc: 85 30 a0 08 srl %g2, 8, %g2
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
4001b0d0: 03 00 00 3f sethi %hi(0xfc00), %g1
4001b0d4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
4001b0d8: 84 08 80 01 and %g2, %g1, %g2
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
4001b0dc: 88 09 00 01 and %g4, %g1, %g4
4001b0e0: 86 08 c0 01 and %g3, %g1, %g3
4001b0e4: 88 16 00 04 or %i0, %g4, %g4
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
4001b0e8: 82 0e 80 01 and %i2, %g1, %g1
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
4001b0ec: 89 29 20 10 sll %g4, 0x10, %g4
4001b0f0: 86 16 40 03 or %i1, %g3, %g3
4001b0f4: 86 11 00 03 or %g4, %g3, %g3
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
4001b0f8: 92 12 40 01 or %o1, %g1, %o1
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
4001b0fc: c6 27 60 1c st %g3, [ %i5 + 0x1c ]
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
4001b100: 40 00 05 70 call 4001c6c0 <msdos_date_dos2unix>
4001b104: 90 12 00 02 or %o0, %g2, %o0
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
4001b108: c2 0f bf eb ldub [ %fp + -21 ], %g1
4001b10c: 82 08 60 10 and %g1, 0x10, %g1
4001b110: 80 88 60 ff btst 0xff, %g1
4001b114: 12 80 00 27 bne 4001b1b0 <msdos_find_name+0x224>
4001b118: d0 27 60 40 st %o0, [ %i5 + 0x40 ]
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
4001b11c: c4 07 bf fc ld [ %fp + -4 ], %g2
4001b120: c2 07 bf cc ld [ %fp + -52 ], %g1
4001b124: bb 28 a0 18 sll %g2, 0x18, %i5
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
4001b128: 89 30 a0 18 srl %g2, 0x18, %g4
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
4001b12c: 87 30 a0 08 srl %g2, 8, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001b130: 88 17 40 04 or %i5, %g4, %g4
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
4001b134: 86 08 e0 ff and %g3, 0xff, %g3
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001b138: 87 28 e0 10 sll %g3, 0x10, %g3
4001b13c: 86 11 00 03 or %g4, %g3, %g3
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
4001b140: 85 30 a0 10 srl %g2, 0x10, %g2
4001b144: 84 08 a0 ff and %g2, 0xff, %g2
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
4001b148: 85 28 a0 08 sll %g2, 8, %g2
4001b14c: 84 10 c0 02 or %g3, %g2, %g2
fat_fd->fat_file_type = FAT_FILE;
4001b150: 86 10 20 04 mov 4, %g3
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
4001b154: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
fat_fd->fat_file_type = FAT_FILE;
4001b158: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
4001b15c: 86 10 3f ff mov -1, %g3
4001b160: c6 20 60 14 st %g3, [ %g1 + 0x14 ]
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
4001b164: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
fat_fd->fat_file_type = FAT_FILE;
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
4001b168: c0 20 60 34 clr [ %g1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
4001b16c: 80 a0 a0 00 cmp %g2, 0
4001b170: 02 80 00 0d be 4001b1a4 <msdos_find_name+0x218>
4001b174: c6 20 60 38 st %g3, [ %g1 + 0x38 ]
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
4001b178: c8 16 e0 06 lduh [ %i3 + 6 ], %g4
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
4001b17c: 80 a1 00 02 cmp %g4, %g2
4001b180: 0a 80 00 0a bcs 4001b1a8 <msdos_find_name+0x21c>
4001b184: 84 10 3f ff mov -1, %g2
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
{
fat_fd->map.last_cln = fat_fd->cln;
4001b188: 10 bf ff b9 b 4001b06c <msdos_find_name+0xe0>
4001b18c: c6 20 60 3c st %g3, [ %g1 + 0x3c ]
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
4001b190: d2 07 bf cc ld [ %fp + -52 ], %o1 <== NOT EXECUTED
4001b194: 7f ff e2 bf call 40013c90 <fat_file_close> <== NOT EXECUTED
4001b198: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001b19c: 81 c7 e0 08 ret <== NOT EXECUTED
4001b1a0: 81 e8 00 00 restore <== NOT EXECUTED
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
4001b1a4: 84 10 3f ff mov -1, %g2
4001b1a8: 10 bf ff b1 b 4001b06c <msdos_find_name+0xe0>
4001b1ac: c4 20 60 3c st %g2, [ %g1 + 0x3c ]
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
{
fat_fd->fat_file_type = FAT_DIRECTORY;
4001b1b0: d2 07 bf cc ld [ %fp + -52 ], %o1
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4001b1b4: 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;
4001b1b8: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4001b1bc: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
4001b1c0: 7f ff e4 70 call 40014380 <fat_file_size>
4001b1c4: 90 10 00 1b mov %i3, %o0
if (rc != RC_OK)
4001b1c8: b0 92 20 00 orcc %o0, 0, %i0
4001b1cc: 12 bf ff f1 bne 4001b190 <msdos_find_name+0x204> <== NEVER TAKEN
4001b1d0: c2 07 bf cc ld [ %fp + -52 ], %g1
4001b1d4: 10 bf ff e4 b 4001b164 <msdos_find_name+0x1d8>
4001b1d8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
40019fbc <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
)
{
40019fbc: 9d e3 bf 80 save %sp, -128, %sp
40019fc0: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40019fc4: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
40019fc8: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40019fcc: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
40019fd0: 80 a7 20 00 cmp %i4, 0
40019fd4: 04 80 02 80 ble 4001a9d4 <msdos_find_name_in_fat_file+0xa18><== NEVER TAKEN
40019fd8: ea 06 20 08 ld [ %i0 + 8 ], %l5
* is short still check for possible long entries with the short name.
*
* In PR1491 we need to have a LFN for a short file name entry. To
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
40019fdc: c4 07 a0 58 ld [ %fp + 0x58 ], %g2
40019fe0: 82 18 a0 01 xor %g2, 1, %g1
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
40019fe4: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
40019fe8: 80 a0 00 01 cmp %g0, %g1
40019fec: c0 20 80 00 clr [ %g2 ]
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40019ff0: 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;
40019ff4: c0 20 a0 04 clr [ %g2 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
40019ff8: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
40019ffc: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
assert(name_len > 0);
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
4001a000: c2 27 bf fc st %g1, [ %fp + -4 ]
* is short still check for possible long entries with the short name.
*
* In PR1491 we need to have a LFN for a short file name entry. To
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
4001a004: b2 60 3f ff subx %g0, -1, %i1
4001a008: 80 a6 60 00 cmp %i1, 0
4001a00c: 02 80 00 82 be 4001a214 <msdos_find_name_in_fat_file+0x258>
4001a010: c2 27 bf f8 st %g1, [ %fp + -8 ]
4001a014: 80 a6 a0 00 cmp %i2, 0
4001a018: 02 80 00 7f be 4001a214 <msdos_find_name_in_fat_file+0x258>
4001a01c: c0 27 bf e4 clr [ %fp + -28 ]
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
4001a020: c4 07 a0 48 ld [ %fp + 0x48 ], %g2
4001a024: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1
4001a028: 80 a0 60 01 cmp %g1, 1
4001a02c: 22 80 01 85 be,a 4001a640 <msdos_find_name_in_fat_file+0x684>
4001a030: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
4001a034: e2 15 60 06 lduh [ %l5 + 6 ], %l1
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
4001a038: c2 07 bf e4 ld [ %fp + -28 ], %g1
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;
4001a03c: ac 10 20 00 clr %l6
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
4001a040: b8 10 20 00 clr %i4
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
4001a044: 82 00 60 01 inc %g1
4001a048: d8 05 60 a0 ld [ %l5 + 0xa0 ], %o4
4001a04c: c2 27 bf ec st %g1, [ %fp + -20 ]
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
4001a050: c0 27 bf e8 clr [ %fp + -24 ]
4001a054: 82 10 00 19 mov %i1, %g1
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;
4001a058: a6 10 20 00 clr %l3
4001a05c: b2 10 00 16 mov %l6, %i1
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;
4001a060: a0 10 20 00 clr %l0
4001a064: ac 10 00 1c mov %i4, %l6
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;
4001a068: a4 10 20 00 clr %l2
4001a06c: b8 10 00 15 mov %l5, %i4
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;
4001a070: ae 10 20 00 clr %l7
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;
4001a074: b0 10 20 00 clr %i0
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
4001a078: a8 10 20 00 clr %l4
4001a07c: aa 10 00 01 mov %g1, %l5
/*
* 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),
4001a080: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
4001a084: d4 07 bf e8 ld [ %fp + -24 ], %o2
4001a088: 90 10 00 1c mov %i4, %o0
4001a08c: 7f ff e6 3b call 40013978 <fat_file_read>
4001a090: 96 10 00 11 mov %l1, %o3
4001a094: 80 a2 20 00 cmp %o0, 0
4001a098: 02 80 00 e4 be 4001a428 <msdos_find_name_in_fat_file+0x46c>
4001a09c: 80 a2 20 1f cmp %o0, 0x1f
bool remainder_empty = false;
#if MSDOS_FIND_PRINT
printf ("MSFS:[2] dir_offset:%li\n", dir_offset);
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001a0a0: 04 80 01 85 ble 4001a6b4 <msdos_find_name_in_fat_file+0x6f8><== NEVER TAKEN
4001a0a4: 80 a2 00 11 cmp %o0, %l1
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
4001a0a8: 12 80 02 53 bne 4001a9f4 <msdos_find_name_in_fat_file+0xa38><== NEVER TAKEN
4001a0ac: 84 10 00 18 mov %i0, %g2
4001a0b0: d8 07 20 a0 ld [ %i4 + 0xa0 ], %o4
4001a0b4: b6 10 20 00 clr %i3
4001a0b8: b0 10 00 19 mov %i1, %i0
4001a0bc: ba 10 00 0c mov %o4, %i5
4001a0c0: b2 10 00 0c mov %o4, %i1
* 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)
4001a0c4: 80 a4 20 00 cmp %l0, 0
4001a0c8: 12 80 00 04 bne 4001a0d8 <msdos_find_name_in_fat_file+0x11c>
4001a0cc: c6 0f 40 00 ldub [ %i5 ], %g3
4001a0d0: a4 10 00 1b mov %i3, %l2
4001a0d4: ae 10 00 14 mov %l4, %l7
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
4001a0d8: 82 88 e0 ff andcc %g3, 0xff, %g1
4001a0dc: 02 80 00 e2 be 4001a464 <msdos_find_name_in_fat_file+0x4a8>
4001a0e0: 80 a0 60 e5 cmp %g1, 0xe5
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
4001a0e4: 02 80 00 69 be 4001a288 <msdos_find_name_in_fat_file+0x2cc>
4001a0e8: 82 1c e0 01 xor %l3, 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)
4001a0ec: 80 88 60 ff btst 0xff, %g1
4001a0f0: 02 80 00 07 be 4001a10c <msdos_find_name_in_fat_file+0x150><== NEVER TAKEN
4001a0f4: c2 0f 60 0b ldub [ %i5 + 0xb ], %g1
4001a0f8: 80 a6 a0 00 cmp %i2, 0
4001a0fc: 02 80 00 04 be 4001a10c <msdos_find_name_in_fat_file+0x150>
4001a100: 01 00 00 00 nop
{
empty_space_entry = 0;
empty_space_count = 0;
4001a104: a0 10 20 00 clr %l0 ! 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;
4001a108: a4 10 20 00 clr %l2
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
4001a10c: 82 08 60 3f and %g1, 0x3f, %g1
4001a110: 80 a0 60 0f cmp %g1, 0xf
4001a114: 02 80 00 67 be 4001a2b0 <msdos_find_name_in_fat_file+0x2f4>
4001a118: 80 88 a0 ff btst 0xff, %g2
* 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)
4001a11c: 02 80 00 4a be 4001a244 <msdos_find_name_in_fat_file+0x288>
4001a120: 80 a5 60 00 cmp %l5, 0
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
4001a124: 9e 07 60 0a add %i5, 0xa, %o7
4001a128: 84 10 00 1d mov %i5, %g2
4001a12c: 88 10 20 00 clr %g4
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;
4001a130: 10 80 00 09 b 4001a154 <msdos_find_name_in_fat_file+0x198>
4001a134: 82 10 20 00 clr %g1
4001a138: 82 08 60 01 and %g1, 1, %g1
4001a13c: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
4001a140: 80 a0 00 01 cmp %g0, %g1
4001a144: 84 00 a0 01 inc %g2
4001a148: 82 40 3f ff addx %g0, -1, %g1
4001a14c: 82 08 60 80 and %g1, 0x80, %g1
4001a150: 82 00 7f 80 add %g1, -128, %g1
4001a154: 88 09 20 ff and %g4, 0xff, %g4
4001a158: 89 31 20 01 srl %g4, 1, %g4
4001a15c: 82 00 40 03 add %g1, %g3, %g1
{
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++)
4001a160: 80 a0 80 0f cmp %g2, %o7
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
4001a164: 82 00 40 04 add %g1, %g4, %g1
{
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++)
4001a168: 12 bf ff f4 bne 4001a138 <msdos_find_name_in_fat_file+0x17c>
4001a16c: 88 10 00 01 mov %g1, %g4
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
4001a170: 88 1d 80 04 xor %l6, %g4, %g4
4001a174: 80 89 20 ff btst 0xff, %g4
4001a178: 12 80 00 33 bne 4001a244 <msdos_find_name_in_fat_file+0x288><== NEVER TAKEN
4001a17c: 80 a5 60 00 cmp %l5, 0
4001a180: 80 a6 20 00 cmp %i0, 0
4001a184: 12 80 00 30 bne 4001a244 <msdos_find_name_in_fat_file+0x288><== NEVER TAKEN
4001a188: 80 a5 60 00 cmp %l5, 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,
4001a18c: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
4001a190: d6 07 bf e8 ld [ %fp + -24 ], %o3
4001a194: d8 07 a0 5c ld [ %fp + 0x5c ], %o4
4001a198: 90 10 00 1c mov %i4, %o0
4001a19c: 7f ff e6 eb call 40013d48 <fat_file_ioctl>
4001a1a0: 94 10 20 01 mov 1, %o2
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
4001a1a4: b0 92 20 00 orcc %o0, 0, %i0
4001a1a8: 12 80 00 19 bne 4001a20c <msdos_find_name_in_fat_file+0x250><== NEVER TAKEN
4001a1ac: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
4001a1b0: d2 07 bf f8 ld [ %fp + -8 ], %o1
4001a1b4: 80 a2 7f ff cmp %o1, -1
4001a1b8: 02 80 01 34 be 4001a688 <msdos_find_name_in_fat_file+0x6cc>
4001a1bc: f6 20 60 04 st %i3, [ %g1 + 4 ]
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
4001a1c0: 7f ff a0 f3 call 4000258c <.umul>
4001a1c4: 90 10 00 11 mov %l1, %o0
4001a1c8: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
4001a1cc: 96 10 00 08 mov %o0, %o3
4001a1d0: 94 10 20 01 mov 1, %o2
4001a1d4: 90 10 00 1c mov %i4, %o0
4001a1d8: 7f ff e6 dc call 40013d48 <fat_file_ioctl>
4001a1dc: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
4001a1e0: 80 a2 20 00 cmp %o0, 0
4001a1e4: 12 80 01 27 bne 4001a680 <msdos_find_name_in_fat_file+0x6c4><== NEVER TAKEN
4001a1e8: c2 07 bf f8 ld [ %fp + -8 ], %g1
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
4001a1ec: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
4001a1f0: d0 07 a0 60 ld [ %fp + 0x60 ], %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
4001a1f4: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
4001a1f8: c2 07 bf fc ld [ %fp + -4 ], %g1
memcpy(name_dir_entry, entry,
4001a1fc: 92 10 00 1d mov %i5, %o1
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
4001a200: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
memcpy(name_dir_entry, entry,
4001a204: 40 00 0f 88 call 4001e024 <memcpy>
4001a208: 94 10 20 20 mov 0x20, %o2
4001a20c: 81 c7 e0 08 ret
4001a210: 81 e8 00 00 restore
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
4001a214: c4 07 a0 54 ld [ %fp + 0x54 ], %g2
4001a218: 92 10 20 0d mov 0xd, %o1
4001a21c: 7f ff a1 18 call 4000267c <.div>
4001a220: 90 00 a0 0c add %g2, 0xc, %o0
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
4001a224: c4 07 a0 48 ld [ %fp + 0x48 ], %g2
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
4001a228: d0 27 bf e4 st %o0, [ %fp + -28 ]
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
4001a22c: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1
4001a230: 80 a0 60 01 cmp %g1, 1
4001a234: 32 bf ff 81 bne,a 4001a038 <msdos_find_name_in_fat_file+0x7c>
4001a238: e2 15 60 06 lduh [ %l5 + 6 ], %l1
4001a23c: 10 80 01 01 b 4001a640 <msdos_find_name_in_fat_file+0x684>
4001a240: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
4001a244: 12 80 00 5f bne 4001a3c0 <msdos_find_name_in_fat_file+0x404>
4001a248: c2 07 bf f8 ld [ %fp + -8 ], %g1
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
4001a24c: 82 10 3f ff mov -1, %g1
lfn_matched = false;
4001a250: 84 10 20 00 clr %g2
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
4001a254: c2 27 bf f8 st %g1, [ %fp + -8 ]
4001a258: b6 06 e0 20 add %i3, 0x20, %i3
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;
4001a25c: 80 a4 40 1b cmp %l1, %i3
4001a260: 18 bf ff 99 bgu 4001a0c4 <msdos_find_name_in_fat_file+0x108>
4001a264: ba 07 60 20 add %i5, 0x20, %i5
4001a268: 98 10 00 19 mov %i1, %o4
4001a26c: b2 10 00 18 mov %i0, %i1
4001a270: b0 10 00 02 mov %g2, %i0
4001a274: c4 07 bf e8 ld [ %fp + -24 ], %g2
}
if (remainder_empty)
break;
dir_offset++;
4001a278: a8 05 20 01 inc %l4
4001a27c: 84 00 80 11 add %g2, %l1, %g2
4001a280: 10 bf ff 80 b 4001a080 <msdos_find_name_in_fat_file+0xc4>
4001a284: c4 27 bf e8 st %g2, [ %fp + -24 ]
}
break;
}
else if (entry_empty)
{
if (create_node)
4001a288: 80 a6 a0 00 cmp %i2, 0
4001a28c: 22 bf ff f4 be,a 4001a25c <msdos_find_name_in_fat_file+0x2a0>
4001a290: b6 06 e0 20 add %i3, 0x20, %i3
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
4001a294: c2 07 bf ec ld [ %fp + -20 ], %g1
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
4001a298: a0 04 20 01 inc %l0
if (empty_space_count == (lfn_entries + 1))
4001a29c: 80 a0 40 10 cmp %g1, %l0
4001a2a0: 22 bf ff ee be,a 4001a258 <msdos_find_name_in_fat_file+0x29c>
4001a2a4: a6 10 20 01 mov 1, %l3
4001a2a8: 10 bf ff ed b 4001a25c <msdos_find_name_in_fat_file+0x2a0>
4001a2ac: b6 06 e0 20 add %i3, 0x20, %i3
#endif
/*
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
4001a2b0: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001a2b4: 80 a0 7f ff cmp %g1, -1
4001a2b8: 02 80 00 4e be 4001a3f0 <msdos_find_name_in_fat_file+0x434>
4001a2bc: 82 08 e0 40 and %g3, 0x40, %g1
* 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) &
4001a2c0: 86 08 e0 3f and %g3, 0x3f, %g3
4001a2c4: 80 a0 c0 18 cmp %g3, %i0
4001a2c8: 22 80 00 05 be,a 4001a2dc <msdos_find_name_in_fat_file+0x320><== ALWAYS TAKEN
4001a2cc: d4 0f 60 0d ldub [ %i5 + 0xd ], %o2
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
#if MSDOS_FIND_PRINT
printf ("MSFS:[4.4] no match\n");
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
4001a2d0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
continue;
4001a2d4: 10 bf ff e1 b 4001a258 <msdos_find_name_in_fat_file+0x29c><== NOT EXECUTED
4001a2d8: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED
* forget this series of long directory entries. These
* could be orphaned entries depending on the history
* of the disk.
*/
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
4001a2dc: 82 0d a0 ff and %l6, 0xff, %g1
4001a2e0: 88 0a a0 ff and %o2, 0xff, %g4
4001a2e4: 80 a1 00 01 cmp %g4, %g1
4001a2e8: 12 bf ff fb bne 4001a2d4 <msdos_find_name_in_fat_file+0x318><== NEVER TAKEN
4001a2ec: 82 10 3f ff mov -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(
4001a2f0: 88 07 60 01 add %i5, 1, %g4
{
#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')
4001a2f4: c4 49 00 00 ldsb [ %g4 ], %g2
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
4001a2f8: b0 06 3f ff add %i0, -1, %i0
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
4001a2fc: 83 2e 20 02 sll %i0, 2, %g1
4001a300: 9b 2e 20 04 sll %i0, 4, %o5
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
4001a304: 9e 10 20 01 mov 1, %o7
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
4001a308: 9a 23 40 01 sub %o5, %g1, %o5
4001a30c: d2 07 a0 50 ld [ %fp + 0x50 ], %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(
4001a310: 82 10 20 00 clr %g1
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
4001a314: 9a 03 40 18 add %o5, %i0, %o5
{
#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')
4001a318: 80 a0 a0 00 cmp %g2, 0
4001a31c: 02 80 00 16 be 4001a374 <msdos_find_name_in_fat_file+0x3b8><== NEVER TAKEN
4001a320: d6 07 a0 54 ld [ %fp + 0x54 ], %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(
4001a324: 98 00 40 0d add %g1, %o5, %o4
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
4001a328: 80 a2 c0 0c cmp %o3, %o4
4001a32c: 04 80 00 ce ble 4001a664 <msdos_find_name_in_fat_file+0x6a8>
4001a330: 98 02 40 0d add %o1, %o5, %o4
4001a334: d8 4b 00 01 ldsb [ %o4 + %g1 ], %o4
4001a338: 80 a0 80 0c cmp %g2, %o4
4001a33c: 12 80 00 ca bne 4001a664 <msdos_find_name_in_fat_file+0x6a8>
4001a340: 80 a0 60 04 cmp %g1, 4
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
switch (i)
4001a344: 02 80 00 44 be 4001a454 <msdos_find_name_in_fat_file+0x498>
4001a348: 80 a0 60 0a cmp %g1, 0xa
4001a34c: 02 80 00 3e be 4001a444 <msdos_find_name_in_fat_file+0x488>
4001a350: 80 a3 e0 0d cmp %o7, 0xd
p = entry + 1;
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
4001a354: 02 80 00 12 be 4001a39c <msdos_find_name_in_fat_file+0x3e0>
4001a358: 88 01 20 02 add %g4, 2, %g4
4001a35c: 82 00 60 01 inc %g1
4001a360: 9e 03 e0 01 inc %o7
{
#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')
4001a364: c4 49 00 00 ldsb [ %g4 ], %g2
4001a368: 80 a0 a0 00 cmp %g2, 0
4001a36c: 12 bf ff ef bne 4001a328 <msdos_find_name_in_fat_file+0x36c>
4001a370: 98 00 40 0d add %g1, %o5, %o4
/*
* 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) &&
4001a374: c4 07 bf e4 ld [ %fp + -28 ], %g2
4001a378: 80 a0 80 03 cmp %g2, %g3
4001a37c: 12 80 00 09 bne 4001a3a0 <msdos_find_name_in_fat_file+0x3e4><== NEVER TAKEN
4001a380: 80 a6 20 00 cmp %i0, 0
4001a384: c4 07 a0 54 ld [ %fp + 0x54 ], %g2
((o + i) != name_len))
4001a388: 82 03 40 01 add %o5, %g1, %g1
/*
* 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) &&
4001a38c: 80 a0 40 02 cmp %g1, %g2
4001a390: 02 80 00 03 be 4001a39c <msdos_find_name_in_fat_file+0x3e0><== ALWAYS TAKEN
4001a394: 82 10 3f ff mov -1, %g1
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
4001a398: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
4001a39c: 80 a6 20 00 cmp %i0, 0
4001a3a0: 12 80 00 06 bne 4001a3b8 <msdos_find_name_in_fat_file+0x3fc>
4001a3a4: 84 10 20 00 clr %g2
4001a3a8: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001a3ac: 82 38 00 01 xnor %g0, %g1, %g1
4001a3b0: 80 a0 00 01 cmp %g0, %g1
4001a3b4: 84 40 20 00 addx %g0, 0, %g2
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_matched = false;
4001a3b8: 10 bf ff a8 b 4001a258 <msdos_find_name_in_fat_file+0x29c>
4001a3bc: ac 10 00 0a mov %o2, %l6
* 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) &&
4001a3c0: 80 a0 7f ff cmp %g1, -1
4001a3c4: 12 bf ff a3 bne 4001a250 <msdos_find_name_in_fat_file+0x294><== NEVER TAKEN
4001a3c8: 82 10 3f ff mov -1, %g1
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
4001a3cc: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
4001a3d0: 90 10 00 1d mov %i5, %o0
4001a3d4: 40 00 0e ea call 4001df7c <memcmp>
4001a3d8: 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) &&
4001a3dc: 80 a2 20 00 cmp %o0, 0
4001a3e0: 12 bf ff 9c bne 4001a250 <msdos_find_name_in_fat_file+0x294>
4001a3e4: 82 10 3f ff mov -1, %g1
#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,
4001a3e8: 10 bf ff 6a b 4001a190 <msdos_find_name_in_fat_file+0x1d4>
4001a3ec: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
4001a3f0: 80 88 60 ff btst 0xff, %g1
4001a3f4: 02 bf ff 99 be 4001a258 <msdos_find_name_in_fat_file+0x29c>
4001a3f8: 84 10 20 00 clr %g2
* 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) &
4001a3fc: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001a400: 86 08 e0 3f and %g3, 0x3f, %g3
4001a404: 80 a0 c0 01 cmp %g3, %g1
4001a408: 32 bf ff 95 bne,a 4001a25c <msdos_find_name_in_fat_file+0x2a0>
4001a40c: b6 06 e0 20 add %i3, 0x20, %i3
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
4001a410: e8 27 bf f8 st %l4, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
4001a414: f6 27 bf fc st %i3, [ %fp + -4 ]
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
4001a418: b0 10 00 01 mov %g1, %i0
4001a41c: ec 0f 60 0d ldub [ %i5 + 0xd ], %l6
4001a420: 10 bf ff a8 b 4001a2c0 <msdos_find_name_in_fat_file+0x304>
4001a424: c6 0f 40 00 ldub [ %i5 ], %g3
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
return MSDOS_NAME_NOT_FOUND_ERR;
4001a428: 31 00 00 1f sethi %hi(0x7c00), %i0
4001a42c: aa 10 00 1c mov %i4, %l5
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
4001a430: 80 a6 a0 00 cmp %i2, 0
4001a434: 12 80 00 16 bne 4001a48c <msdos_find_name_in_fat_file+0x4d0>
4001a438: b0 16 21 01 or %i0, 0x101, %i0
empty_space_entry = 0;
read_cluster = true;
}
return 0;
}
4001a43c: 81 c7 e0 08 ret
4001a440: 81 e8 00 00 restore
{
case 4:
p += 5;
break;
case 10:
p += 4;
4001a444: 88 01 20 04 add %g4, 4, %g4
4001a448: 82 00 60 01 inc %g1
4001a44c: 10 bf ff c6 b 4001a364 <msdos_find_name_in_fat_file+0x3a8>
4001a450: 9e 03 e0 01 inc %o7
}
switch (i)
{
case 4:
p += 5;
4001a454: 88 01 20 05 add %g4, 5, %g4
4001a458: 82 00 60 01 inc %g1
4001a45c: 10 bf ff c2 b 4001a364 <msdos_find_name_in_fat_file+0x3a8>
4001a460: 9e 03 e0 01 inc %o7
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
4001a464: 80 a6 a0 00 cmp %i2, 0
4001a468: 02 80 01 1e be 4001a8e0 <msdos_find_name_in_fat_file+0x924>
4001a46c: aa 10 00 1c mov %i4, %l5
* 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)
4001a470: 80 8c e0 ff btst 0xff, %l3
4001a474: 12 80 00 07 bne 4001a490 <msdos_find_name_in_fat_file+0x4d4>
4001a478: c2 07 a0 58 ld [ %fp + 0x58 ], %g1
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
entries_per_block = bts2rd / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
4001a47c: 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);
4001a480: b7 36 e0 05 srl %i3, 5, %i3
4001a484: a0 04 00 02 add %l0, %g2, %l0
* 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 +=
4001a488: a0 24 00 1b sub %l0, %i3, %l0
* 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)
4001a48c: c2 07 a0 58 ld [ %fp + 0x58 ], %g1
4001a490: 80 a0 60 02 cmp %g1, 2
4001a494: 02 80 01 1d be 4001a908 <msdos_find_name_in_fat_file+0x94c>
4001a498: 90 10 00 17 mov %l7, %o0
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
msdos_short_name_hex(MSDOS_DIR_NAME(name_dir_entry), slot);
}
if (lfn_entries)
4001a49c: c4 07 bf e4 ld [ %fp + -28 ], %g2
4001a4a0: 80 a0 a0 00 cmp %g2, 0
4001a4a4: 02 80 00 15 be 4001a4f8 <msdos_find_name_in_fat_file+0x53c>
4001a4a8: b6 10 20 00 clr %i3
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
4001a4ac: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
4001a4b0: 84 10 20 00 clr %g2
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
4001a4b4: 88 00 60 0b add %g1, 0xb, %g4
4001a4b8: 10 80 00 07 b 4001a4d4 <msdos_find_name_in_fat_file+0x518>
4001a4bc: 86 10 00 01 mov %g1, %g3
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
4001a4c0: 84 08 a0 01 and %g2, 1, %g2
4001a4c4: 80 a0 00 02 cmp %g0, %g2
4001a4c8: 84 40 3f ff addx %g0, -1, %g2
4001a4cc: 84 08 a0 80 and %g2, 0x80, %g2
4001a4d0: 84 00 bf 80 add %g2, -128, %g2
4001a4d4: fa 08 c0 00 ldub [ %g3 ], %i5
4001a4d8: 82 0e e0 ff and %i3, 0xff, %g1
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
4001a4dc: 86 00 e0 01 inc %g3
lfn_checksum =
4001a4e0: 83 30 60 01 srl %g1, 1, %g1
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
4001a4e4: 80 a0 c0 04 cmp %g3, %g4
lfn_checksum =
4001a4e8: 82 07 40 01 add %i5, %g1, %g1
4001a4ec: 84 00 40 02 add %g1, %g2, %g2
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
4001a4f0: 12 bf ff f4 bne 4001a4c0 <msdos_find_name_in_fat_file+0x504>
4001a4f4: b6 10 00 02 mov %g2, %i3
* 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)
4001a4f8: 80 a4 20 00 cmp %l0, 0
4001a4fc: 22 80 00 ba be,a 4001a7e4 <msdos_find_name_in_fat_file+0x828>
4001a500: ae 10 00 14 mov %l4, %l7
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;
4001a504: a8 1d 00 17 xor %l4, %l7, %l4
4001a508: 80 a0 00 14 cmp %g0, %l4
4001a50c: ba 40 20 00 addx %g0, 0, %i5
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
4001a510: c2 07 bf e4 ld [ %fp + -28 ], %g1
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
4001a514: 84 10 3f ff mov -1, %g2
4001a518: c4 27 bf fc st %g2, [ %fp + -4 ]
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
4001a51c: 80 a0 60 00 cmp %g1, 0
4001a520: 06 80 00 af bl 4001a7dc <msdos_find_name_in_fat_file+0x820><== NEVER TAKEN
4001a524: c4 27 bf f8 st %g2, [ %fp + -8 ]
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
4001a528: b8 00 60 01 add %g1, 1, %i4
4001a52c: 90 10 00 17 mov %l7, %o0
4001a530: 7f ff a0 17 call 4000258c <.umul>
4001a534: 92 10 00 11 mov %l1, %o1
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,
4001a538: f2 07 a0 48 ld [ %fp + 0x48 ], %i1
4001a53c: b0 10 00 08 mov %o0, %i0
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
lfn_entry = 0;
4001a540: a0 10 20 00 clr %l0
4001a544: b4 10 00 1c mov %i4, %i2
*/
while (lfn_entry < (lfn_entries + 1))
{
int length = 0;
if (read_cluster)
4001a548: 80 8f 60 ff btst 0xff, %i5
4001a54c: 32 80 00 b9 bne,a 4001a830 <msdos_find_name_in_fat_file+0x874>
4001a550: d8 05 60 a0 ld [ %l5 + 0xa0 ], %o4
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
4001a554: 80 a4 40 12 cmp %l1, %l2
4001a558: 08 80 00 e9 bleu 4001a8fc <msdos_find_name_in_fat_file+0x940><== NEVER TAKEN
4001a55c: a8 04 20 01 add %l0, 1, %l4
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
4001a560: ec 05 60 a0 ld [ %l5 + 0xa0 ], %l6
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
4001a564: 80 a7 00 14 cmp %i4, %l4
4001a568: 02 80 00 e2 be 4001a8f0 <msdos_find_name_in_fat_file+0x934>
4001a56c: ac 05 80 12 add %l6, %l2, %l6
* 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(
4001a570: c4 07 bf e4 ld [ %fp + -28 ], %g2
4001a574: 82 38 00 10 xnor %g0, %l0, %g1
4001a578: 82 00 40 02 add %g1, %g2, %g1
4001a57c: 85 28 60 02 sll %g1, 2, %g2
4001a580: 87 28 60 04 sll %g1, 4, %g3
4001a584: 84 20 c0 02 sub %g3, %g2, %g2
4001a588: 82 00 80 01 add %g2, %g1, %g1
4001a58c: c4 07 a0 50 ld [ %fp + 0x50 ], %g2
4001a590: a0 10 00 12 mov %l2, %l0
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
4001a594: ba 10 20 20 mov 0x20, %i5
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
4001a598: a6 00 80 01 add %g2, %g1, %l3
* 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)
4001a59c: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001a5a0: 80 a0 7f ff cmp %g1, -1
4001a5a4: 22 80 00 96 be,a 4001a7fc <msdos_find_name_in_fat_file+0x840>
4001a5a8: ee 27 bf f8 st %l7, [ %fp + -8 ]
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
4001a5ac: 94 10 20 20 mov 0x20, %o2
4001a5b0: 90 10 00 16 mov %l6, %o0
4001a5b4: 40 00 0e d9 call 4001e118 <memset>
4001a5b8: 92 10 20 00 clr %o1
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
4001a5bc: 86 10 00 13 mov %l3, %g3
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
4001a5c0: f6 2d a0 0d stb %i3, [ %l6 + 0xd ]
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
4001a5c4: de 48 c0 00 ldsb [ %g3 ], %o7
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
4001a5c8: 84 10 20 01 mov 1, %g2
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
4001a5cc: 82 05 a0 01 add %l6, 1, %g1
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
4001a5d0: 96 10 20 00 clr %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(
4001a5d4: 88 00 bf ff add %g2, -1, %g4
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
4001a5d8: 80 a3 e0 00 cmp %o7, 0
4001a5dc: 02 80 00 11 be 4001a620 <msdos_find_name_in_fat_file+0x664><== NEVER TAKEN
4001a5e0: d4 08 c0 00 ldub [ %g3 ], %o2
{
*p = *n;
4001a5e4: d4 28 40 00 stb %o2, [ %g1 ]
p [0] = fill;
p [1] = fill;
fill = 0xff;
}
switch (i)
4001a5e8: 80 a1 20 04 cmp %g4, 4
4001a5ec: 02 80 00 12 be 4001a634 <msdos_find_name_in_fat_file+0x678>
4001a5f0: 86 00 e0 01 inc %g3
4001a5f4: 80 a1 20 0a cmp %g4, 0xa
4001a5f8: 02 80 00 7e be 4001a7f0 <msdos_find_name_in_fat_file+0x834>
4001a5fc: 80 a0 a0 0d cmp %g2, 0xd
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
4001a600: 02 80 00 33 be 4001a6cc <msdos_find_name_in_fat_file+0x710>
4001a604: 82 00 60 02 add %g1, 2, %g1
4001a608: 84 00 a0 01 inc %g2
{
if (*n != 0)
4001a60c: de 48 c0 00 ldsb [ %g3 ], %o7
* 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(
4001a610: 88 00 bf ff add %g2, -1, %g4
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
4001a614: 80 a3 e0 00 cmp %o7, 0
4001a618: 12 bf ff f3 bne 4001a5e4 <msdos_find_name_in_fat_file+0x628>
4001a61c: d4 08 c0 00 ldub [ %g3 ], %o2
*p = *n;
n++;
}
else
{
p [0] = fill;
4001a620: d6 28 40 00 stb %o3, [ %g1 ]
p [1] = fill;
4001a624: d6 28 60 01 stb %o3, [ %g1 + 1 ]
fill = 0xff;
}
switch (i)
4001a628: 80 a1 20 04 cmp %g4, 4
4001a62c: 12 bf ff f2 bne 4001a5f4 <msdos_find_name_in_fat_file+0x638>
4001a630: 96 10 3f ff mov -1, %o3
{
case 4:
p += 5;
4001a634: 82 00 60 05 add %g1, 5, %g1
4001a638: 10 bf ff f5 b 4001a60c <msdos_find_name_in_fat_file+0x650>
4001a63c: 84 00 a0 01 inc %g2
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
4001a640: 80 a0 60 00 cmp %g1, 0
4001a644: 32 bf fe 7d bne,a 4001a038 <msdos_find_name_in_fat_file+0x7c><== NEVER TAKEN
4001a648: e2 15 60 06 lduh [ %l5 + 6 ], %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
4001a64c: c2 0d 60 0e ldub [ %l5 + 0xe ], %g1
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
4001a650: 80 88 60 03 btst 3, %g1
4001a654: 22 bf fe 79 be,a 4001a038 <msdos_find_name_in_fat_file+0x7c>
4001a658: e2 15 60 06 lduh [ %l5 + 6 ], %l1
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
4001a65c: 10 bf fe 77 b 4001a038 <msdos_find_name_in_fat_file+0x7c>
4001a660: e2 00 a0 18 ld [ %g2 + 0x18 ], %l1
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
4001a664: 84 10 3f ff mov -1, %g2
4001a668: c4 27 bf f8 st %g2, [ %fp + -8 ]
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
4001a66c: 80 a6 20 00 cmp %i0, 0
4001a670: 12 bf ff 52 bne 4001a3b8 <msdos_find_name_in_fat_file+0x3fc>
4001a674: 84 10 20 00 clr %g2
4001a678: 10 bf ff 4d b 4001a3ac <msdos_find_name_in_fat_file+0x3f0>
4001a67c: c2 07 bf f8 ld [ %fp + -8 ], %g1
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
4001a680: 81 c7 e0 08 ret <== NOT EXECUTED
4001a684: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
4001a688: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
4001a68c: 82 10 3f ff mov -1, %g1
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
4001a690: d0 07 a0 60 ld [ %fp + 0x60 ], %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
4001a694: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
4001a698: c2 07 bf fc ld [ %fp + -4 ], %g1
memcpy(name_dir_entry, entry,
4001a69c: 92 10 00 1d mov %i5, %o1
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
4001a6a0: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
memcpy(name_dir_entry, entry,
4001a6a4: 40 00 0e 60 call 4001e024 <memcpy>
4001a6a8: 94 10 20 20 mov 0x20, %o2
4001a6ac: 81 c7 e0 08 ret
4001a6b0: 81 e8 00 00 restore
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
4001a6b4: 40 00 0b b7 call 4001d590 <__errno> <== NOT EXECUTED
4001a6b8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001a6bc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001a6c0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001a6c4: 81 c7 e0 08 ret <== NOT EXECUTED
4001a6c8: 81 e8 00 00 restore <== NOT EXECUTED
* RC_OK on success, or error code if error occured (errno set
* appropriately)
*
*/
#define MSDOS_FIND_PRINT 0
int msdos_find_name_in_fat_file(
4001a6cc: 82 26 80 14 sub %i2, %l4, %g1
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
4001a6d0: 80 a5 20 01 cmp %l4, 1
4001a6d4: 02 80 00 4c be 4001a804 <msdos_find_name_in_fat_file+0x848>
4001a6d8: c2 2d 80 00 stb %g1, [ %l6 ]
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
4001a6dc: c2 0d a0 0b ldub [ %l6 + 0xb ], %g1
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001a6e0: a0 04 20 20 add %l0, 0x20, %l0
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
4001a6e4: 82 10 60 0f or %g1, 0xf, %g1
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
4001a6e8: 80 a4 40 10 cmp %l1, %l0
4001a6ec: 08 80 00 4e bleu 4001a824 <msdos_find_name_in_fat_file+0x868><== NEVER TAKEN
4001a6f0: c2 2d a0 0b stb %g1, [ %l6 + 0xb ]
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
4001a6f4: ec 05 60 a0 ld [ %l5 + 0xa0 ], %l6
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
4001a6f8: a8 05 20 01 inc %l4
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;
4001a6fc: ac 05 80 10 add %l6, %l0, %l6
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
4001a700: ba 07 60 20 add %i5, 0x20, %i5
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
4001a704: 80 a7 00 14 cmp %i4, %l4
4001a708: 12 bf ff a5 bne 4001a59c <msdos_find_name_in_fat_file+0x5e0>
4001a70c: a6 04 ff f3 add %l3, -13, %l3
{
/* get current cluster number */
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
4001a710: d8 07 a0 5c ld [ %fp + 0x5c ], %o4
4001a714: 90 10 00 15 mov %l5, %o0
4001a718: 92 10 00 19 mov %i1, %o1
4001a71c: 94 10 20 01 mov 1, %o2
4001a720: 7f ff e5 8a call 40013d48 <fat_file_ioctl>
4001a724: 96 10 00 18 mov %i0, %o3
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
4001a728: 80 a2 20 00 cmp %o0, 0
4001a72c: 12 bf ff d5 bne 4001a680 <msdos_find_name_in_fat_file+0x6c4><== NEVER TAKEN
4001a730: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
4001a734: d2 07 bf f8 ld [ %fp + -8 ], %o1
4001a738: 80 a2 7f ff cmp %o1, -1
4001a73c: 02 80 00 67 be 4001a8d8 <msdos_find_name_in_fat_file+0x91c>
4001a740: e0 20 a0 04 st %l0, [ %g2 + 4 ]
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
4001a744: 7f ff 9f 92 call 4000258c <.umul>
4001a748: 90 10 00 11 mov %l1, %o0
4001a74c: 92 10 00 19 mov %i1, %o1
4001a750: 96 10 00 08 mov %o0, %o3
4001a754: 94 10 20 01 mov 1, %o2
4001a758: 90 10 00 15 mov %l5, %o0
4001a75c: 7f ff e5 7b call 40013d48 <fat_file_ioctl>
4001a760: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
4001a764: 80 a2 20 00 cmp %o0, 0
4001a768: 12 bf ff c6 bne 4001a680 <msdos_find_name_in_fat_file+0x6c4><== NEVER TAKEN
4001a76c: c2 07 bf f8 ld [ %fp + -8 ], %g1
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
4001a770: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
4001a774: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
4001a778: c2 20 a0 08 st %g1, [ %g2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
4001a77c: c2 07 bf fc ld [ %fp + -4 ], %g1
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
4001a780: 90 10 00 16 mov %l6, %o0
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
4001a784: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
4001a788: 40 00 0e 27 call 4001e024 <memcpy>
4001a78c: 94 10 20 20 mov 0x20, %o2
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
4001a790: a0 10 00 14 mov %l4, %l0
4001a794: 96 10 00 1d mov %i5, %o3
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
}
ret = fat_file_write(&fs_info->fat, fat_fd,
4001a798: d8 05 60 a0 ld [ %l5 + 0xa0 ], %o4
4001a79c: 90 10 00 15 mov %l5, %o0
4001a7a0: 92 10 00 19 mov %i1, %o1
4001a7a4: 94 06 00 12 add %i0, %l2, %o2
4001a7a8: 7f ff e6 32 call 40014070 <fat_file_write>
4001a7ac: 98 03 00 12 add %o4, %l2, %o4
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
4001a7b0: 80 a2 3f ff cmp %o0, -1
4001a7b4: 02 80 00 84 be 4001a9c4 <msdos_find_name_in_fat_file+0xa08><== NEVER TAKEN
4001a7b8: 80 a2 00 1d cmp %o0, %i5
return ret;
else if (ret != length)
4001a7bc: 12 bf ff be bne 4001a6b4 <msdos_find_name_in_fat_file+0x6f8><== NEVER TAKEN
4001a7c0: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
4001a7c4: ae 05 e0 01 inc %l7
4001a7c8: b0 06 00 11 add %i0, %l1, %i0
empty_space_entry = 0;
4001a7cc: a4 10 20 00 clr %l2
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
4001a7d0: 80 a0 40 10 cmp %g1, %l0
4001a7d4: 16 bf ff 5d bge 4001a548 <msdos_find_name_in_fat_file+0x58c><== NEVER TAKEN
4001a7d8: ba 10 20 01 mov 1, %i5
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
4001a7dc: 81 c7 e0 08 ret
4001a7e0: 91 e8 20 00 restore %g0, 0, %o0
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
{
read_cluster = true;
4001a7e4: ba 10 20 01 mov 1, %i5
empty_space_offset = dir_offset;
empty_space_entry = 0;
4001a7e8: 10 bf ff 4a b 4001a510 <msdos_find_name_in_fat_file+0x554>
4001a7ec: a4 10 20 00 clr %l2
{
case 4:
p += 5;
break;
case 10:
p += 4;
4001a7f0: 82 00 60 04 add %g1, 4, %g1
4001a7f4: 10 bf ff 86 b 4001a60c <msdos_find_name_in_fat_file+0x650>
4001a7f8: 84 00 a0 01 inc %g2
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_start.cln = empty_space_offset;
lfn_start.ofs = dir_entry;
4001a7fc: 10 bf ff 6c b 4001a5ac <msdos_find_name_in_fat_file+0x5f0>
4001a800: e0 27 bf fc st %l0, [ %fp + -4 ]
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
4001a804: 82 10 60 40 or %g1, 0x40, %g1
4001a808: c2 2d 80 00 stb %g1, [ %l6 ]
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
4001a80c: c2 0d a0 0b ldub [ %l6 + 0xb ], %g1
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001a810: a0 04 20 20 add %l0, 0x20, %l0
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
4001a814: 82 10 60 0f or %g1, 0xf, %g1
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
4001a818: 80 a4 40 10 cmp %l1, %l0
4001a81c: 18 bf ff b6 bgu 4001a6f4 <msdos_find_name_in_fat_file+0x738><== ALWAYS TAKEN
4001a820: c2 2d a0 0b stb %g1, [ %l6 + 0xb ]
4001a824: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
4001a828: 10 bf ff dc b 4001a798 <msdos_find_name_in_fat_file+0x7dc><== NOT EXECUTED
4001a82c: a0 10 00 14 mov %l4, %l0 <== NOT EXECUTED
{
uint32_t new_length;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
#endif
ret = fat_file_read(&fs_info->fat, fat_fd,
4001a830: 90 10 00 15 mov %l5, %o0
4001a834: 92 10 00 19 mov %i1, %o1
4001a838: 94 10 00 18 mov %i0, %o2
4001a83c: 7f ff e4 4f call 40013978 <fat_file_read>
4001a840: 96 10 00 11 mov %l1, %o3
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
4001a844: 80 a2 00 11 cmp %o0, %l1
4001a848: 02 bf ff 43 be 4001a554 <msdos_find_name_in_fat_file+0x598><== NEVER TAKEN
4001a84c: 80 a2 20 00 cmp %o0, 0
{
if (ret != FAT_EOF)
4001a850: 12 80 00 1b bne 4001a8bc <msdos_find_name_in_fat_file+0x900><== NEVER TAKEN
4001a854: 90 10 00 15 mov %l5, %o0
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,
4001a858: 92 10 00 19 mov %i1, %o1
4001a85c: 94 10 20 00 clr %o2
4001a860: 96 10 00 18 mov %i0, %o3
4001a864: 7f ff e5 6e call 40013e1c <fat_file_extend>
4001a868: 98 07 bf f4 add %fp, -12, %o4
empty_space_offset * bts2rd, &new_length);
if (ret != RC_OK)
4001a86c: 80 a2 20 00 cmp %o0, 0
4001a870: 12 80 00 57 bne 4001a9cc <msdos_find_name_in_fat_file+0xa10><== NEVER TAKEN
4001a874: 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))
4001a878: 80 a0 40 18 cmp %g1, %i0
4001a87c: 12 80 00 10 bne 4001a8bc <msdos_find_name_in_fat_file+0x900><== NEVER TAKEN
4001a880: 92 10 20 00 clr %o1
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
4001a884: d0 05 60 a0 ld [ %l5 + 0xa0 ], %o0
4001a888: 40 00 0e 24 call 4001e118 <memset>
4001a88c: 94 10 00 11 mov %l1, %o2
ret = fat_file_write(&fs_info->fat, fat_fd,
4001a890: d8 05 60 a0 ld [ %l5 + 0xa0 ], %o4
4001a894: 90 10 00 15 mov %l5, %o0
4001a898: 92 10 00 19 mov %i1, %o1
4001a89c: 94 10 00 18 mov %i0, %o2
4001a8a0: 7f ff e5 f4 call 40014070 <fat_file_write>
4001a8a4: 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)
4001a8a8: 80 a2 3f ff cmp %o0, -1
4001a8ac: 02 80 00 48 be 4001a9cc <msdos_find_name_in_fat_file+0xa10><== ALWAYS TAKEN
4001a8b0: 80 a2 00 11 cmp %o0, %l1
return ret;
else if (ret != bts2rd)
4001a8b4: 02 bf ff 29 be 4001a558 <msdos_find_name_in_fat_file+0x59c><== NOT EXECUTED
4001a8b8: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
4001a8bc: 40 00 0b 35 call 4001d590 <__errno> <== NOT EXECUTED
4001a8c0: 01 00 00 00 nop <== NOT EXECUTED
4001a8c4: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
4001a8c8: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED
4001a8cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001a8d0: 81 c7 e0 08 ret
4001a8d4: 91 e8 00 02 restore %g0, %g2, %o0
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
4001a8d8: 10 bf ff a6 b 4001a770 <msdos_find_name_in_fat_file+0x7b4>
4001a8dc: 82 10 3f ff mov -1, %g1
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
return MSDOS_NAME_NOT_FOUND_ERR;
4001a8e0: 31 00 00 1f sethi %hi(0x7c00), %i0
4001a8e4: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01>
4001a8e8: 81 c7 e0 08 ret
4001a8ec: 81 e8 00 00 restore
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
4001a8f0: a0 10 00 12 mov %l2, %l0
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
4001a8f4: 10 bf ff 87 b 4001a710 <msdos_find_name_in_fat_file+0x754>
4001a8f8: ba 10 20 20 mov 0x20, %i5
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
4001a8fc: 96 10 20 00 clr %o3 <== NOT EXECUTED
4001a900: 10 bf ff a6 b 4001a798 <msdos_find_name_in_fat_file+0x7dc><== NOT EXECUTED
4001a904: ba 10 20 00 clr %i5 <== NOT EXECUTED
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
4001a908: 7f ff 9f 21 call 4000258c <.umul>
4001a90c: 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 == '.'))
4001a910: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
4001a914: 90 02 00 12 add %o0, %l2, %o0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
4001a918: c4 48 40 00 ldsb [ %g1 ], %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;
4001a91c: c2 07 bf e4 ld [ %fp + -28 ], %g1
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
4001a920: bb 32 20 05 srl %o0, 5, %i5
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
4001a924: 86 00 60 01 add %g1, 1, %g3
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
4001a928: 80 a0 a0 2e cmp %g2, 0x2e
4001a92c: 02 80 00 05 be 4001a940 <msdos_find_name_in_fat_file+0x984><== NEVER TAKEN
4001a930: ba 00 c0 1d add %g3, %i5, %i5
4001a934: 80 a0 a0 20 cmp %g2, 0x20
4001a938: 12 80 00 06 bne 4001a950 <msdos_find_name_in_fat_file+0x994>
4001a93c: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
*c = '_';
4001a940: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
4001a944: 84 10 20 5f mov 0x5f, %g2
4001a948: c4 28 40 00 stb %g2, [ %g1 ]
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
4001a94c: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
4001a950: c4 48 60 01 ldsb [ %g1 + 1 ], %g2
4001a954: 80 a0 a0 2e cmp %g2, 0x2e
4001a958: 02 80 00 06 be 4001a970 <msdos_find_name_in_fat_file+0x9b4><== NEVER TAKEN
4001a95c: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
4001a960: 80 a0 a0 20 cmp %g2, 0x20
4001a964: 12 80 00 06 bne 4001a97c <msdos_find_name_in_fat_file+0x9c0>
4001a968: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
*c = '_';
4001a96c: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
4001a970: 84 10 20 5f mov 0x5f, %g2
4001a974: c4 28 60 01 stb %g2, [ %g1 + 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++)
4001a978: c4 07 a0 60 ld [ %fp + 0x60 ], %g2
4001a97c: 09 10 00 b6 sethi %hi(0x4002d800), %g4
4001a980: 86 00 a0 02 add %g2, 2, %g3
4001a984: 88 11 22 d0 or %g4, 0x2d0, %g4
4001a988: 84 10 20 0c mov 0xc, %g2
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
4001a98c: 83 3f 40 02 sra %i5, %g2, %g1
4001a990: 82 08 60 0f and %g1, 0xf, %g1
4001a994: c2 09 00 01 ldub [ %g4 + %g1 ], %g1
4001a998: 84 00 bf fc add %g2, -4, %g2
4001a99c: c2 28 c0 00 stb %g1, [ %g3 ]
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++)
4001a9a0: 80 a0 bf fc cmp %g2, -4
4001a9a4: 12 bf ff fa bne 4001a98c <msdos_find_name_in_fat_file+0x9d0>
4001a9a8: 86 00 e0 01 inc %g3
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
4001a9ac: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
4001a9b0: 84 10 20 7e mov 0x7e, %g2
4001a9b4: c4 28 60 06 stb %g2, [ %g1 + 6 ]
*c++ = '1';
4001a9b8: 84 10 20 31 mov 0x31, %g2
4001a9bc: 10 bf fe b8 b 4001a49c <msdos_find_name_in_fat_file+0x4e0>
4001a9c0: c4 28 60 07 stb %g2, [ %g1 + 7 ]
}
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)
4001a9c4: 81 c7 e0 08 ret <== NOT EXECUTED
4001a9c8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
4001a9cc: 10 bf ff c1 b 4001a8d0 <msdos_find_name_in_fat_file+0x914>
4001a9d0: 84 10 00 08 mov %o0, %g2
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
4001a9d4: 11 10 00 b8 sethi %hi(0x4002e000), %o0 <== NOT EXECUTED
4001a9d8: 15 10 00 b8 sethi %hi(0x4002e000), %o2 <== NOT EXECUTED
4001a9dc: 17 10 00 b8 sethi %hi(0x4002e000), %o3 <== NOT EXECUTED
4001a9e0: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
4001a9e4: 92 10 23 c9 mov 0x3c9, %o1 <== NOT EXECUTED
4001a9e8: 94 12 a3 c8 or %o2, 0x3c8, %o2 <== NOT EXECUTED
4001a9ec: 7f ff ac 84 call 40005bfc <__assert_func> <== NOT EXECUTED
4001a9f0: 96 12 e3 88 or %o3, 0x388, %o3 <== NOT EXECUTED
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
4001a9f4: 11 10 00 b8 sethi %hi(0x4002e000), %o0 <== NOT EXECUTED
4001a9f8: 15 10 00 b8 sethi %hi(0x4002e000), %o2 <== NOT EXECUTED
4001a9fc: 17 10 00 b8 sethi %hi(0x4002e000), %o3 <== NOT EXECUTED
4001aa00: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
4001aa04: 92 10 23 f9 mov 0x3f9, %o1 <== NOT EXECUTED
4001aa08: 94 12 a3 c8 or %o2, 0x3c8, %o2 <== NOT EXECUTED
4001aa0c: 7f ff ac 7c call 40005bfc <__assert_func> <== NOT EXECUTED
4001aa10: 96 12 e3 98 or %o3, 0x398, %o3 <== NOT EXECUTED
4001aa18 <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
)
{
4001aa18: 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) &&
4001aa1c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
4001aa20: 80 a0 60 01 cmp %g1, 1
4001aa24: 02 80 00 36 be 4001aafc <msdos_find_node_by_cluster_num_in_fat_file+0xe4><== NEVER TAKEN
4001aa28: e4 06 20 08 ld [ %i0 + 8 ], %l2
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
4001aa2c: e2 14 a0 06 lduh [ %l2 + 6 ], %l1
4001aa30: d8 04 a0 a0 ld [ %l2 + 0xa0 ], %o4
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
4001aa34: 31 00 00 3f sethi %hi(0xfc00), %i0
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
4001aa38: a6 10 20 00 clr %l3
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
4001aa3c: b0 16 23 ff or %i0, 0x3ff, %i0
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
4001aa40: 90 10 00 12 mov %l2, %o0
4001aa44: 92 10 00 19 mov %i1, %o1
4001aa48: 94 10 00 13 mov %l3, %o2
4001aa4c: 7f ff e3 cb call 40013978 <fat_file_read>
4001aa50: 96 10 00 11 mov %l1, %o3
4001aa54: 80 a2 20 00 cmp %o0, 0
4001aa58: 02 80 00 25 be 4001aaec <msdos_find_node_by_cluster_num_in_fat_file+0xd4><== NEVER TAKEN
4001aa5c: 80 a2 20 1f cmp %o0, 0x1f
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
4001aa60: 04 80 00 42 ble 4001ab68 <msdos_find_node_by_cluster_num_in_fat_file+0x150><== NEVER TAKEN
4001aa64: 80 a2 00 11 cmp %o0, %l1
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
4001aa68: 12 80 00 46 bne 4001ab80 <msdos_find_node_by_cluster_num_in_fat_file+0x168><== NEVER TAKEN
4001aa6c: a0 10 20 00 clr %l0
4001aa70: d8 04 a0 a0 ld [ %l2 + 0xa0 ], %o4
4001aa74: ba 10 00 0c mov %o4, %i5
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
4001aa78: c2 0f 40 00 ldub [ %i5 ], %g1
4001aa7c: 80 a0 60 00 cmp %g1, 0
4001aa80: 02 80 00 1b be 4001aaec <msdos_find_node_by_cluster_num_in_fat_file+0xd4><== NEVER TAKEN
4001aa84: 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)) ==
4001aa88: 22 80 00 14 be,a 4001aad8 <msdos_find_node_by_cluster_num_in_fat_file+0xc0><== NEVER TAKEN
4001aa8c: a0 04 20 20 add %l0, 0x20, %l0 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
4001aa90: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
4001aa94: c4 17 60 14 lduh [ %i5 + 0x14 ], %g2
4001aa98: 83 28 60 10 sll %g1, 0x10, %g1
4001aa9c: 85 28 a0 10 sll %g2, 0x10, %g2
4001aaa0: 89 30 60 18 srl %g1, 0x18, %g4
4001aaa4: 9f 30 a0 18 srl %g2, 0x18, %o7
4001aaa8: 87 30 60 08 srl %g1, 8, %g3
4001aaac: 85 30 a0 08 srl %g2, 8, %g2
4001aab0: 86 08 c0 18 and %g3, %i0, %g3
4001aab4: 84 08 80 18 and %g2, %i0, %g2
4001aab8: 86 11 00 03 or %g4, %g3, %g3
4001aabc: 82 13 c0 02 or %o7, %g2, %g1
4001aac0: 83 28 60 10 sll %g1, 0x10, %g1
4001aac4: 82 10 40 03 or %g1, %g3, %g1
4001aac8: 80 a0 40 1a cmp %g1, %i2
4001aacc: 22 80 00 16 be,a 4001ab24 <msdos_find_node_by_cluster_num_in_fat_file+0x10c>
4001aad0: 90 10 00 12 mov %l2, %o0
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
4001aad4: a0 04 20 20 add %l0, 0x20, %l0
4001aad8: 80 a4 00 11 cmp %l0, %l1
4001aadc: 0a bf ff e7 bcs 4001aa78 <msdos_find_node_by_cluster_num_in_fat_file+0x60><== ALWAYS TAKEN
4001aae0: ba 07 60 20 add %i5, 0x20, %i5
4001aae4: 10 bf ff d7 b 4001aa40 <msdos_find_node_by_cluster_num_in_fat_file+0x28><== NOT EXECUTED
4001aae8: a6 04 c0 11 add %l3, %l1, %l3 <== NOT EXECUTED
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
4001aaec: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
4001aaf0: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
4001aaf4: 81 c7 e0 08 ret <== NOT EXECUTED
4001aaf8: 81 e8 00 00 restore <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
4001aafc: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
4001ab00: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001ab04: 32 bf ff cb bne,a 4001aa30 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
4001ab08: e2 14 a0 06 lduh [ %l2 + 6 ], %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
4001ab0c: c2 0c a0 0e ldub [ %l2 + 0xe ], %g1 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
4001ab10: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
4001ab14: 22 bf ff c7 be,a 4001aa30 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
4001ab18: e2 14 a0 06 lduh [ %l2 + 6 ], %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
4001ab1c: 10 bf ff c5 b 4001aa30 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
4001ab20: e2 06 60 18 ld [ %i1 + 0x18 ], %l1 <== NOT EXECUTED
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
4001ab24: 92 10 00 19 mov %i1, %o1
4001ab28: 94 10 20 01 mov 1, %o2
4001ab2c: 96 10 00 13 mov %l3, %o3
4001ab30: 7f ff e4 86 call 40013d48 <fat_file_ioctl>
4001ab34: 98 10 00 1b mov %i3, %o4
&dir_pos->sname.cln);
if (rc != RC_OK)
4001ab38: b0 92 20 00 orcc %o0, 0, %i0
4001ab3c: 12 bf ff ee bne 4001aaf4 <msdos_find_node_by_cluster_num_in_fat_file+0xdc><== NEVER TAKEN
4001ab40: 82 10 3f ff mov -1, %g1
return rc;
dir_pos->sname.ofs = i;
4001ab44: e0 26 e0 04 st %l0, [ %i3 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4001ab48: c2 26 e0 08 st %g1, [ %i3 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4001ab4c: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
memcpy(dir_entry, entry,
4001ab50: 90 10 00 1c mov %i4, %o0
4001ab54: 92 10 00 1d mov %i5, %o1
4001ab58: 40 00 0d 33 call 4001e024 <memcpy>
4001ab5c: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
4001ab60: 81 c7 e0 08 ret
4001ab64: 81 e8 00 00 restore
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
4001ab68: 40 00 0a 8a call 4001d590 <__errno> <== NOT EXECUTED
4001ab6c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001ab70: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001ab74: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001ab78: 81 c7 e0 08 ret <== NOT EXECUTED
4001ab7c: 81 e8 00 00 restore <== NOT EXECUTED
assert(ret == bts2rd);
4001ab80: 11 10 00 b8 sethi %hi(0x4002e000), %o0 <== NOT EXECUTED
4001ab84: 15 10 00 b8 sethi %hi(0x4002e000), %o2 <== NOT EXECUTED
4001ab88: 17 10 00 b8 sethi %hi(0x4002e000), %o3 <== NOT EXECUTED
4001ab8c: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
4001ab90: 92 10 26 4e mov 0x64e, %o1 <== NOT EXECUTED
4001ab94: 94 12 a3 e8 or %o2, 0x3e8, %o2 <== NOT EXECUTED
4001ab98: 7f ff ac 19 call 40005bfc <__assert_func> <== NOT EXECUTED
4001ab9c: 96 12 e3 98 or %o3, 0x398, %o3 <== NOT EXECUTED
4000e848 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4000e848: 9d e3 bc d0 save %sp, -816, %sp <== NOT EXECUTED
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
4000e84c: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000e850: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000e854: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000e858: 7f ff ff 41 call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000e85c: 94 12 a0 d0 or %o2, 0xd0, %o2 ! 4002dcd0 <_CPU_Trap_slot_template+0x68><== NOT EXECUTED
fd = open(devname, O_RDWR);
4000e860: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000e864: 7f ff e0 b2 call 40006b2c <open> <== NOT EXECUTED
4000e868: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
if (fd == -1) {
4000e86c: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
4000e870: 02 80 01 88 be 4000ee90 <msdos_format+0x648> <== NOT EXECUTED
4000e874: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000e878: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4000e87c: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000e880: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000e884: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000e888: 7f ff ff 35 call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000e88c: 94 12 a1 a8 or %o2, 0x1a8, %o2 ! 4002dda8 <_CPU_Trap_slot_template+0x140><== NOT EXECUTED
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
4000e890: 92 07 bd 60 add %fp, -672, %o1 <== NOT EXECUTED
4000e894: 7f ff dd 68 call 40005e34 <fstat> <== NOT EXECUTED
4000e898: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4000e89c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
4000e8a0: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4000e8a4: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4000e8a8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000e8ac: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000e8b0: 7f ff ff 2b call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000e8b4: 94 12 a1 b8 or %o2, 0x1b8, %o2 ! 4002ddb8 <_CPU_Trap_slot_template+0x150><== NOT EXECUTED
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
4000e8b8: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
4000e8bc: 12 80 00 0c bne 4000e8ec <msdos_format+0xa4> <== NOT EXECUTED
4000e8c0: c4 07 bd 6c ld [ %fp + -660 ], %g2 <== NOT EXECUTED
4000e8c4: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
4000e8c8: 84 08 80 01 and %g2, %g1, %g2 <== NOT EXECUTED
4000e8cc: 03 00 00 18 sethi %hi(0x6000), %g1 <== NOT EXECUTED
4000e8d0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000e8d4: 02 80 00 13 be 4000e920 <msdos_format+0xd8> <== NOT EXECUTED
4000e8d8: 92 10 20 00 clr %o1 <== NOT EXECUTED
errno = ENOTTY;
4000e8dc: 40 00 3b 2d call 4001d590 <__errno> <== NOT EXECUTED
4000e8e0: ae 10 3f ff mov -1, %l7 <== NOT EXECUTED
4000e8e4: 82 10 20 19 mov 0x19, %g1 <== NOT EXECUTED
4000e8e8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000e8ec: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
4000e8f0: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
4000e8f4: c2 2f bd 57 stb %g1, [ %fp + -681 ] <== NOT EXECUTED
}
/*
* create master boot record
*/
if (ret_val == 0) {
4000e8f8: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
4000e8fc: 02 80 00 7d be 4000eaf0 <msdos_format+0x2a8> <== NOT EXECUTED
4000e900: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
4000e904: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
4000e908: 02 80 00 04 be 4000e918 <msdos_format+0xd0> <== NOT EXECUTED
4000e90c: 01 00 00 00 nop <== NOT EXECUTED
close(fd);
4000e910: 7f ff dc fd call 40005d04 <close> <== NOT EXECUTED
4000e914: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
}
return ret_val;
}
4000e918: 81 c7 e0 08 ret <== NOT EXECUTED
4000e91c: 91 e8 00 17 restore %g0, %l7, %o0 <== NOT EXECUTED
uint64_t total_size = 0;
uint32_t data_clusters_cnt;
uint8_t iteration_cnt = 0;
uint8_t fat_type = UINT8_MAX;
memset(fmt_params,0,sizeof(*fmt_params));
4000e920: 94 10 20 54 mov 0x54, %o2 <== NOT EXECUTED
4000e924: 40 00 3d fd call 4001e118 <memset> <== NOT EXECUTED
4000e928: 90 07 bd ac add %fp, -596, %o0 <== NOT EXECUTED
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);
4000e92c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000e930: 3b 10 01 10 sethi %hi(0x40044000), %i5 <== NOT EXECUTED
4000e934: 94 07 bd ac add %fp, -596, %o2 <== NOT EXECUTED
4000e938: 40 00 1e 51 call 4001627c <ioctl> <== NOT EXECUTED
4000e93c: 92 17 62 02 or %i5, 0x202, %o1 <== NOT EXECUTED
* 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) {
4000e940: 84 92 20 00 orcc %o0, 0, %g2 <== NOT EXECUTED
4000e944: 02 80 01 62 be 4000eecc <msdos_format+0x684> <== NOT EXECUTED
4000e948: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000e94c: ea 07 bd b0 ld [ %fp + -592 ], %l5 <== NOT EXECUTED
4000e950: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
4000e954: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
4000e958: c2 2f bd 57 stb %g1, [ %fp + -681 ] <== NOT EXECUTED
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
4000e95c: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
4000e960: 02 80 01 c7 be 4000f07c <msdos_format+0x834> <== NOT EXECUTED
4000e964: 01 00 00 00 nop <== NOT EXECUTED
4000e968: ae 10 00 02 mov %g2, %l7 <== NOT EXECUTED
4000e96c: fa 07 bd b4 ld [ %fp + -588 ], %i5 <== NOT EXECUTED
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
}
else {
fmt_params->media_code = rqdata->media;
4000e970: b8 10 20 00 clr %i4 <== NOT EXECUTED
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
4000e974: f4 07 bd c8 ld [ %fp + -568 ], %i2 <== NOT EXECUTED
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4000e978: d0 0f bd dc ldub [ %fp + -548 ], %o0 <== NOT EXECUTED
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
4000e97c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4000e980: 02 80 01 c4 be 4000f090 <msdos_format+0x848> <== NOT EXECUTED
4000e984: d2 07 bd bc ld [ %fp + -580 ], %o1 <== NOT EXECUTED
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4000e988: 7f ff cf 01 call 4000258c <.umul> <== NOT EXECUTED
4000e98c: 01 00 00 00 nop <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
4000e990: f4 27 bd d0 st %i2, [ %fp + -560 ] <== NOT EXECUTED
* 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);
4000e994: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
4000e998: d0 27 bd cc st %o0, [ %fp + -564 ] <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
4000e99c: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
4000e9a0: 12 80 00 46 bne 4000eab8 <msdos_format+0x270> <== NOT EXECUTED
4000e9a4: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
4000e9a8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4000e9ac: 02 80 03 8d be 4000f7e0 <msdos_format+0xf98> <== NOT EXECUTED
4000e9b0: 09 10 00 b7 sethi %hi(0x4002dc00), %g4 <== NOT EXECUTED
(rqdata->OEMName != NULL)) {
4000e9b4: c8 06 40 00 ld [ %i1 ], %g4 <== NOT EXECUTED
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
4000e9b8: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
4000e9bc: 22 80 03 89 be,a 4000f7e0 <msdos_format+0xf98> <== NOT EXECUTED
4000e9c0: 09 10 00 b7 sethi %hi(0x4002dc00), %g4 <== NOT EXECUTED
4000e9c4: 03 10 00 bb sethi %hi(0x4002ec00), %g1 <== NOT EXECUTED
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
4000e9c8: 84 10 20 08 mov 8, %g2 <== NOT EXECUTED
4000e9cc: f4 00 61 48 ld [ %g1 + 0x148 ], %i2 <== NOT EXECUTED
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4000e9d0: b0 10 20 20 mov 0x20, %i0 <== NOT EXECUTED
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
4000e9d4: 10 80 00 07 b 4000e9f0 <msdos_format+0x1a8> <== NOT EXECUTED
4000e9d8: 82 07 bd df add %fp, -545, %g1 <== NOT EXECUTED
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
4000e9dc: 82 00 60 01 inc %g1 <== NOT EXECUTED
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
4000e9e0: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
4000e9e4: 84 80 bf ff addcc %g2, -1, %g2 <== NOT EXECUTED
4000e9e8: 02 80 00 0e be 4000ea20 <msdos_format+0x1d8> <== NOT EXECUTED
4000e9ec: 88 01 20 01 inc %g4 <== NOT EXECUTED
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4000e9f0: c6 09 00 00 ldub [ %g4 ], %g3 <== NOT EXECUTED
4000e9f4: ba 08 e0 ff and %g3, 0xff, %i5 <== NOT EXECUTED
4000e9f8: ba 06 80 1d add %i2, %i5, %i5 <== NOT EXECUTED
4000e9fc: fa 4f 60 01 ldsb [ %i5 + 1 ], %i5 <== NOT EXECUTED
4000ea00: 80 8f 60 97 btst 0x97, %i5 <== NOT EXECUTED
4000ea04: 32 bf ff f6 bne,a 4000e9dc <msdos_format+0x194> <== NOT EXECUTED
4000ea08: c6 28 40 00 stb %g3, [ %g1 ] <== NOT EXECUTED
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4000ea0c: f0 28 40 00 stb %i0, [ %g1 ] <== NOT EXECUTED
4000ea10: 82 00 60 01 inc %g1 <== NOT EXECUTED
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
4000ea14: 84 80 bf ff addcc %g2, -1, %g2 <== NOT EXECUTED
4000ea18: 12 bf ff f6 bne 4000e9f0 <msdos_format+0x1a8> <== NOT EXECUTED
4000ea1c: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
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) &&
4000ea20: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4000ea24: 02 80 03 71 be 4000f7e8 <msdos_format+0xfa0> <== NOT EXECUTED
4000ea28: 09 10 00 b7 sethi %hi(0x4002dc00), %g4 <== NOT EXECUTED
(rqdata->VolLabel != NULL)) {
4000ea2c: c8 06 60 04 ld [ %i1 + 4 ], %g4 <== NOT EXECUTED
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) &&
4000ea30: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
4000ea34: 22 80 03 6d be,a 4000f7e8 <msdos_format+0xfa0> <== NOT EXECUTED
4000ea38: 09 10 00 b7 sethi %hi(0x4002dc00), %g4 <== NOT EXECUTED
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
4000ea3c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4000ea40: c2 2f bd f4 stb %g1, [ %fp + -524 ] <== NOT EXECUTED
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
4000ea44: 84 10 20 0b mov 0xb, %g2 <== NOT EXECUTED
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
4000ea48: 82 07 bd e8 add %fp, -536, %g1 <== NOT EXECUTED
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4000ea4c: 10 80 00 07 b 4000ea68 <msdos_format+0x220> <== NOT EXECUTED
4000ea50: b0 10 20 20 mov 0x20, %i0 <== NOT EXECUTED
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
4000ea54: 82 00 60 01 inc %g1 <== NOT EXECUTED
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
4000ea58: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
4000ea5c: 84 80 bf ff addcc %g2, -1, %g2 <== NOT EXECUTED
4000ea60: 02 80 00 0e be 4000ea98 <msdos_format+0x250> <== NOT EXECUTED
4000ea64: 88 01 20 01 inc %g4 <== NOT EXECUTED
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
4000ea68: c6 09 00 00 ldub [ %g4 ], %g3 <== NOT EXECUTED
4000ea6c: ba 08 e0 ff and %g3, 0xff, %i5 <== NOT EXECUTED
4000ea70: ba 06 80 1d add %i2, %i5, %i5 <== NOT EXECUTED
4000ea74: fa 4f 60 01 ldsb [ %i5 + 1 ], %i5 <== NOT EXECUTED
4000ea78: 80 8f 60 97 btst 0x97, %i5 <== NOT EXECUTED
4000ea7c: 32 bf ff f6 bne,a 4000ea54 <msdos_format+0x20c> <== NOT EXECUTED
4000ea80: c6 28 40 00 stb %g3, [ %g1 ] <== NOT EXECUTED
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
4000ea84: f0 28 40 00 stb %i0, [ %g1 ] <== NOT EXECUTED
4000ea88: 82 00 60 01 inc %g1 <== NOT EXECUTED
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
4000ea8c: 84 80 bf ff addcc %g2, -1, %g2 <== NOT EXECUTED
4000ea90: 12 bf ff f6 bne 4000ea68 <msdos_format+0x220> <== NOT EXECUTED
4000ea94: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
4000ea98: 40 00 22 51 call 400173dc <rtems_clock_get_tod_timeval> <== NOT EXECUTED
4000ea9c: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
if (rc == RTEMS_SUCCESSFUL) {
4000eaa0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000eaa4: 12 80 03 3d bne 4000f798 <msdos_format+0xf50> <== NOT EXECUTED
4000eaa8: c2 07 be 00 ld [ %fp + -512 ], %g1 <== NOT EXECUTED
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
4000eaac: 83 28 60 01 sll %g1, 1, %g1 <== NOT EXECUTED
4000eab0: c2 27 bd f8 st %g1, [ %fp + -520 ] <== NOT EXECUTED
ret_val = msdos_format_determine_fmt_params(fd,rqdata,&fmt_params);
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
4000eab4: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
4000eab8: 02 bf ff 91 be 4000e8fc <msdos_format+0xb4> <== NOT EXECUTED
4000eabc: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
(rqdata != NULL) &&
4000eac0: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1 <== NOT EXECUTED
4000eac4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000eac8: 12 80 00 0a bne 4000eaf0 <msdos_format+0x2a8> <== NOT EXECUTED
4000eacc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
4000ead0: d6 07 bd b0 ld [ %fp + -592 ], %o3 <== NOT EXECUTED
4000ead4: d8 07 bd ac ld [ %fp + -596 ], %o4 <== NOT EXECUTED
4000ead8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000eadc: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000eae0: 7f ff fe cc call 4000e610 <msdos_format_fill_sectors> <== NOT EXECUTED
4000eae4: 9a 10 3f e5 mov -27, %o5 <== NOT EXECUTED
4000eae8: 10 bf ff 84 b 4000e8f8 <msdos_format+0xb0> <== NOT EXECUTED
4000eaec: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
*/
if (ret_val == 0) {
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000eaf0: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000eaf4: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000eaf8: 7f ff fe 99 call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000eafc: 94 12 a1 58 or %o2, 0x158, %o2 ! 4002dd58 <_CPU_Trap_slot_template+0xf0><== NOT EXECUTED
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4000eb00: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
/*
* 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,
4000eb04: fa 07 bd ac ld [ %fp + -596 ], %i5 <== NOT EXECUTED
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4000eb08: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000eb0c: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000eb10: 40 00 1d fc call 40016300 <lseek> <== NOT EXECUTED
4000eb14: 96 10 20 00 clr %o3 <== NOT EXECUTED
4000eb18: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000eb1c: 06 80 01 16 bl 4000ef74 <msdos_format+0x72c> <== NOT EXECUTED
4000eb20: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
4000eb24: 92 07 be 00 add %fp, -512, %o1 <== NOT EXECUTED
4000eb28: 40 00 1e cc call 40016658 <read> <== NOT EXECUTED
4000eb2c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4000eb30: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000eb34: 06 80 01 10 bl 4000ef74 <msdos_format+0x72c> <== NOT EXECUTED
4000eb38: 90 10 00 19 mov %i1, %o0 <== 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,
4000eb3c: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000eb40: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000eb44: 7f ff fe 86 call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000eb48: 94 12 a1 c8 or %o2, 0x1c8, %o2 ! 4002ddc8 <_CPU_Trap_slot_template+0x160><== NOT EXECUTED
{
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) {
4000eb4c: c2 07 bd b0 ld [ %fp + -592 ], %g1 <== NOT EXECUTED
4000eb50: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED
4000eb54: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <PROM_START+0xffff> <== NOT EXECUTED
4000eb58: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4000eb5c: 08 80 02 f9 bleu 4000f740 <msdos_format+0xef8> <== NOT EXECUTED
4000eb60: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
4000eb64: 84 08 40 02 and %g1, %g2, %g2 <== NOT EXECUTED
4000eb68: a8 10 00 01 mov %g1, %l4 <== NOT EXECUTED
4000eb6c: a7 30 a0 08 srl %g2, 8, %l3 <== NOT EXECUTED
4000eb70: a5 30 60 10 srl %g1, 0x10, %l2 <== NOT EXECUTED
4000eb74: a3 30 60 18 srl %g1, 0x18, %l1 <== NOT EXECUTED
4000eb78: a0 10 20 00 clr %l0 <== NOT EXECUTED
4000eb7c: b0 10 20 00 clr %i0 <== NOT EXECUTED
* finally we are there: let's fill in the values into the MBR
* but first clear the MRB leaving the partition table.
*/
#define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be
#define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16)
memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
4000eb80: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000eb84: 94 10 21 be mov 0x1be, %o2 <== NOT EXECUTED
4000eb88: 40 00 3d 64 call 4001e118 <memset> <== NOT EXECUTED
4000eb8c: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
4000eb90: 90 07 be 03 add %fp, -509, %o0 <== NOT EXECUTED
* 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,
4000eb94: c0 37 bf fe clrh [ %fp + -2 ] <== NOT EXECUTED
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
4000eb98: 92 07 bd df add %fp, -545, %o1 <== NOT EXECUTED
4000eb9c: 40 00 3d 22 call 4001e024 <memcpy> <== NOT EXECUTED
4000eba0: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
4000eba4: c4 07 bd c4 ld [ %fp + -572 ], %g2 <== NOT EXECUTED
* 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);
4000eba8: c8 07 bd ac ld [ %fp + -596 ], %g4 <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
4000ebac: 83 30 a0 08 srl %g2, 8, %g1 <== NOT EXECUTED
4000ebb0: c2 2f be 12 stb %g1, [ %fp + -494 ] <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
4000ebb4: c2 0f bd dd ldub [ %fp + -547 ], %g1 <== NOT EXECUTED
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);
4000ebb8: c6 07 bd b4 ld [ %fp + -588 ], %g3 <== NOT EXECUTED
* 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);
4000ebbc: 9b 31 20 08 srl %g4, 8, %o5 <== NOT EXECUTED
4000ebc0: c8 2f be 0b stb %g4, [ %fp + -501 ] <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
4000ebc4: c8 07 bd b8 ld [ %fp + -584 ], %g4 <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
4000ebc8: fa 0f bd de ldub [ %fp + -546 ], %i5 <== NOT EXECUTED
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
4000ebcc: c2 2f be 15 stb %g1, [ %fp + -491 ] <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
4000ebd0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
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);
4000ebd4: 9f 30 e0 08 srl %g3, 8, %o7 <== NOT EXECUTED
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
4000ebd8: b4 10 20 02 mov 2, %i2 <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
4000ebdc: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
4000ebe0: c2 2f be 18 stb %g1, [ %fp + -488 ] <== NOT EXECUTED
* 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);
4000ebe4: da 2f be 0c stb %o5, [ %fp + -500 ] <== NOT EXECUTED
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
4000ebe8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED
*/
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);
4000ebec: c8 2f be 0d stb %g4, [ %fp + -499 ] <== NOT EXECUTED
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
4000ebf0: c6 2f be 0e stb %g3, [ %fp + -498 ] <== NOT EXECUTED
4000ebf4: de 2f be 0f stb %o7, [ %fp + -497 ] <== NOT EXECUTED
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
4000ebf8: f4 2f be 10 stb %i2, [ %fp + -496 ] <== NOT EXECUTED
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
4000ebfc: c4 2f be 11 stb %g2, [ %fp + -495 ] <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
4000ec00: f0 2f be 13 stb %i0, [ %fp + -493 ] <== NOT EXECUTED
4000ec04: e0 2f be 14 stb %l0, [ %fp + -492 ] <== NOT EXECUTED
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... */
4000ec08: c2 2f be 1a stb %g1, [ %fp + -486 ] <== NOT EXECUTED
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
4000ec0c: f8 2f be 1c stb %i4, [ %fp + -484 ] <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
4000ec10: e8 2f be 20 stb %l4, [ %fp + -480 ] <== NOT EXECUTED
4000ec14: e6 2f be 21 stb %l3, [ %fp + -479 ] <== NOT EXECUTED
4000ec18: e4 2f be 22 stb %l2, [ %fp + -478 ] <== NOT EXECUTED
if (fmt_params->fattype != FAT_FAT32) {
4000ec1c: 80 a7 60 04 cmp %i5, 4 <== NOT EXECUTED
4000ec20: 02 80 02 f7 be 4000f7fc <msdos_format+0xfb4> <== NOT EXECUTED
4000ec24: e2 2f be 23 stb %l1, [ %fp + -477 ] <== NOT EXECUTED
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 */
4000ec28: c2 07 bd f8 ld [ %fp + -520 ], %g1 <== NOT EXECUTED
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
4000ec2c: c4 07 bd bc ld [ %fp + -580 ], %g2 <== NOT EXECUTED
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 */
4000ec30: 89 30 60 10 srl %g1, 0x10, %g4 <== NOT EXECUTED
4000ec34: 87 30 60 18 srl %g1, 0x18, %g3 <== NOT EXECUTED
4000ec38: b9 30 60 08 srl %g1, 8, %i4 <== NOT EXECUTED
4000ec3c: c2 2f be 27 stb %g1, [ %fp + -473 ] <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
4000ec40: 82 10 20 29 mov 0x29, %g1 <== NOT EXECUTED
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
4000ec44: b5 30 a0 08 srl %g2, 8, %i2 <== NOT EXECUTED
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);
4000ec48: c2 2f be 26 stb %g1, [ %fp + -474 ] <== NOT EXECUTED
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
4000ec4c: c4 2f be 16 stb %g2, [ %fp + -490 ] <== NOT EXECUTED
4000ec50: f4 2f be 17 stb %i2, [ %fp + -489 ] <== NOT EXECUTED
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 */
4000ec54: f8 2f be 28 stb %i4, [ %fp + -472 ] <== NOT EXECUTED
4000ec58: c8 2f be 29 stb %g4, [ %fp + -471 ] <== NOT EXECUTED
4000ec5c: c6 2f be 2a stb %g3, [ %fp + -470 ] <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
4000ec60: 90 07 be 2b add %fp, -469, %o0 <== NOT EXECUTED
4000ec64: 92 07 bd e8 add %fp, -536, %o1 <== NOT EXECUTED
4000ec68: 40 00 3c ef call 4001e024 <memcpy> <== NOT EXECUTED
4000ec6c: 94 10 20 0b mov 0xb, %o2 <== NOT EXECUTED
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
4000ec70: 03 10 00 b7 sethi %hi(0x4002dc00), %g1 <== NOT EXECUTED
4000ec74: 80 a7 60 01 cmp %i5, 1 <== NOT EXECUTED
4000ec78: 02 80 02 c2 be 4000f780 <msdos_format+0xf38> <== NOT EXECUTED
4000ec7c: 82 10 60 b8 or %g1, 0xb8, %g1 <== NOT EXECUTED
4000ec80: c4 10 40 00 lduh [ %g1 ], %g2 <== NOT EXECUTED
4000ec84: c4 37 be 36 sth %g2, [ %fp + -458 ] <== NOT EXECUTED
4000ec88: c4 10 60 02 lduh [ %g1 + 2 ], %g2 <== NOT EXECUTED
4000ec8c: c4 37 be 38 sth %g2, [ %fp + -456 ] <== NOT EXECUTED
4000ec90: c4 10 60 04 lduh [ %g1 + 4 ], %g2 <== NOT EXECUTED
4000ec94: c4 37 be 3a sth %g2, [ %fp + -454 ] <== NOT EXECUTED
4000ec98: c2 10 60 06 lduh [ %g1 + 6 ], %g1 <== NOT EXECUTED
4000ec9c: c2 37 be 3c sth %g1, [ %fp + -452 ] <== NOT EXECUTED
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
4000eca0: 82 10 20 55 mov 0x55, %g1 <== NOT EXECUTED
4000eca4: c2 2f bf fe stb %g1, [ %fp + -2 ] <== NOT EXECUTED
4000eca8: 82 10 3f aa mov -86, %g1 <== NOT EXECUTED
4000ecac: c2 2f bf ff stb %g1, [ %fp + -1 ] <== NOT EXECUTED
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
4000ecb0: 82 10 3f eb mov -21, %g1 <== NOT EXECUTED
4000ecb4: c2 2f be 00 stb %g1, [ %fp + -512 ] <== NOT EXECUTED
FAT_SET_VAL8(mbr,1,0x3c);
4000ecb8: 82 10 20 3c mov 0x3c, %g1 <== NOT EXECUTED
4000ecbc: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
FAT_SET_VAL8(mbr,2,0x90);
4000ecc0: 82 10 3f 90 mov -112, %g1 <== NOT EXECUTED
/*
* 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,
4000ecc4: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000ecc8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
/*
* 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);
4000eccc: c2 2f be 02 stb %g1, [ %fp + -510 ] <== NOT EXECUTED
/*
* 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,
4000ecd0: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000ecd4: 7f ff fe 22 call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000ecd8: 94 12 a1 70 or %o2, 0x170, %o2 ! 4002dd70 <_CPU_Trap_slot_template+0x108><== NOT EXECUTED
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4000ecdc: d4 07 bd ac ld [ %fp + -596 ], %o2 <== NOT EXECUTED
4000ece0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000ece4: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000ece8: 7f ff fe 32 call 4000e5b0 <msdos_format_write_sec> <== NOT EXECUTED
4000ecec: 96 07 be 00 add %fp, -512, %o3 <== NOT EXECUTED
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
4000ecf0: ae 92 20 00 orcc %o0, 0, %l7 <== NOT EXECUTED
4000ecf4: 12 bf ff 04 bne 4000e904 <msdos_format+0xbc> <== NOT EXECUTED
4000ecf8: c2 07 bd d4 ld [ %fp + -556 ], %g1 <== NOT EXECUTED
4000ecfc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000ed00: 12 80 02 aa bne 4000f7a8 <msdos_format+0xf60> <== NOT EXECUTED
4000ed04: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
4000ed08: fa 07 bd d8 ld [ %fp + -552 ], %i5 <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4000ed0c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000ed10: 12 80 00 9b bne 4000ef7c <msdos_format+0x734> <== NOT EXECUTED
4000ed14: d2 07 bd bc ld [ %fp + -580 ], %o1 <== NOT EXECUTED
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
(rqdata,
4000ed18: d0 0f bd dc ldub [ %fp + -548 ], %o0 <== NOT EXECUTED
4000ed1c: 7f ff ce 1c call 4000258c <.umul> <== NOT EXECUTED
4000ed20: fa 07 bd b4 ld [ %fp + -588 ], %i5 <== NOT EXECUTED
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4000ed24: d8 07 bd ac ld [ %fp + -596 ], %o4 <== NOT EXECUTED
(rqdata,
4000ed28: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
4000ed2c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000ed30: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000ed34: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4000ed38: 7f ff fe 36 call 4000e610 <msdos_format_fill_sectors> <== NOT EXECUTED
4000ed3c: 9a 10 20 00 clr %o5 <== NOT EXECUTED
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
4000ed40: ae 92 20 00 orcc %o0, 0, %l7 <== NOT EXECUTED
4000ed44: 12 bf fe f0 bne 4000e904 <msdos_format+0xbc> <== NOT EXECUTED
4000ed48: d4 07 bd cc ld [ %fp + -564 ], %o2 <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
4000ed4c: d6 07 bd d0 ld [ %fp + -560 ], %o3 <== NOT EXECUTED
4000ed50: d8 07 bd ac ld [ %fp + -596 ], %o4 <== NOT EXECUTED
4000ed54: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000ed58: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000ed5c: 7f ff fe 2d call 4000e610 <msdos_format_fill_sectors> <== NOT EXECUTED
4000ed60: 9a 10 20 00 clr %o5 <== NOT EXECUTED
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
4000ed64: ae 92 20 00 orcc %o0, 0, %l7 <== NOT EXECUTED
4000ed68: 12 bf fe e7 bne 4000e904 <msdos_format+0xbc> <== NOT EXECUTED
4000ed6c: c2 0f bd f4 ldub [ %fp + -524 ], %g1 <== NOT EXECUTED
4000ed70: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000ed74: 12 80 00 a9 bne 4000f018 <msdos_format+0x7d0> <== NOT EXECUTED
4000ed78: 92 10 20 00 clr %o1 <== NOT EXECUTED
uint32_t start_sector;
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
4000ed7c: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
4000ed80: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000ed84: 40 00 3c e5 call 4001e118 <memset> <== NOT EXECUTED
4000ed88: 94 10 22 00 mov 0x200, %o2 <== NOT EXECUTED
switch(fmt_params.fattype) {
4000ed8c: c2 0f bd de ldub [ %fp + -546 ], %g1 <== NOT EXECUTED
4000ed90: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
4000ed94: 02 80 00 e2 be 4000f11c <msdos_format+0x8d4> <== NOT EXECUTED
4000ed98: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
4000ed9c: 02 80 00 c4 be 4000f0ac <msdos_format+0x864> <== NOT EXECUTED
4000eda0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
4000eda4: 02 80 00 d7 be 4000f100 <msdos_format+0x8b8> <== NOT EXECUTED
4000eda8: c2 0f bd dd ldub [ %fp + -547 ], %g1 <== NOT EXECUTED
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
errno = EINVAL;
4000edac: 40 00 39 f9 call 4001d590 <__errno> <== NOT EXECUTED
4000edb0: 01 00 00 00 nop <== NOT EXECUTED
4000edb4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
4000edb8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
4000edbc: c2 0f bd de ldub [ %fp + -546 ], %g1 <== NOT EXECUTED
4000edc0: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
4000edc4: 02 80 00 c7 be 4000f0e0 <msdos_format+0x898> <== NOT EXECUTED
4000edc8: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000edcc: c2 0f bd fc ldub [ %fp + -516 ], %g1 <== NOT EXECUTED
* 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,
4000edd0: f8 07 bd b4 ld [ %fp + -588 ], %i4 <== NOT EXECUTED
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000edd4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000edd8: 12 80 00 06 bne 4000edf0 <msdos_format+0x5a8> <== NOT EXECUTED
4000eddc: c4 07 bd b8 ld [ %fp + -584 ], %g2 <== NOT EXECUTED
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000ede0: b8 07 00 02 add %i4, %g2, %i4 <== NOT EXECUTED
4000ede4: 84 20 00 02 neg %g2 <== NOT EXECUTED
4000ede8: b8 07 3f ff add %i4, -1, %i4 <== NOT EXECUTED
4000edec: b8 0f 00 02 and %i4, %g2, %i4 <== NOT EXECUTED
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
4000edf0: c2 0f bd dc ldub [ %fp + -548 ], %g1 <== NOT EXECUTED
4000edf4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000edf8: 02 80 02 b0 be 4000f8b8 <msdos_format+0x1070> <== NOT EXECUTED
4000edfc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
(i < fmt_params.fat_num) && (ret_val == 0);
4000ee00: 12 80 00 5a bne 4000ef68 <msdos_format+0x720> <== NOT EXECUTED
4000ee04: d0 07 bd bc ld [ %fp + -580 ], %o0 <== NOT EXECUTED
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
4000ee08: 10 80 00 05 b 4000ee1c <msdos_format+0x5d4> <== NOT EXECUTED
4000ee0c: ba 10 20 00 clr %i5 <== NOT EXECUTED
(i < fmt_params.fat_num) && (ret_val == 0);
4000ee10: 32 bf fe bd bne,a 4000e904 <msdos_format+0xbc> <== NOT EXECUTED
4000ee14: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
4000ee18: d0 07 bd bc ld [ %fp + -580 ], %o0 <== NOT EXECUTED
i++) {
ret_val = msdos_format_write_sec
(fd,
start_sector
+ (i * fmt_params.sectors_per_fat),
4000ee1c: 7f ff cd dc call 4000258c <.umul> <== NOT EXECUTED
4000ee20: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
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
4000ee24: d4 07 bd ac ld [ %fp + -596 ], %o2 <== NOT EXECUTED
(fd,
4000ee28: 92 02 00 1c add %o0, %i4, %o1 <== NOT EXECUTED
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
4000ee2c: 96 07 be 00 add %fp, -512, %o3 <== NOT EXECUTED
4000ee30: 7f ff fd e0 call 4000e5b0 <msdos_format_write_sec> <== NOT EXECUTED
4000ee34: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
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);
4000ee38: c2 0f bd dc ldub [ %fp + -548 ], %g1 <== NOT EXECUTED
i++) {
4000ee3c: ba 07 60 01 inc %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;
4000ee40: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED
4000ee44: 14 bf ff f3 bg 4000ee10 <msdos_format+0x5c8> <== NOT EXECUTED
4000ee48: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000ee4c: c4 0f bd 57 ldub [ %fp + -681 ], %g2 <== NOT EXECUTED
4000ee50: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
4000ee54: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
4000ee58: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
4000ee5c: 80 88 60 ff btst 0xff, %g1 <== NOT EXECUTED
4000ee60: 22 bf fe a9 be,a 4000e904 <msdos_format+0xbc> <== NOT EXECUTED
4000ee64: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
4000ee68: c2 0e 60 17 ldub [ %i1 + 0x17 ], %g1 <== NOT EXECUTED
4000ee6c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000ee70: 02 bf fe a6 be 4000e908 <msdos_format+0xc0> <== NOT EXECUTED
4000ee74: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
}
static inline int rtems_disk_fd_sync(int fd)
{
return ioctl(fd, RTEMS_BLKIO_SYNCDEV);
4000ee78: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000ee7c: 13 08 00 10 sethi %hi(0x20004000), %o1 <== NOT EXECUTED
4000ee80: 40 00 1c ff call 4001627c <ioctl> <== NOT EXECUTED
4000ee84: 92 12 62 06 or %o1, 0x206, %o1 ! 20004206 <RAM_SIZE+0x1fc04206><== NOT EXECUTED
4000ee88: 10 bf fe 9f b 4000e904 <msdos_format+0xbc> <== NOT EXECUTED
4000ee8c: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000ee90: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4000ee94: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000ee98: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000ee9c: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000eea0: 7f ff fd af call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000eea4: 94 12 a1 a8 or %o2, 0x1a8, %o2 ! 4002dda8 <_CPU_Trap_slot_template+0x140><== NOT EXECUTED
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4000eea8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000eeac: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4000eeb0: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4000eeb4: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000eeb8: ae 10 3f ff mov -1, %l7 <== NOT EXECUTED
4000eebc: 7f ff fd a8 call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000eec0: 94 12 a1 b8 or %o2, 0x1b8, %o2 <== NOT EXECUTED
4000eec4: 10 bf fe 8b b 4000e8f0 <msdos_format+0xa8> <== NOT EXECUTED
4000eec8: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
static inline int rtems_disk_fd_get_block_count(
int fd,
rtems_blkdev_bnum *block_count
)
{
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
4000eecc: 92 17 62 05 or %i5, 0x205, %o1 <== NOT EXECUTED
4000eed0: 40 00 1c eb call 4001627c <ioctl> <== NOT EXECUTED
4000eed4: 94 07 bd b0 add %fp, -592, %o2 <== NOT EXECUTED
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) {
4000eed8: 84 92 20 00 orcc %o0, 0, %g2 <== NOT EXECUTED
4000eedc: 12 bf fe 9c bne 4000e94c <msdos_format+0x104> <== NOT EXECUTED
4000eee0: f0 07 bd ac ld [ %fp + -596 ], %i0 <== NOT EXECUTED
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
4000eee4: f4 07 bd b0 ld [ %fp + -592 ], %i2 <== NOT EXECUTED
4000eee8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4000eeec: 7f ff cd a8 call 4000258c <.umul> <== NOT EXECUTED
4000eef0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000eef4: 9a 10 20 00 clr %o5 <== NOT EXECUTED
}
if (ret_val == 0) {
ret_val = rtems_disk_fd_get_block_count(fd, &fmt_params->totl_sector_cnt);
}
if (ret_val == 0) {
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
4000eef8: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000eefc: d0 23 a0 5c st %o0, [ %sp + 0x5c ] <== NOT EXECUTED
}
if (ret_val == 0) {
ret_val = rtems_disk_fd_get_block_count(fd, &fmt_params->totl_sector_cnt);
}
if (ret_val == 0) {
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
4000ef00: b8 10 20 00 clr %i4 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000ef04: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000ef08: f8 3f bd 58 std %i4, [ %fp + -680 ] <== NOT EXECUTED
4000ef0c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000ef10: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4000ef14: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000ef18: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
4000ef1c: 7f ff fd 90 call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000ef20: 94 12 a0 e0 or %o2, 0xe0, %o2 <== NOT EXECUTED
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
4000ef24: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4000ef28: 02 80 02 69 be 4000f8cc <msdos_format+0x1084> <== NOT EXECUTED
4000ef2c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
(rqdata->fat_num == 0)) {
4000ef30: d6 06 60 0c ld [ %i1 + 0xc ], %o3 <== NOT EXECUTED
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
4000ef34: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
4000ef38: 22 80 00 82 be,a 4000f140 <msdos_format+0x8f8> <== NOT EXECUTED
4000ef3c: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
4000ef40: 80 a2 e0 06 cmp %o3, 6 <== NOT EXECUTED
4000ef44: 18 80 02 09 bgu 4000f768 <msdos_format+0xf20> <== NOT EXECUTED
4000ef48: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
fmt_params->fat_num = rqdata->fat_num;
4000ef4c: d6 2f bd dc stb %o3, [ %fp + -548 ] <== NOT EXECUTED
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000ef50: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000ef54: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000ef58: 7f ff fd 81 call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000ef5c: 94 12 a1 20 or %o2, 0x120, %o2 ! 4002dd20 <_CPU_Trap_slot_template+0xb8><== NOT EXECUTED
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
4000ef60: 10 80 00 7f b 4000f15c <msdos_format+0x914> <== NOT EXECUTED
4000ef64: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
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);
4000ef68: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
4000ef6c: 10 bf fe 66 b 4000e904 <msdos_format+0xbc> <== NOT EXECUTED
4000ef70: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
4000ef74: 10 bf fe 64 b 4000e904 <msdos_format+0xbc> <== NOT EXECUTED
4000ef78: ae 10 3f ff mov -1, %l7 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
4000ef7c: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000ef80: 94 10 22 00 mov 0x200, %o2 <== NOT EXECUTED
4000ef84: 40 00 3c 65 call 4001e118 <memset> <== NOT EXECUTED
4000ef88: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4000ef8c: 84 10 20 61 mov 0x61, %g2 <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4000ef90: d4 07 bd ac ld [ %fp + -596 ], %o2 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4000ef94: c4 2f be 02 stb %g2, [ %fp + -510 ] <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000ef98: c4 2f bf e7 stb %g2, [ %fp + -25 ] <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000ef9c: 84 10 20 55 mov 0x55, %g2 <== NOT EXECUTED
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
4000efa0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4000efa4: 86 10 20 41 mov 0x41, %g3 <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000efa8: 88 10 20 72 mov 0x72, %g4 <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000efac: c4 2f bf fe stb %g2, [ %fp + -2 ] <== NOT EXECUTED
4000efb0: 84 10 3f aa mov -86, %g2 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
4000efb4: b8 10 20 52 mov 0x52, %i4 <== NOT EXECUTED
4000efb8: c6 2f be 03 stb %g3, [ %fp + -509 ] <== NOT EXECUTED
4000efbc: f8 2f be 00 stb %i4, [ %fp + -512 ] <== NOT EXECUTED
4000efc0: f8 2f be 01 stb %i4, [ %fp + -511 ] <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000efc4: c8 2f bf e4 stb %g4, [ %fp + -28 ] <== NOT EXECUTED
4000efc8: c8 2f bf e5 stb %g4, [ %fp + -27 ] <== NOT EXECUTED
4000efcc: c6 2f bf e6 stb %g3, [ %fp + -26 ] <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000efd0: c4 2f bf ff stb %g2, [ %fp + -1 ] <== NOT EXECUTED
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
4000efd4: c2 2f bf e8 stb %g1, [ %fp + -24 ] <== NOT EXECUTED
4000efd8: c2 2f bf e9 stb %g1, [ %fp + -23 ] <== NOT EXECUTED
4000efdc: c2 2f bf ea stb %g1, [ %fp + -22 ] <== NOT EXECUTED
4000efe0: c2 2f bf eb stb %g1, [ %fp + -21 ] <== NOT EXECUTED
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
4000efe4: c2 2f bf ec stb %g1, [ %fp + -20 ] <== NOT EXECUTED
4000efe8: c2 2f bf ed stb %g1, [ %fp + -19 ] <== NOT EXECUTED
4000efec: c2 2f bf ee stb %g1, [ %fp + -18 ] <== NOT EXECUTED
4000eff0: c2 2f bf ef stb %g1, [ %fp + -17 ] <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
4000eff4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000eff8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000effc: 7f ff fd 6d call 4000e5b0 <msdos_format_write_sec> <== NOT EXECUTED
4000f000: 96 07 be 00 add %fp, -512, %o3 <== NOT EXECUTED
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
4000f004: ae 92 20 00 orcc %o0, 0, %l7 <== NOT EXECUTED
4000f008: 12 bf fe 40 bne 4000e908 <msdos_format+0xc0> <== NOT EXECUTED
4000f00c: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
(rqdata,
4000f010: 10 bf ff 42 b 4000ed18 <msdos_format+0x4d0> <== NOT EXECUTED
4000f014: d2 07 bd bc ld [ %fp + -580 ], %o1 <== NOT EXECUTED
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
4000f018: 94 10 22 00 mov 0x200, %o2 <== NOT EXECUTED
4000f01c: 40 00 3c 3f call 4001e118 <memset> <== NOT EXECUTED
4000f020: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
4000f024: c2 0f bd f2 ldub [ %fp + -526 ], %g1 <== NOT EXECUTED
4000f028: c6 07 bd ec ld [ %fp + -532 ], %g3 <== NOT EXECUTED
4000f02c: c4 17 bd f0 lduh [ %fp + -528 ], %g2 <== NOT EXECUTED
4000f030: c8 07 bd e8 ld [ %fp + -536 ], %g4 <== NOT EXECUTED
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
4000f034: d2 07 bd cc ld [ %fp + -564 ], %o1 <== NOT EXECUTED
4000f038: d4 07 bd ac ld [ %fp + -596 ], %o2 <== NOT EXECUTED
/*
* 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);
4000f03c: c2 2f be 0a stb %g1, [ %fp + -502 ] <== NOT EXECUTED
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
4000f040: 82 10 20 08 mov 8, %g1 <== NOT EXECUTED
/*
* 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);
4000f044: c8 27 be 00 st %g4, [ %fp + -512 ] <== NOT EXECUTED
4000f048: c6 27 be 04 st %g3, [ %fp + -508 ] <== NOT EXECUTED
4000f04c: c4 37 be 08 sth %g2, [ %fp + -504 ] <== NOT EXECUTED
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
4000f050: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
* 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;
4000f054: c2 2f be 0b stb %g1, [ %fp + -501 ] <== NOT EXECUTED
ret_val = msdos_format_write_sec
4000f058: 7f ff fd 56 call 4000e5b0 <msdos_format_write_sec> <== NOT EXECUTED
4000f05c: 96 07 be 00 add %fp, -512, %o3 <== NOT EXECUTED
/*
* 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) {
4000f060: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000f064: 22 bf ff 47 be,a 4000ed80 <msdos_format+0x538> <== NOT EXECUTED
4000f068: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
4000f06c: 10 bf fe 26 b 4000e904 <msdos_format+0xbc> <== NOT EXECUTED
4000f070: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
4000f074: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
4000f078: c2 2f bd 57 stb %g1, [ %fp + -681 ] <== NOT EXECUTED
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
{
errno = EINVAL;
4000f07c: 40 00 39 45 call 4001d590 <__errno> <== NOT EXECUTED
4000f080: ae 10 3f ff mov -1, %l7 <== NOT EXECUTED
4000f084: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000f088: 10 bf fe 39 b 4000e96c <msdos_format+0x124> <== NOT EXECUTED
4000f08c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4000f090: 7f ff cd 3f call 4000258c <.umul> <== NOT EXECUTED
4000f094: 01 00 00 00 nop <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4000f098: c2 07 bd b8 ld [ %fp + -584 ], %g1 <== NOT EXECUTED
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
4000f09c: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4000f0a0: c2 27 bd d0 st %g1, [ %fp + -560 ] <== NOT EXECUTED
}
else {
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
4000f0a4: 10 bf fe 3e b 4000e99c <msdos_format+0x154> <== NOT EXECUTED
4000f0a8: d0 27 bd cc st %o0, [ %fp + -564 ] <== NOT EXECUTED
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
4000f0ac: c4 0f bd dd ldub [ %fp + -547 ], %g2 <== NOT EXECUTED
4000f0b0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
4000f0b4: c4 2f be 00 stb %g2, [ %fp + -512 ] <== NOT EXECUTED
4000f0b8: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
4000f0bc: c2 2f be 02 stb %g1, [ %fp + -510 ] <== NOT EXECUTED
4000f0c0: c2 2f be 03 stb %g1, [ %fp + -509 ] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
4000f0c4: 84 10 3f f8 mov -8, %g2 <== NOT EXECUTED
4000f0c8: c2 2f be 05 stb %g1, [ %fp + -507 ] <== NOT EXECUTED
4000f0cc: c2 2f be 06 stb %g1, [ %fp + -506 ] <== NOT EXECUTED
4000f0d0: c4 2f be 04 stb %g2, [ %fp + -508 ] <== NOT EXECUTED
4000f0d4: 82 10 20 0f mov 0xf, %g1 <== NOT EXECUTED
4000f0d8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000f0dc: c2 2f be 07 stb %g1, [ %fp + -505 ] <== NOT EXECUTED
/*
* 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);
4000f0e0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
4000f0e4: 84 10 3f f8 mov -8, %g2 <== NOT EXECUTED
4000f0e8: c2 2f be 09 stb %g1, [ %fp + -503 ] <== NOT EXECUTED
4000f0ec: c2 2f be 0a stb %g1, [ %fp + -502 ] <== NOT EXECUTED
4000f0f0: c4 2f be 08 stb %g2, [ %fp + -504 ] <== NOT EXECUTED
4000f0f4: 82 10 20 0f mov 0xf, %g1 <== NOT EXECUTED
4000f0f8: 10 bf ff 35 b 4000edcc <msdos_format+0x584> <== NOT EXECUTED
4000f0fc: c2 2f be 0b stb %g1, [ %fp + -501 ] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
4000f100: 90 10 20 00 clr %o0 <== NOT EXECUTED
memset(tmp_sec,0,sizeof(tmp_sec));
switch(fmt_params.fattype) {
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
4000f104: c2 2f be 00 stb %g1, [ %fp + -512 ] <== NOT EXECUTED
/* 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)));
4000f108: 82 10 3f 8f mov -113, %g1 <== NOT EXECUTED
4000f10c: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
4000f110: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
4000f114: 10 bf ff 2e b 4000edcc <msdos_format+0x584> <== NOT EXECUTED
4000f118: c2 2f be 02 stb %g1, [ %fp + -510 ] <== NOT EXECUTED
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
4000f11c: c4 0f bd dd ldub [ %fp + -547 ], %g2 <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
4000f120: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
4000f124: c4 2f be 00 stb %g2, [ %fp + -512 ] <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
4000f128: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
4000f12c: 84 10 3f f8 mov -8, %g2 <== NOT EXECUTED
4000f130: c2 2f be 03 stb %g1, [ %fp + -509 ] <== NOT EXECUTED
4000f134: c4 2f be 02 stb %g2, [ %fp + -510 ] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
4000f138: 10 bf ff 25 b 4000edcc <msdos_format+0x584> <== NOT EXECUTED
4000f13c: 90 10 20 00 clr %o0 <== NOT EXECUTED
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
4000f140: c2 2f bd dc stb %g1, [ %fp + -548 ] <== NOT EXECUTED
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000f144: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000f148: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000f14c: 94 12 a1 20 or %o2, 0x120, %o2 <== NOT EXECUTED
4000f150: 7f ff fd 03 call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000f154: 96 10 20 02 mov 2, %o3 <== NOT EXECUTED
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
4000f158: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
4000f15c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000f160: 02 80 01 75 be 4000f734 <msdos_format+0xeec> <== NOT EXECUTED
4000f164: 07 00 00 1f sethi %hi(0x7c00), %g3 <== NOT EXECUTED
4000f168: 85 28 60 02 sll %g1, 2, %g2 <== NOT EXECUTED
4000f16c: 87 28 60 0a sll %g1, 0xa, %g3 <== NOT EXECUTED
4000f170: 86 20 c0 02 sub %g3, %g2, %g3 <== NOT EXECUTED
4000f174: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED
4000f178: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED
4000f17c: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED
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) {
4000f180: c4 07 bd b0 ld [ %fp + -592 ], %g2 <== NOT EXECUTED
4000f184: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
4000f188: 1a 80 01 4f bcc 4000f6c4 <msdos_format+0xe7c> <== NOT EXECUTED
4000f18c: 87 28 60 02 sll %g1, 2, %g3 <== NOT EXECUTED
fmt_params->fattype = FAT_FAT12;
4000f190: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4000f194: c2 2f bd de stb %g1, [ %fp + -546 ] <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4000f198: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
4000f19c: c2 27 bd b8 st %g1, [ %fp + -584 ] <== NOT EXECUTED
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 );
4000f1a0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000f1a4: 7f ff fd 88 call 4000e7c4 <msdos_set_sectors_per_cluster_from_request><== NOT EXECUTED
4000f1a8: 92 07 bd ac add %fp, -596, %o1 <== NOT EXECUTED
if (ret_val == 0) {
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
4000f1ac: ae 92 20 00 orcc %o0, 0, %l7 <== NOT EXECUTED
4000f1b0: 12 80 01 d2 bne 4000f8f8 <msdos_format+0x10b0> <== NOT EXECUTED
4000f1b4: c2 0f bd de ldub [ %fp + -546 ], %g1 <== NOT EXECUTED
&& fmt_params->fattype != fat_type
4000f1b8: 80 a0 60 ff cmp %g1, 0xff <== NOT EXECUTED
4000f1bc: 02 80 01 d5 be 4000f910 <msdos_format+0x10c8> <== NOT EXECUTED
4000f1c0: c2 07 bd b0 ld [ %fp + -592 ], %g1 <== NOT EXECUTED
&& fmt_params->totl_sector_cnt > 0 ) {
4000f1c4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000f1c8: 02 bf ff ab be 4000f074 <msdos_format+0x82c> <== NOT EXECUTED
4000f1cc: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
4000f1d0: 84 40 20 00 addx %g0, 0, %g2 <== NOT EXECUTED
4000f1d4: c4 2f bd 57 stb %g2, [ %fp + -681 ] <== NOT EXECUTED
4000f1d8: ec 0f bd 57 ldub [ %fp + -681 ], %l6 <== NOT EXECUTED
/* 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;
4000f1dc: 98 10 20 00 clr %o4 <== NOT EXECUTED
4000f1e0: 1b 10 00 00 sethi %hi(0x40000000), %o5 <== NOT EXECUTED
4000f1e4: 86 87 40 0d addcc %i5, %o5, %g3 <== NOT EXECUTED
4000f1e8: 84 47 00 0c addx %i4, %o4, %g2 <== NOT EXECUTED
4000f1ec: a6 10 20 00 clr %l3 <== NOT EXECUTED
4000f1f0: 89 28 a0 02 sll %g2, 2, %g4 <== NOT EXECUTED
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
4000f1f4: f6 27 bd 40 st %i3, [ %fp + -704 ] <== NOT EXECUTED
/* 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;
4000f1f8: 85 30 e0 1e srl %g3, 0x1e, %g2 <== NOT EXECUTED
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
4000f1fc: ee 27 bd 3c st %l7, [ %fp + -708 ] <== NOT EXECUTED
/* 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;
4000f200: 84 11 00 02 or %g4, %g2, %g2 <== NOT EXECUTED
4000f204: c4 27 bd 38 st %g2, [ %fp + -712 ] <== NOT EXECUTED
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
/*
* Skip aligning structures or d align them
*/
if (ret_val == 0 && rqdata != NULL)
4000f208: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
4000f20c: 02 80 00 05 be 4000f220 <msdos_format+0x9d8> <== NOT EXECUTED
4000f210: d6 07 bd b8 ld [ %fp + -584 ], %o3 <== NOT EXECUTED
fmt_params->skip_alignment = rqdata->skip_alignment;
4000f214: c2 0e 60 16 ldub [ %i1 + 0x16 ], %g1 <== NOT EXECUTED
4000f218: c2 2f bd fc stb %g1, [ %fp + -516 ] <== NOT EXECUTED
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000f21c: d6 07 bd b8 ld [ %fp + -584 ], %o3 <== NOT EXECUTED
4000f220: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000f224: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000f228: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000f22c: 7f ff fc cc call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000f230: 94 12 a1 38 or %o2, 0x138, %o2 ! 4002dd38 <_CPU_Trap_slot_template+0xd0><== NOT EXECUTED
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
4000f234: fa 0f bd de ldub [ %fp + -546 ], %i5 <== NOT EXECUTED
4000f238: 80 a7 60 04 cmp %i5, 4 <== NOT EXECUTED
4000f23c: 02 80 01 13 be 4000f688 <msdos_format+0xe40> <== NOT EXECUTED
4000f240: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
4000f244: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
4000f248: 02 80 01 0a be 4000f670 <msdos_format+0xe28> <== NOT EXECUTED
4000f24c: c8 27 bd b4 st %g4, [ %fp + -588 ] <== NOT EXECUTED
(rqdata->files_per_root_dir > 0)) {
4000f250: d0 06 60 10 ld [ %i1 + 0x10 ], %o0 <== NOT EXECUTED
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
4000f254: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000f258: 02 80 01 07 be 4000f674 <msdos_format+0xe2c> <== NOT EXECUTED
4000f25c: 82 1f 60 02 xor %i5, 2, %g1 <== NOT EXECUTED
4000f260: 90 02 3f ff add %o0, -1, %o0 <== NOT EXECUTED
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
4000f264: f6 07 bd ac ld [ %fp + -596 ], %i3 <== NOT EXECUTED
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
4000f268: a8 10 20 01 mov 1, %l4 <== NOT EXECUTED
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
4000f26c: 93 2e e0 01 sll %i3, 1, %o1 <== NOT EXECUTED
4000f270: 93 32 60 05 srl %o1, 5, %o1 <== NOT EXECUTED
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
4000f274: b8 02 00 09 add %o0, %o1, %i4 <== NOT EXECUTED
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
4000f278: 40 00 6d 20 call 4002a6f8 <.urem> <== NOT EXECUTED
4000f27c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000f280: 90 27 00 08 sub %i4, %o0, %o0 <== NOT EXECUTED
4000f284: d0 27 bd c4 st %o0, [ %fp + -572 ] <== NOT EXECUTED
4000f288: 91 2a 20 05 sll %o0, 5, %o0 <== NOT EXECUTED
}
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);
4000f28c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
4000f290: a4 06 ff ff add %i3, -1, %l2 <== NOT EXECUTED
/ fmt_params->bytes_per_sector);
4000f294: 7f ff cc f8 call 40002674 <.udiv> <== NOT EXECUTED
4000f298: 90 04 80 08 add %l2, %o0, %o0 <== NOT EXECUTED
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,
4000f29c: ee 07 bd b8 ld [ %fp + -584 ], %l7 <== NOT EXECUTED
}
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);
4000f2a0: d0 27 bd 4c st %o0, [ %fp + -692 ] <== NOT EXECUTED
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 =
4000f2a4: d0 27 bd c8 st %o0, [ %fp + -568 ] <== NOT EXECUTED
uint32_t fatdata_sect_cnt;
uint32_t fat_sectors_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4000f2a8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000f2ac: 7f ff cc f2 call 40002674 <.udiv> <== NOT EXECUTED
4000f2b0: 11 00 00 20 sethi %hi(0x8000), %o0 <== NOT EXECUTED
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,
4000f2b4: ea 07 bd b0 ld [ %fp + -592 ], %l5 <== NOT EXECUTED
4000f2b8: e2 0f bd dc ldub [ %fp + -548 ], %l1 <== NOT EXECUTED
uint32_t fatdata_sect_cnt;
uint32_t fat_sectors_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4000f2bc: 80 a5 c0 08 cmp %l7, %o0 <== NOT EXECUTED
4000f2c0: 08 80 00 06 bleu 4000f2d8 <msdos_format+0xa90> <== NOT EXECUTED
4000f2c4: f4 0f bd fc ldub [ %fp + -516 ], %i2 <== NOT EXECUTED
sectors_per_cluster /= 2;
4000f2c8: af 35 e0 01 srl %l7, 1, %l7 <== NOT EXECUTED
uint32_t fatdata_sect_cnt;
uint32_t fat_sectors_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
4000f2cc: 80 a2 00 17 cmp %o0, %l7 <== NOT EXECUTED
4000f2d0: 2a bf ff ff bcs,a 4000f2cc <msdos_format+0xa84> <== NOT EXECUTED
4000f2d4: af 35 e0 01 srl %l7, 1, %l7 <== NOT EXECUTED
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000f2d8: c4 07 bd 4c ld [ %fp + -692 ], %g2 <== NOT EXECUTED
* 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
4000f2dc: 82 25 40 14 sub %l5, %l4, %g1 <== 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);
4000f2e0: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4000f2e4: a2 0c 60 ff and %l1, 0xff, %l1 <== NOT EXECUTED
4000f2e8: b4 0e a0 ff and %i2, 0xff, %i2 <== NOT EXECUTED
* 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
4000f2ec: c2 27 bd 44 st %g1, [ %fp + -700 ] <== 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);
4000f2f0: a8 05 3f ff add %l4, -1, %l4 <== NOT EXECUTED
4000f2f4: c4 27 bd 48 st %g2, [ %fp + -696 ] <== NOT EXECUTED
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000f2f8: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4000f2fc: 02 80 00 0a be 4000f324 <msdos_format+0xadc> <== NOT EXECUTED
4000f300: 82 20 00 17 neg %l7, %g1 <== NOT EXECUTED
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_sect_cnt = total_sector_cnt
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
4000f304: 80 a7 60 01 cmp %i5, 1 <== NOT EXECUTED
4000f308: 02 80 01 8e be 4000f940 <msdos_format+0x10f8> <== NOT EXECUTED
4000f30c: d0 07 bd 44 ld [ %fp + -700 ], %o0 <== NOT EXECUTED
fatdata_sect_cnt = fatdata_sect_cnt
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
4000f310: 80 a7 60 02 cmp %i5, 2 <== NOT EXECUTED
4000f314: 12 80 00 0c bne 4000f344 <msdos_format+0xafc> <== NOT EXECUTED
4000f318: c2 07 bd 4c ld [ %fp + -692 ], %g1 <== NOT EXECUTED
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;
4000f31c: 10 80 00 99 b 4000f580 <msdos_format+0xd38> <== NOT EXECUTED
4000f320: 90 22 00 01 sub %o0, %g1, %o0 <== 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);
4000f324: 90 05 00 17 add %l4, %l7, %o0 <== NOT EXECUTED
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_sect_cnt = total_sector_cnt
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
4000f328: 80 a7 60 01 cmp %i5, 1 <== 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);
4000f32c: 90 08 40 08 and %g1, %o0, %o0 <== NOT EXECUTED
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_sect_cnt = total_sector_cnt
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
4000f330: 02 80 00 86 be 4000f548 <msdos_format+0xd00> <== NOT EXECUTED
4000f334: 90 25 40 08 sub %l5, %o0, %o0 <== NOT EXECUTED
fatdata_sect_cnt = fatdata_sect_cnt
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
4000f338: 80 a7 60 02 cmp %i5, 2 <== NOT EXECUTED
4000f33c: 02 80 00 8e be 4000f574 <msdos_format+0xd2c> <== NOT EXECUTED
4000f340: c8 07 bd 48 ld [ %fp + -696 ], %g4 <== NOT EXECUTED
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
fat_capacity = fatdata_cluster_cnt * 2;
}
else { /* FAT32 */
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
4000f344: 7f ff cc cc call 40002674 <.udiv> <== NOT EXECUTED
4000f348: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
4000f34c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 4;
4000f350: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED
}
sectors_per_fat = ((fat_capacity
4000f354: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000f358: 7f ff cc c7 call 40002674 <.udiv> <== NOT EXECUTED
4000f35c: 90 02 00 12 add %o0, %l2, %o0 <== NOT EXECUTED
+ (bytes_per_sector - 1))
/ bytes_per_sector);
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
4000f360: 7f ff cc 8b call 4000258c <.umul> <== NOT EXECUTED
4000f364: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000f368: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
4000f36c: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000f370: 12 80 00 05 bne 4000f384 <msdos_format+0xb3c> <== NOT EXECUTED
4000f374: 90 05 ff ff add %l7, -1, %o0 <== NOT EXECUTED
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000f378: 82 20 00 17 neg %l7, %g1 <== NOT EXECUTED
4000f37c: b8 07 00 08 add %i4, %o0, %i4 <== NOT EXECUTED
4000f380: b8 0f 00 01 and %i4, %g1, %i4 <== NOT EXECUTED
skip_alignment);
*data_cluster_cnt = (fatdata_cluster_cnt -
((fat_sectors_cnt
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
4000f384: 90 02 00 1c add %o0, %i4, %o0 <== NOT EXECUTED
4000f388: 7f ff cc bb call 40002674 <.udiv> <== NOT EXECUTED
4000f38c: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
4000f390: 80 a7 60 01 cmp %i5, 1 <== NOT EXECUTED
4000f394: 02 80 00 54 be 4000f4e4 <msdos_format+0xc9c> <== NOT EXECUTED
4000f398: b0 24 00 08 sub %l0, %o0, %i0 <== NOT EXECUTED
4000f39c: 80 a7 60 02 cmp %i5, 2 <== NOT EXECUTED
4000f3a0: 02 80 00 62 be 4000f528 <msdos_format+0xce0> <== NOT EXECUTED
4000f3a4: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
*/
if (fattype == FAT_FAT12) {
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
finished = true;
}
} else if ((sectors_per_cluster * bytes_per_sector)
4000f3a8: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
4000f3ac: 7f ff cc 78 call 4000258c <.umul> <== NOT EXECUTED
4000f3b0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000f3b4: 07 00 00 20 sethi %hi(0x8000), %g3 <== NOT EXECUTED
4000f3b8: 80 a2 00 03 cmp %o0, %g3 <== NOT EXECUTED
4000f3bc: 08 80 00 57 bleu 4000f518 <msdos_format+0xcd0> <== NOT EXECUTED
4000f3c0: 80 8c 20 ff btst 0xff, %l0 <== NOT EXECUTED
finished = true;
}
} while (!finished);
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
4000f3c4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4000f3c8: 7f ff cc ab call 40002674 <.udiv> <== NOT EXECUTED
4000f3cc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
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 =
4000f3d0: 09 10 00 b7 sethi %hi(0x4002dc00), %g4 <== NOT EXECUTED
finished = true;
}
} while (!finished);
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
4000f3d4: d0 27 bd bc st %o0, [ %fp + -580 ] <== NOT EXECUTED
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 =
4000f3d8: d0 01 21 f0 ld [ %g4 + 0x1f0 ], %o0 <== NOT EXECUTED
4000f3dc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
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;
4000f3e0: ee 27 bd b8 st %l7, [ %fp + -584 ] <== NOT EXECUTED
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 =
4000f3e4: 7f ff cc a4 call 40002674 <.udiv> <== NOT EXECUTED
4000f3e8: a0 10 00 18 mov %i0, %l0 <== NOT EXECUTED
( 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
4000f3ec: 80 a2 00 17 cmp %o0, %l7 <== NOT EXECUTED
4000f3f0: 1a 80 00 69 bcc 4000f594 <msdos_format+0xd4c> <== NOT EXECUTED
4000f3f4: 80 a6 2f f4 cmp %i0, 0xff4 <== NOT EXECUTED
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 =
4000f3f8: 03 10 00 b7 sethi %hi(0x4002dc00), %g1 <== NOT EXECUTED
4000f3fc: d0 00 61 f4 ld [ %g1 + 0x1f4 ], %o0 ! 4002ddf4 <_CPU_Trap_slot_template+0x18c><== NOT EXECUTED
4000f400: 7f ff cc 9d call 40002674 <.udiv> <== NOT EXECUTED
4000f404: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
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
4000f408: 80 a2 00 17 cmp %o0, %l7 <== NOT EXECUTED
4000f40c: 2a 80 00 07 bcs,a 4000f428 <msdos_format+0xbe0> <== NOT EXECUTED
4000f410: 84 10 20 04 mov 4, %g2 <== NOT EXECUTED
4000f414: 07 00 00 3f sethi %hi(0xfc00), %g3 <== NOT EXECUTED
4000f418: 86 10 e3 f4 or %g3, 0x3f4, %g3 ! fff4 <PROM_START+0xfff4> <== NOT EXECUTED
4000f41c: 80 a0 c0 10 cmp %g3, %l0 <== NOT EXECUTED
4000f420: 0a 80 00 2f bcs 4000f4dc <msdos_format+0xc94> <== NOT EXECUTED
4000f424: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED
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) {
4000f428: 82 08 a0 ff and %g2, 0xff, %g1 <== NOT EXECUTED
4000f42c: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4000f430: 02 80 00 5f be 4000f5ac <msdos_format+0xd64> <== NOT EXECUTED
4000f434: c4 2f bd de stb %g2, [ %fp + -546 ] <== NOT EXECUTED
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 ) {
4000f438: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
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
4000f43c: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
4000f440: 84 08 a0 ff and %g2, 0xff, %g2 <== NOT EXECUTED
4000f444: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
4000f448: 18 80 00 06 bgu 4000f460 <msdos_format+0xc18> <== NOT EXECUTED
4000f44c: c6 07 bd 38 ld [ %fp + -712 ], %g3 <== NOT EXECUTED
|| fmt_params->fattype == FAT_FAT16 ) {
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4000f450: 10 80 01 16 b 4000f8a8 <msdos_format+0x1060> <== NOT EXECUTED
4000f454: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
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-- ) {
4000f458: 02 80 00 07 be 4000f474 <msdos_format+0xc2c> <== NOT EXECUTED
4000f45c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
if ( (gigs & ( 1 << b) ) != 0 )
4000f460: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
4000f464: 85 29 00 01 sll %g4, %g1, %g2 <== NOT EXECUTED
4000f468: 80 88 80 03 btst %g2, %g3 <== NOT EXECUTED
4000f46c: 02 bf ff fb be 4000f458 <msdos_format+0xc10> <== NOT EXECUTED
4000f470: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
break;
}
fmt_params->sectors_per_cluster = 1 << b;
4000f474: c4 27 bd b8 st %g2, [ %fp + -584 ] <== NOT EXECUTED
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,
4000f478: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000f47c: 7f ff fc d2 call 4000e7c4 <msdos_set_sectors_per_cluster_from_request><== NOT EXECUTED
4000f480: 92 07 bd ac add %fp, -596, %o1 <== NOT EXECUTED
fmt_params );
}
}
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
4000f484: c2 0f bd de ldub [ %fp + -546 ], %g1 <== NOT EXECUTED
4000f488: 84 08 60 ff and %g1, 0xff, %g2 <== NOT EXECUTED
4000f48c: 80 a7 40 02 cmp %i5, %g2 <== NOT EXECUTED
4000f490: 02 80 00 08 be 4000f4b0 <msdos_format+0xc68> <== NOT EXECUTED
4000f494: ea 07 bd b0 ld [ %fp + -592 ], %l5 <== NOT EXECUTED
4000f498: 84 0c e0 ff and %l3, 0xff, %g2 <== NOT EXECUTED
4000f49c: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
4000f4a0: 08 80 00 05 bleu 4000f4b4 <msdos_format+0xc6c> <== NOT EXECUTED
4000f4a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
--fmt_params->totl_sector_cnt;
4000f4a8: aa 05 7f ff add %l5, -1, %l5 <== NOT EXECUTED
4000f4ac: ea 27 bd b0 st %l5, [ %fp + -592 ] <== NOT EXECUTED
if (ret_val == 0) {
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
4000f4b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000f4b4: 12 80 00 b6 bne 4000f78c <msdos_format+0xf44> <== NOT EXECUTED
4000f4b8: a6 04 e0 01 inc %l3 <== NOT EXECUTED
&& fmt_params->fattype != fat_type
4000f4bc: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED
4000f4c0: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4000f4c4: 02 80 00 3a be 4000f5ac <msdos_format+0xd64> <== NOT EXECUTED
4000f4c8: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
&& fmt_params->totl_sector_cnt > 0 ) {
4000f4cc: 12 bf ff 50 bne 4000f20c <msdos_format+0x9c4> <== NOT EXECUTED
4000f4d0: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
4000f4d4: 10 bf fe ea b 4000f07c <msdos_format+0x834> <== NOT EXECUTED
4000f4d8: f6 07 bd 40 ld [ %fp + -704 ], %i3 <== NOT EXECUTED
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;
uint32_t ms_sectors_per_cluster_limit_FAT16 =
( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;
uint8_t fattype = FAT_FAT32;
4000f4dc: 10 bf ff d3 b 4000f428 <msdos_format+0xbe0> <== NOT EXECUTED
4000f4e0: 84 10 20 04 mov 4, %g2 <== NOT EXECUTED
+ (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)) ||
4000f4e4: 80 a6 2f f5 cmp %i0, 0xff5 <== NOT EXECUTED
4000f4e8: 08 80 00 04 bleu 4000f4f8 <msdos_format+0xcb0> <== NOT EXECUTED
4000f4ec: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
4000f4f0: af 2d e0 01 sll %l7, 1, %l7 <== NOT EXECUTED
4000f4f4: a0 10 20 00 clr %l0 <== NOT EXECUTED
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if (fattype == FAT_FAT12) {
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
4000f4f8: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
4000f4fc: 7f ff cc 24 call 4000258c <.umul> <== NOT EXECUTED
4000f500: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000f504: 05 00 00 04 sethi %hi(0x1000), %g2 <== NOT EXECUTED
4000f508: 80 a2 00 02 cmp %o0, %g2 <== NOT EXECUTED
4000f50c: 38 bf ff af bgu,a 4000f3c8 <msdos_format+0xb80> <== NOT EXECUTED
4000f510: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
}
} else if ((sectors_per_cluster * bytes_per_sector)
> MS_BYTES_PER_CLUSTER_LIMIT) {
finished = true;
}
} while (!finished);
4000f514: 80 8c 20 ff btst 0xff, %l0 <== NOT EXECUTED
4000f518: 02 bf ff 79 be 4000f2fc <msdos_format+0xab4> <== NOT EXECUTED
4000f51c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
4000f520: 10 bf ff aa b 4000f3c8 <msdos_format+0xb80> <== NOT EXECUTED
4000f524: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
/ sectors_per_cluster));
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
4000f528: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED
4000f52c: 82 10 63 f5 or %g1, 0x3f5, %g1 ! fff5 <PROM_START+0xfff5> <== NOT EXECUTED
4000f530: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED
4000f534: 08 bf ff 9e bleu 4000f3ac <msdos_format+0xb64> <== NOT EXECUTED
4000f538: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
sectors_per_cluster *= 2;
4000f53c: af 2d e0 01 sll %l7, 1, %l7 <== NOT EXECUTED
4000f540: 10 bf ff 9a b 4000f3a8 <msdos_format+0xb60> <== NOT EXECUTED
4000f544: a0 10 20 00 clr %l0 <== 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);
4000f548: c6 07 bd 48 ld [ %fp + -696 ], %g3 <== NOT EXECUTED
4000f54c: 84 00 c0 17 add %g3, %l7, %g2 <== NOT EXECUTED
4000f550: 82 08 80 01 and %g2, %g1, %g1 <== NOT EXECUTED
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;
4000f554: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
4000f558: 7f ff cc 47 call 40002674 <.udiv> <== NOT EXECUTED
4000f55c: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
4000f560: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 3 / 2;
4000f564: 91 2a 20 01 sll %o0, 1, %o0 <== NOT EXECUTED
4000f568: 90 02 00 10 add %o0, %l0, %o0 <== NOT EXECUTED
4000f56c: 10 bf ff 7a b 4000f354 <msdos_format+0xb0c> <== NOT EXECUTED
4000f570: 91 32 20 01 srl %o0, 1, %o0 <== 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);
4000f574: 84 01 00 17 add %g4, %l7, %g2 <== NOT EXECUTED
4000f578: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED
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;
4000f57c: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
4000f580: 7f ff cc 3d call 40002674 <.udiv> <== NOT EXECUTED
4000f584: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
4000f588: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 2;
4000f58c: 10 bf ff 72 b 4000f354 <msdos_format+0xb0c> <== NOT EXECUTED
4000f590: 91 2a 20 01 sll %o0, 1, %o0 <== NOT EXECUTED
( 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
4000f594: 18 bf ff 99 bgu 4000f3f8 <msdos_format+0xbb0> <== NOT EXECUTED
4000f598: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
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) {
4000f59c: 82 08 a0 ff and %g2, 0xff, %g1 <== NOT EXECUTED
4000f5a0: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4000f5a4: 12 bf ff a5 bne 4000f438 <msdos_format+0xbf0> <== NOT EXECUTED
4000f5a8: c4 2f bd de stb %g2, [ %fp + -546 ] <== NOT EXECUTED
4000f5ac: f6 07 bd 40 ld [ %fp + -704 ], %i3 <== NOT EXECUTED
4000f5b0: ee 07 bd 3c ld [ %fp + -708 ], %l7 <== NOT EXECUTED
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
4000f5b4: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
4000f5b8: 02 bf fe b1 be 4000f07c <msdos_format+0x834> <== NOT EXECUTED
4000f5bc: c2 0f bd de ldub [ %fp + -546 ], %g1 <== NOT EXECUTED
ret_val = -1;
}
if (0 == ret_val)
{
if (FAT_FAT32 != fmt_params->fattype)
4000f5c0: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
4000f5c4: 02 80 00 8b be 4000f7f0 <msdos_format+0xfa8> <== NOT EXECUTED
4000f5c8: d0 07 bd c8 ld [ %fp + -568 ], %o0 <== NOT EXECUTED
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000f5cc: f8 0f bd fc ldub [ %fp + -516 ], %i4 <== NOT EXECUTED
4000f5d0: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000f5d4: 12 80 00 06 bne 4000f5ec <msdos_format+0xda4> <== NOT EXECUTED
4000f5d8: f4 07 bd b8 ld [ %fp + -584 ], %i2 <== NOT EXECUTED
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000f5dc: 90 02 00 1a add %o0, %i2, %o0 <== NOT EXECUTED
4000f5e0: 82 20 00 1a neg %i2, %g1 <== NOT EXECUTED
4000f5e4: 90 02 3f ff add %o0, -1, %o0 <== NOT EXECUTED
4000f5e8: 90 0a 00 01 and %o0, %g1, %o0 <== NOT EXECUTED
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);
4000f5ec: d2 07 bd ac ld [ %fp + -596 ], %o1 <== NOT EXECUTED
4000f5f0: 7f ff cb e7 call 4000258c <.umul> <== NOT EXECUTED
4000f5f4: 93 32 60 05 srl %o1, 5, %o1 <== NOT EXECUTED
if (0 == ret_val)
{
if (FAT_FAT32 != fmt_params->fattype)
{
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
4000f5f8: d0 27 bd c4 st %o0, [ %fp + -572 ] <== NOT EXECUTED
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
4000f5fc: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000f600: 12 80 00 06 bne 4000f618 <msdos_format+0xdd0> <== NOT EXECUTED
4000f604: fa 07 bd b4 ld [ %fp + -588 ], %i5 <== NOT EXECUTED
return (sectors + clustersize - 1) & ~(clustersize - 1);
4000f608: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
4000f60c: 82 20 00 1a neg %i2, %g1 <== NOT EXECUTED
4000f610: ba 07 40 1a add %i5, %i2, %i5 <== NOT EXECUTED
4000f614: ba 0f 40 01 and %i5, %g1, %i5 <== NOT EXECUTED
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
4000f618: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4000f61c: 02 80 00 26 be 4000f6b4 <msdos_format+0xe6c> <== NOT EXECUTED
4000f620: fa 27 bd b4 st %i5, [ %fp + -588 ] <== NOT EXECUTED
(rqdata->media != 0)) {
4000f624: f8 0e 60 14 ldub [ %i1 + 0x14 ], %i4 <== NOT EXECUTED
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
4000f628: b4 8f 20 ff andcc %i4, 0xff, %i2 <== NOT EXECUTED
4000f62c: 02 80 00 23 be 4000f6b8 <msdos_format+0xe70> <== NOT EXECUTED
4000f630: 82 10 3f f8 mov -8, %g1 <== NOT EXECUTED
(rqdata->media != 0)) {
const char valid_media_codes[] =
4000f634: 94 10 20 09 mov 9, %o2 <== NOT EXECUTED
4000f638: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
4000f63c: 13 10 00 b7 sethi %hi(0x4002dc00), %o1 <== NOT EXECUTED
4000f640: 40 00 3a 79 call 4001e024 <memcpy> <== NOT EXECUTED
4000f644: 92 12 61 e0 or %o1, 0x1e0, %o1 ! 4002dde0 <_CPU_Trap_slot_template+0x178><== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
4000f648: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
4000f64c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4000f650: 40 00 3a 07 call 4001de6c <memchr> <== NOT EXECUTED
4000f654: 94 10 20 09 mov 9, %o2 <== NOT EXECUTED
4000f658: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000f65c: 02 80 00 b2 be 4000f924 <msdos_format+0x10dc> <== NOT EXECUTED
4000f660: 01 00 00 00 nop <== NOT EXECUTED
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
}
else {
fmt_params->media_code = rqdata->media;
4000f664: f8 2f bd dd stb %i4, [ %fp + -547 ] <== NOT EXECUTED
4000f668: 10 bf fc c3 b 4000e974 <msdos_format+0x12c> <== NOT EXECUTED
4000f66c: f8 0f bd 57 ldub [ %fp + -681 ], %i4 <== NOT EXECUTED
if ((rqdata != NULL) &&
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
}
else {
if (fmt_params->fattype == FAT_FAT16) {
4000f670: 82 1f 60 02 xor %i5, 2, %g1 <== NOT EXECUTED
4000f674: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
4000f678: 90 40 3f ff addx %g0, -1, %o0 <== NOT EXECUTED
4000f67c: 90 0a 21 c0 and %o0, 0x1c0, %o0 <== NOT EXECUTED
4000f680: 10 bf fe f9 b 4000f264 <msdos_format+0xa1c> <== NOT EXECUTED
4000f684: 90 02 20 3f add %o0, 0x3f, %o0 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
4000f688: 82 10 20 20 mov 0x20, %g1 <== NOT EXECUTED
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
4000f68c: 84 10 20 06 mov 6, %g2 <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
4000f690: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
4000f694: c2 27 bd b4 st %g1, [ %fp + -588 ] <== NOT EXECUTED
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
4000f698: c0 27 bd c4 clr [ %fp + -572 ] <== NOT EXECUTED
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
4000f69c: c4 27 bd d4 st %g2, [ %fp + -556 ] <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
4000f6a0: c6 27 bd d8 st %g3, [ %fp + -552 ] <== NOT EXECUTED
4000f6a4: f6 07 bd ac ld [ %fp + -596 ], %i3 <== NOT EXECUTED
4000f6a8: a8 10 20 20 mov 0x20, %l4 <== NOT EXECUTED
4000f6ac: 10 bf fe f8 b 4000f28c <msdos_format+0xa44> <== NOT EXECUTED
4000f6b0: 90 10 20 00 clr %o0 <== NOT EXECUTED
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
4000f6b4: 82 10 3f f8 mov -8, %g1 <== NOT EXECUTED
4000f6b8: f8 0f bd 57 ldub [ %fp + -681 ], %i4 <== NOT EXECUTED
4000f6bc: 10 bf fc ae b 4000e974 <msdos_format+0x12c> <== NOT EXECUTED
4000f6c0: c2 2f bd dd stb %g1, [ %fp + -547 ] <== NOT EXECUTED
if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
fmt_params->fattype = FAT_FAT12;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
4000f6c4: 89 28 60 0e sll %g1, 0xe, %g4 <== NOT EXECUTED
4000f6c8: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
4000f6cc: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED
4000f6d0: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED
4000f6d4: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
4000f6d8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000f6dc: 2a 80 00 1f bcs,a 4000f758 <msdos_format+0xf10> <== NOT EXECUTED
4000f6e0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
4000f6e4: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED
/* 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;
4000f6e8: 98 10 20 00 clr %o4 <== NOT EXECUTED
4000f6ec: 1b 10 00 00 sethi %hi(0x40000000), %o5 <== NOT EXECUTED
4000f6f0: 86 87 40 0d addcc %i5, %o5, %g3 <== NOT EXECUTED
4000f6f4: 84 47 00 0c addx %i4, %o4, %g2 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
4000f6f8: c2 2f bd de stb %g1, [ %fp + -546 ] <== NOT EXECUTED
/* 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;
4000f6fc: 89 28 a0 02 sll %g2, 2, %g4 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
4000f700: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
/* 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;
4000f704: 85 30 e0 1e srl %g3, 0x1e, %g2 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
4000f708: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
/* 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;
4000f70c: 10 80 00 04 b 4000f71c <msdos_format+0xed4> <== NOT EXECUTED
4000f710: 88 11 00 02 or %g4, %g2, %g4 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
4000f714: 02 80 00 67 be 4000f8b0 <msdos_format+0x1068> <== NOT EXECUTED
4000f718: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
4000f71c: 85 28 c0 01 sll %g3, %g1, %g2 <== NOT EXECUTED
4000f720: 80 88 80 04 btst %g2, %g4 <== NOT EXECUTED
4000f724: 02 bf ff fc be 4000f714 <msdos_format+0xecc> <== NOT EXECUTED
4000f728: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
break;
fmt_params->sectors_per_cluster = 1 << b;
4000f72c: 10 bf fe 9d b 4000f1a0 <msdos_format+0x958> <== NOT EXECUTED
4000f730: c4 27 bd b8 st %g2, [ %fp + -584 ] <== NOT EXECUTED
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
4000f734: 82 10 20 20 mov 0x20, %g1 <== NOT EXECUTED
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
4000f738: 10 bf fe 92 b 4000f180 <msdos_format+0x938> <== NOT EXECUTED
4000f73c: 86 10 e3 a8 or %g3, 0x3a8, %g3 <== NOT EXECUTED
4000f740: a1 30 60 08 srl %g1, 8, %l0 <== NOT EXECUTED
{
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) {
4000f744: a2 10 20 00 clr %l1 <== NOT EXECUTED
4000f748: a4 10 20 00 clr %l2 <== NOT EXECUTED
4000f74c: a6 10 20 00 clr %l3 <== NOT EXECUTED
4000f750: 10 bf fd 0c b 4000eb80 <msdos_format+0x338> <== NOT EXECUTED
4000f754: a8 10 20 00 clr %l4 <== NOT EXECUTED
fmt_params->fattype = FAT_FAT12;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
fmt_params->fattype = FAT_FAT16;
4000f758: c2 2f bd de stb %g1, [ %fp + -546 ] <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4000f75c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
4000f760: 10 bf fe 90 b 4000f1a0 <msdos_format+0x958> <== NOT EXECUTED
4000f764: c2 27 bd b8 st %g1, [ %fp + -584 ] <== NOT EXECUTED
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
}
else {
errno = EINVAL;
4000f768: 40 00 37 8a call 4001d590 <__errno> <== NOT EXECUTED
4000f76c: 01 00 00 00 nop <== NOT EXECUTED
4000f770: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
ret_val = -1;
4000f774: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
}
else {
errno = EINVAL;
4000f778: 10 bf fc 75 b 4000e94c <msdos_format+0x104> <== NOT EXECUTED
4000f77c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
4000f780: 03 10 00 b7 sethi %hi(0x4002dc00), %g1 <== NOT EXECUTED
4000f784: 10 bf fd 3f b 4000ec80 <msdos_format+0x438> <== NOT EXECUTED
4000f788: 82 10 60 a8 or %g1, 0xa8, %g1 ! 4002dca8 <_CPU_Trap_slot_template+0x40><== NOT EXECUTED
4000f78c: f6 07 bd 40 ld [ %fp + -704 ], %i3 <== NOT EXECUTED
4000f790: 10 bf fc 73 b 4000e95c <msdos_format+0x114> <== NOT EXECUTED
4000f794: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
rc = rtems_clock_get_tod_timeval(&time_value);
if (rc == RTEMS_SUCCESSFUL) {
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
}
else {
*volid_ptr = rand();
4000f798: 40 00 3c df call 4001eb14 <rand> <== NOT EXECUTED
4000f79c: 01 00 00 00 nop <== NOT EXECUTED
4000f7a0: 10 bf fc c5 b 4000eab4 <msdos_format+0x26c> <== NOT EXECUTED
4000f7a4: d0 27 bd f8 st %o0, [ %fp + -520 ] <== NOT EXECUTED
if ((ret_val == 0) &&
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000f7a8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000f7ac: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000f7b0: 7f ff fb 6b call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000f7b4: 94 12 a1 88 or %o2, 0x188, %o2 ! 4002dd88 <_CPU_Trap_slot_template+0x120><== NOT EXECUTED
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
4000f7b8: d2 07 bd d4 ld [ %fp + -556 ], %o1 <== NOT EXECUTED
4000f7bc: d4 07 bd ac ld [ %fp + -596 ], %o2 <== NOT EXECUTED
4000f7c0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000f7c4: 7f ff fb 7b call 4000e5b0 <msdos_format_write_sec> <== NOT EXECUTED
4000f7c8: 96 07 be 00 add %fp, -512, %o3 <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
4000f7cc: ae 92 20 00 orcc %o0, 0, %l7 <== NOT EXECUTED
4000f7d0: 02 bf fd 4f be 4000ed0c <msdos_format+0x4c4> <== NOT EXECUTED
4000f7d4: fa 07 bd d8 ld [ %fp + -552 ], %i5 <== NOT EXECUTED
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
4000f7d8: 10 bf fc 4c b 4000e908 <msdos_format+0xc0> <== NOT EXECUTED
4000f7dc: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
4000f7e0: 10 bf fc 79 b 4000e9c4 <msdos_format+0x17c> <== NOT EXECUTED
4000f7e4: 88 11 20 c8 or %g4, 0xc8, %g4 <== NOT EXECUTED
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
4000f7e8: 10 bf fc 97 b 4000ea44 <msdos_format+0x1fc> <== NOT EXECUTED
4000f7ec: 88 11 21 50 or %g4, 0x150, %g4 <== NOT EXECUTED
4000f7f0: f4 07 bd b8 ld [ %fp + -584 ], %i2 <== NOT EXECUTED
4000f7f4: 10 bf ff 82 b 4000f5fc <msdos_format+0xdb4> <== NOT EXECUTED
4000f7f8: f8 0f bd fc ldub [ %fp + -516 ], %i4 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4000f7fc: c2 07 bd bc ld [ %fp + -580 ], %g1 <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4000f800: c4 07 bd d4 ld [ %fp + -556 ], %g2 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4000f804: b1 30 60 08 srl %g1, 8, %i0 <== NOT EXECUTED
4000f808: bb 30 60 10 srl %g1, 0x10, %i5 <== NOT EXECUTED
4000f80c: 89 30 60 18 srl %g1, 0x18, %g4 <== NOT EXECUTED
4000f810: c2 2f be 24 stb %g1, [ %fp + -476 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
4000f814: 82 10 20 29 mov 0x29, %g1 <== NOT EXECUTED
4000f818: c2 2f be 42 stb %g1, [ %fp + -446 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4000f81c: 03 00 00 11 sethi %hi(0x4400), %g1 <== NOT EXECUTED
4000f820: 82 10 62 41 or %g1, 0x241, %g1 ! 4641 <PROM_START+0x4641> <== NOT EXECUTED
4000f824: c2 37 be 52 sth %g1, [ %fp + -430 ] <== NOT EXECUTED
4000f828: 03 00 00 15 sethi %hi(0x5400), %g1 <== NOT EXECUTED
4000f82c: 82 10 60 33 or %g1, 0x33, %g1 ! 5433 <PROM_START+0x5433> <== NOT EXECUTED
4000f830: c2 37 be 54 sth %g1, [ %fp + -428 ] <== NOT EXECUTED
4000f834: 03 00 00 0c sethi %hi(0x3000), %g1 <== NOT EXECUTED
4000f838: 82 10 62 20 or %g1, 0x220, %g1 ! 3220 <PROM_START+0x3220> <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4000f83c: 87 30 a0 08 srl %g2, 8, %g3 <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4000f840: c2 37 be 56 sth %g1, [ %fp + -426 ] <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4000f844: f0 2f be 25 stb %i0, [ %fp + -475 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4000f848: 03 00 00 08 sethi %hi(0x2000), %g1 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4000f84c: fa 2f be 26 stb %i5, [ %fp + -474 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4000f850: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
4000f854: c8 2f be 27 stb %g4, [ %fp + -473 ] <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
4000f858: f4 2f be 2c stb %i2, [ %fp + -468 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
4000f85c: f8 2f be 30 stb %i4, [ %fp + -464 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
4000f860: c4 2f be 32 stb %g2, [ %fp + -462 ] <== NOT EXECUTED
4000f864: c6 2f be 33 stb %g3, [ %fp + -461 ] <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
4000f868: c0 27 be 34 clr [ %fp + -460 ] <== NOT EXECUTED
4000f86c: c0 27 be 38 clr [ %fp + -456 ] <== NOT EXECUTED
4000f870: c0 27 be 3c clr [ %fp + -452 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
4000f874: c0 2f be 47 clrb [ %fp + -441 ] <== NOT EXECUTED
4000f878: c0 2f be 48 clrb [ %fp + -440 ] <== NOT EXECUTED
4000f87c: c0 2f be 49 clrb [ %fp + -439 ] <== NOT EXECUTED
4000f880: c0 2f be 4a clrb [ %fp + -438 ] <== NOT EXECUTED
4000f884: c0 2f be 4b clrb [ %fp + -437 ] <== NOT EXECUTED
4000f888: c0 2f be 4c clrb [ %fp + -436 ] <== NOT EXECUTED
4000f88c: c0 2f be 4d clrb [ %fp + -435 ] <== NOT EXECUTED
4000f890: c0 2f be 4e clrb [ %fp + -434 ] <== NOT EXECUTED
4000f894: c0 2f be 4f clrb [ %fp + -433 ] <== NOT EXECUTED
4000f898: c0 2f be 50 clrb [ %fp + -432 ] <== NOT EXECUTED
4000f89c: c0 2f be 51 clrb [ %fp + -431 ] <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
4000f8a0: 10 bf fd 00 b 4000eca0 <msdos_format+0x458> <== NOT EXECUTED
4000f8a4: c2 37 be 58 sth %g1, [ %fp + -424 ] <== NOT EXECUTED
const uint64_t total_size )
{
if ( fmt_params->fattype == FAT_FAT12
|| fmt_params->fattype == FAT_FAT16 ) {
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
4000f8a8: 10 bf fe f4 b 4000f478 <msdos_format+0xc30> <== NOT EXECUTED
4000f8ac: c2 27 bd b8 st %g1, [ %fp + -584 ] <== NOT EXECUTED
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
4000f8b0: 10 bf fe 3c b 4000f1a0 <msdos_format+0x958> <== NOT EXECUTED
4000f8b4: c4 27 bd b8 st %g2, [ %fp + -584 ] <== NOT EXECUTED
4000f8b8: c6 0f bd 57 ldub [ %fp + -681 ], %g3 <== NOT EXECUTED
4000f8bc: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
4000f8c0: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
4000f8c4: 10 bf fd 66 b 4000ee5c <msdos_format+0x614> <== NOT EXECUTED
4000f8c8: 82 08 40 03 and %g1, %g3, %g1 <== NOT EXECUTED
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000f8cc: 90 10 20 00 clr %o0 <== NOT EXECUTED
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
4000f8d0: c2 2f bd dc stb %g1, [ %fp + -548 ] <== NOT EXECUTED
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000f8d4: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000f8d8: 96 10 20 02 mov 2, %o3 <== NOT EXECUTED
4000f8dc: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000f8e0: 7f ff fb 1f call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000f8e4: 94 12 a1 20 or %o2, 0x120, %o2 ! 4002dd20 <_CPU_Trap_slot_template+0xb8><== NOT EXECUTED
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
4000f8e8: 07 00 00 1f sethi %hi(0x7c00), %g3 <== NOT EXECUTED
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
4000f8ec: 82 10 20 20 mov 0x20, %g1 <== NOT EXECUTED
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
4000f8f0: 10 bf fe 24 b 4000f180 <msdos_format+0x938> <== NOT EXECUTED
4000f8f4: 86 10 e3 a8 or %g3, 0x3a8, %g3 <== NOT EXECUTED
4000f8f8: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
4000f8fc: ea 07 bd b0 ld [ %fp + -592 ], %l5 <== NOT EXECUTED
4000f900: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
if (ret_val == 0) {
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
4000f904: 84 10 00 17 mov %l7, %g2 <== NOT EXECUTED
4000f908: 10 bf fc 15 b 4000e95c <msdos_format+0x114> <== NOT EXECUTED
4000f90c: c2 2f bd 57 stb %g1, [ %fp + -681 ] <== NOT EXECUTED
4000f910: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
4000f914: ea 07 bd b0 ld [ %fp + -592 ], %l5 <== NOT EXECUTED
4000f918: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
4000f91c: 10 bf ff 26 b 4000f5b4 <msdos_format+0xd6c> <== NOT EXECUTED
4000f920: c2 2f bd 57 stb %g1, [ %fp + -681 ] <== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
4000f924: 40 00 37 1b call 4001d590 <__errno> <== NOT EXECUTED
4000f928: b8 10 20 00 clr %i4 <== NOT EXECUTED
4000f92c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000f930: fa 07 bd b4 ld [ %fp + -588 ], %i5 <== NOT EXECUTED
4000f934: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
const char valid_media_codes[] =
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
4000f938: 10 bf fc 0f b 4000e974 <msdos_format+0x12c> <== NOT EXECUTED
4000f93c: ae 10 3f ff mov -1, %l7 <== NOT EXECUTED
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
else
return sectors;
4000f940: 10 bf ff 05 b 4000f554 <msdos_format+0xd0c> <== NOT EXECUTED
4000f944: c2 07 bd 4c ld [ %fp + -692 ], %g1 <== NOT EXECUTED
4000e610 <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4000e610: 9d e3 bf a0 save %sp, -96, %sp
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
4000e614: 90 10 00 1c mov %i4, %o0
4000e618: 7f ff df 30 call 400062d8 <malloc>
4000e61c: a6 10 00 18 mov %i0, %l3
if (fill_buffer == NULL) {
4000e620: 80 a2 20 00 cmp %o0, 0
4000e624: 02 80 00 47 be 4000e740 <msdos_format_fill_sectors+0x130> <== NEVER TAKEN
4000e628: a4 10 00 08 mov %o0, %l2
errno = ENOMEM;
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
4000e62c: 92 10 00 1d mov %i5, %o1
4000e630: 40 00 3e ba call 4001e118 <memset>
4000e634: 94 10 00 1c mov %i4, %o2
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000e638: 90 10 00 18 mov %i0, %o0
4000e63c: 92 10 20 02 mov 2, %o1
4000e640: 15 10 00 b7 sethi %hi(0x4002dc00), %o2
4000e644: 7f ff ff c6 call 4000e55c <msdos_format_printf>
4000e648: 94 12 a0 78 or %o2, 0x78, %o2 ! 4002dc78 <_CPU_Trap_slot_template+0x10>
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4000e64c: 80 a6 e0 00 cmp %i3, 0
4000e650: 02 80 00 56 be 4000e7a8 <msdos_format_fill_sectors+0x198> <== NEVER TAKEN
4000e654: 83 2e e0 04 sll %i3, 4, %g1
4000e658: bb 2e e0 02 sll %i3, 2, %i5
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4000e65c: 29 10 00 b6 sethi %hi(0x4002d800), %l4
4000e660: ba 07 40 01 add %i5, %g1, %i5
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4000e664: a0 10 00 1b mov %i3, %l0
4000e668: 83 2f 60 02 sll %i5, 2, %g1
\*=========================================================================*/
{
int ret_val = 0;
char *fill_buffer = NULL;
uint32_t total_sectors = sector_cnt;
int last_percent = -1;
4000e66c: a2 10 3f ff mov -1, %l1
4000e670: ba 07 40 01 add %i5, %g1, %i5
while ((ret_val == 0) &&
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4000e674: 10 80 00 10 b 4000e6b4 <msdos_format_fill_sectors+0xa4>
4000e678: a8 15 20 80 or %l4, 0x80, %l4
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4000e67c: 92 10 00 1a mov %i2, %o1
4000e680: 90 10 00 19 mov %i1, %o0
4000e684: 94 10 00 1c mov %i4, %o2
4000e688: 96 10 00 12 mov %l2, %o3
4000e68c: 7f ff ff c9 call 4000e5b0 <msdos_format_write_sec>
4000e690: a0 04 3f ff add %l0, -1, %l0
start_sector++;
4000e694: b4 06 a0 01 inc %i2
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4000e698: b0 10 00 08 mov %o0, %i0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4000e69c: 80 a2 20 00 cmp %o0, 0
4000e6a0: 12 80 00 1c bne 4000e710 <msdos_format_fill_sectors+0x100><== NEVER TAKEN
4000e6a4: ba 07 7f 9c add %i5, -100, %i5
4000e6a8: 80 a4 20 00 cmp %l0, 0
4000e6ac: 02 80 00 1a be 4000e714 <msdos_format_fill_sectors+0x104>
4000e6b0: 90 10 00 13 mov %l3, %o0
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
4000e6b4: 92 10 00 1b mov %i3, %o1
4000e6b8: 7f ff cf ef call 40002674 <.udiv>
4000e6bc: 90 10 00 1d mov %i5, %o0
if (percent != last_percent) {
4000e6c0: 80 a2 00 11 cmp %o0, %l1
4000e6c4: 02 bf ff ee be 4000e67c <msdos_format_fill_sectors+0x6c>
4000e6c8: 80 8a 20 01 btst 1, %o0
if ((percent & 1) == 0)
4000e6cc: 12 bf ff ec bne 4000e67c <msdos_format_fill_sectors+0x6c>
4000e6d0: a2 10 00 08 mov %o0, %l1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4000e6d4: 90 10 00 13 mov %l3, %o0
4000e6d8: 92 10 20 02 mov 2, %o1
4000e6dc: 7f ff ff a0 call 4000e55c <msdos_format_printf>
4000e6e0: 94 10 00 14 mov %l4, %o2
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4000e6e4: 92 10 00 1a mov %i2, %o1
4000e6e8: 90 10 00 19 mov %i1, %o0
4000e6ec: 94 10 00 1c mov %i4, %o2
4000e6f0: 96 10 00 12 mov %l2, %o3
4000e6f4: 7f ff ff af call 4000e5b0 <msdos_format_write_sec>
4000e6f8: a0 04 3f ff add %l0, -1, %l0
start_sector++;
4000e6fc: b4 06 a0 01 inc %i2
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4000e700: b0 10 00 08 mov %o0, %i0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
4000e704: 80 a2 20 00 cmp %o0, 0
4000e708: 02 bf ff e8 be 4000e6a8 <msdos_format_fill_sectors+0x98> <== ALWAYS TAKEN
4000e70c: ba 07 7f 9c add %i5, -100, %i5
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
4000e710: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
4000e714: 92 10 20 02 mov 2, %o1
4000e718: 15 10 00 b7 sethi %hi(0x4002dc00), %o2
4000e71c: 7f ff ff 90 call 4000e55c <msdos_format_printf>
4000e720: 94 12 a1 80 or %o2, 0x180, %o2 ! 4002dd80 <_CPU_Trap_slot_template+0x118>
if (ret_val)
4000e724: 80 a6 20 00 cmp %i0, 0
4000e728: 12 80 00 16 bne 4000e780 <msdos_format_fill_sectors+0x170><== NEVER TAKEN
4000e72c: 90 10 00 13 mov %l3, %o0
/*
* cleanup
*/
if (fill_buffer != NULL) {
free(fill_buffer);
4000e730: 7f ff dd 97 call 40005d8c <free>
4000e734: 90 10 00 12 mov %l2, %o0
4000e738: 81 c7 e0 08 ret
4000e73c: 81 e8 00 00 restore
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
if (fill_buffer == NULL) {
errno = ENOMEM;
4000e740: 40 00 3b 94 call 4001d590 <__errno> <== NOT EXECUTED
4000e744: 01 00 00 00 nop <== NOT EXECUTED
4000e748: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000e74c: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
if (fill_buffer == NULL) {
errno = ENOMEM;
4000e750: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
4000e754: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000e758: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000e75c: 7f ff ff 80 call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000e760: 94 12 a0 78 or %o2, 0x78, %o2 <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
4000e764: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000e768: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000e76c: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
if (fill_buffer == NULL) {
errno = ENOMEM;
ret_val = -1;
4000e770: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
4000e774: 7f ff ff 7a call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000e778: 94 12 a1 80 or %o2, 0x180, %o2 <== NOT EXECUTED
if (ret_val)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
4000e77c: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
4000e780: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4000e784: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
4000e788: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000e78c: 7f ff ff 74 call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000e790: 94 12 a0 88 or %o2, 0x88, %o2 ! 4002dc88 <_CPU_Trap_slot_template+0x20><== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
4000e794: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
4000e798: 12 bf ff e6 bne 4000e730 <msdos_format_fill_sectors+0x120><== NOT EXECUTED
4000e79c: 01 00 00 00 nop <== NOT EXECUTED
free(fill_buffer);
fill_buffer = NULL;
}
return ret_val;
}
4000e7a0: 81 c7 e0 08 ret <== NOT EXECUTED
4000e7a4: 81 e8 00 00 restore <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
4000e7a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000e7ac: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
4000e7b0: b0 10 20 00 clr %i0 <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
4000e7b4: 15 10 00 b7 sethi %hi(0x4002dc00), %o2 <== NOT EXECUTED
4000e7b8: 7f ff ff 69 call 4000e55c <msdos_format_printf> <== NOT EXECUTED
4000e7bc: 94 12 a1 80 or %o2, 0x180, %o2 ! 4002dd80 <_CPU_Trap_slot_template+0x118><== NOT EXECUTED
4000e7c0: 30 bf ff dc b,a 4000e730 <msdos_format_fill_sectors+0x120><== NOT EXECUTED
4000e55c <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
4000e55c: 9d e3 bf 98 save %sp, -104, %sp
va_list args;
va_start (args, format);
4000e560: 94 07 a0 50 add %fp, 0x50, %o2
4000e564: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
4000e568: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
4000e56c: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
if (rqdata != NULL && rqdata->info_level >= info_level)
4000e570: 80 a6 20 00 cmp %i0, 0
4000e574: 02 80 00 0d be 4000e5a8 <msdos_format_printf+0x4c>
4000e578: d4 27 bf fc st %o2, [ %fp + -4 ]
4000e57c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000e580: 80 a0 40 19 cmp %g1, %i1
4000e584: 06 80 00 09 bl 4000e5a8 <msdos_format_printf+0x4c> <== ALWAYS TAKEN
4000e588: 3b 10 00 bb sethi %hi(0x4002ec00), %i5
{
vfprintf (stdout, format, args);
4000e58c: c2 07 61 50 ld [ %i5 + 0x150 ], %g1 ! 4002ed50 <_impure_ptr><== NOT EXECUTED
4000e590: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4000e594: 40 00 5d 0c call 400259c4 <vfprintf> <== NOT EXECUTED
4000e598: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
fflush (stdout);
4000e59c: c2 07 61 50 ld [ %i5 + 0x150 ], %g1 <== NOT EXECUTED
4000e5a0: 40 00 3c ff call 4001d99c <fflush> <== NOT EXECUTED
4000e5a4: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
4000e5a8: 81 c7 e0 08 ret
4000e5ac: 81 e8 00 00 restore
4000e5b0 <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
4000e5b0: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
4000e5b4: 94 10 20 00 clr %o2
4000e5b8: 96 10 00 1a mov %i2, %o3
4000e5bc: 90 10 20 00 clr %o0
4000e5c0: 7f ff ce d6 call 40002118 <__muldi3>
4000e5c4: 92 10 00 19 mov %i1, %o1
4000e5c8: 84 10 00 08 mov %o0, %g2
4000e5cc: 86 10 00 09 mov %o1, %g3
4000e5d0: 90 10 00 18 mov %i0, %o0
4000e5d4: 92 10 00 02 mov %g2, %o1
4000e5d8: 94 10 00 03 mov %g3, %o2
4000e5dc: 40 00 1f 49 call 40016300 <lseek>
4000e5e0: 96 10 20 00 clr %o3
4000e5e4: 80 a2 20 00 cmp %o0, 0
4000e5e8: 16 80 00 04 bge 4000e5f8 <msdos_format_write_sec+0x48> <== ALWAYS TAKEN
4000e5ec: 90 10 00 18 mov %i0, %o0
4000e5f0: 81 c7 e0 08 ret <== NOT EXECUTED
4000e5f4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
4000e5f8: 92 10 00 1b mov %i3, %o1
4000e5fc: 7f ff ee 0f call 40009e38 <write>
4000e600: 94 10 00 1a mov %i2, %o2
4000e604: b1 3a 20 1f sra %o0, 0x1f, %i0
ret_val = -1;
}
}
return ret_val;
}
4000e608: 81 c7 e0 08 ret
4000e60c: 81 e8 00 00 restore
4001aba4 <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
)
{
4001aba4: 9d e3 bf 50 save %sp, -176, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
4001aba8: f8 06 20 08 ld [ %i0 + 8 ], %i4
fat_file_fd_t *fat_fd = NULL;
4001abac: 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);
4001abb0: 90 10 00 1c mov %i4, %o0
4001abb4: 92 10 00 1a mov %i2, %o1
4001abb8: 7f ff e2 bc call 400136a8 <fat_file_open>
4001abbc: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
4001abc0: ba 92 20 00 orcc %o0, 0, %i5
4001abc4: 02 80 00 04 be 4001abd4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x30><== ALWAYS TAKEN
4001abc8: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
4001abcc: 81 c7 e0 08 ret
4001abd0: 91 e8 00 1d restore %g0, %i5, %o0
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4001abd4: 05 00 08 00 sethi %hi(0x200000), %g2
*/
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
4001abd8: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
4001abdc: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4001abe0: c4 22 60 14 st %g2, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
4001abe4: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
4001abe8: f2 22 60 38 st %i1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
4001abec: 7f ff e5 e5 call 40014380 <fat_file_size>
4001abf0: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
4001abf4: ba 92 20 00 orcc %o0, 0, %i5
4001abf8: 12 80 00 95 bne 4001ae4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a8><== NEVER TAKEN
4001abfc: 33 10 00 b6 sethi %hi(0x4002d800), %i1
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
4001ac00: ba 07 bf c0 add %fp, -64, %i5
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
4001ac04: 94 10 00 1d mov %i5, %o2
4001ac08: 92 10 20 01 mov 1, %o1
4001ac0c: 96 10 20 0b mov 0xb, %o3
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
4001ac10: c0 27 bf c0 clr [ %fp + -64 ]
4001ac14: c0 27 bf c4 clr [ %fp + -60 ]
4001ac18: c0 27 bf c8 clr [ %fp + -56 ]
4001ac1c: c0 27 bf cc clr [ %fp + -52 ]
4001ac20: c0 27 bf d0 clr [ %fp + -48 ]
4001ac24: c0 27 bf d4 clr [ %fp + -44 ]
4001ac28: c0 27 bf d8 clr [ %fp + -40 ]
4001ac2c: c0 27 bf dc clr [ %fp + -36 ]
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
4001ac30: 7f ff fa eb call 400197dc <msdos_long_to_short>
4001ac34: 90 16 60 80 or %i1, 0x80, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
4001ac38: d2 07 bf bc ld [ %fp + -68 ], %o1
4001ac3c: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
4001ac40: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
4001ac44: 90 10 00 18 mov %i0, %o0
4001ac48: 94 10 20 00 clr %o2
4001ac4c: 96 16 60 80 or %i1, 0x80, %o3
4001ac50: 98 10 20 01 mov 1, %o4
4001ac54: 7f ff fc da call 40019fbc <msdos_find_name_in_fat_file>
4001ac58: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
4001ac5c: ba 92 20 00 orcc %o0, 0, %i5
4001ac60: 12 80 00 7b bne 4001ae4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a8><== NEVER TAKEN
4001ac64: 33 10 00 b8 sethi %hi(0x4002e000), %i1
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
4001ac68: ba 07 bf e0 add %fp, -32, %i5
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
4001ac6c: 94 10 00 1d mov %i5, %o2
4001ac70: 92 10 20 02 mov 2, %o1
4001ac74: 96 10 20 0b mov 0xb, %o3
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
4001ac78: c0 27 bf e0 clr [ %fp + -32 ]
4001ac7c: c0 27 bf e4 clr [ %fp + -28 ]
4001ac80: c0 27 bf e8 clr [ %fp + -24 ]
4001ac84: c0 27 bf ec clr [ %fp + -20 ]
4001ac88: c0 27 bf f0 clr [ %fp + -16 ]
4001ac8c: c0 27 bf f4 clr [ %fp + -12 ]
4001ac90: c0 27 bf f8 clr [ %fp + -8 ]
4001ac94: c0 27 bf fc clr [ %fp + -4 ]
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
4001ac98: 7f ff fa d1 call 400197dc <msdos_long_to_short>
4001ac9c: 90 16 60 a8 or %i1, 0xa8, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
4001aca0: d2 07 bf bc ld [ %fp + -68 ], %o1
4001aca4: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
4001aca8: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
4001acac: 90 10 00 18 mov %i0, %o0
4001acb0: 94 10 20 00 clr %o2
4001acb4: 96 16 60 a8 or %i1, 0xa8, %o3
4001acb8: 98 10 20 02 mov 2, %o4
4001acbc: 7f ff fc c0 call 40019fbc <msdos_find_name_in_fat_file>
4001acc0: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
4001acc4: d2 07 bf bc ld [ %fp + -68 ], %o1
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
4001acc8: 80 a2 20 00 cmp %o0, 0
4001accc: 12 80 00 66 bne 4001ae64 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c0><== NEVER TAKEN
4001acd0: ba 10 00 08 mov %o0, %i5
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
4001acd4: f2 17 bf da lduh [ %fp + -38 ], %i1
4001acd8: e0 17 bf d4 lduh [ %fp + -44 ], %l0
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(&fs_info->fat, fat_fd);
4001acdc: 7f ff e3 ed call 40013c90 <fat_file_close>
4001ace0: 90 10 00 1c mov %i4, %o0
if ( rc != RC_OK )
4001ace4: ba 92 20 00 orcc %o0, 0, %i5
4001ace8: 12 bf ff b9 bne 4001abcc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28><== NEVER TAKEN
4001acec: c4 17 bf fa lduh [ %fp + -6 ], %g2
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
4001acf0: c6 17 bf f4 lduh [ %fp + -12 ], %g3
4001acf4: 85 28 a0 10 sll %g2, 0x10, %g2
4001acf8: 87 28 e0 10 sll %g3, 0x10, %g3
4001acfc: 89 30 a0 18 srl %g2, 0x18, %g4
4001ad00: bb 30 e0 18 srl %g3, 0x18, %i5
4001ad04: 03 00 00 3f sethi %hi(0xfc00), %g1
4001ad08: 87 30 e0 08 srl %g3, 8, %g3
4001ad0c: 82 10 63 ff or %g1, 0x3ff, %g1
4001ad10: 85 30 a0 08 srl %g2, 8, %g2
4001ad14: 86 08 c0 01 and %g3, %g1, %g3
4001ad18: 82 08 80 01 and %g2, %g1, %g1
4001ad1c: 86 17 40 03 or %i5, %g3, %g3
4001ad20: 82 11 00 01 or %g4, %g1, %g1
4001ad24: 87 28 e0 10 sll %g3, 0x10, %g3
4001ad28: 80 90 c0 01 orcc %g3, %g1, %g0
4001ad2c: 12 80 00 08 bne 4001ad4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1a8><== ALWAYS TAKEN
4001ad30: 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;
4001ad34: 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;
4001ad38: c0 26 a0 04 clr [ %i2 + 4 ] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4001ad3c: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4001ad40: 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;
4001ad44: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4001ad48: 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);
4001ad4c: 92 10 00 1a mov %i2, %o1
4001ad50: 7f ff e2 56 call 400136a8 <fat_file_open>
4001ad54: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
4001ad58: ba 92 20 00 orcc %o0, 0, %i5
4001ad5c: 12 bf ff 9c bne 4001abcc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28><== NEVER TAKEN
4001ad60: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
4001ad64: c8 17 bf fa lduh [ %fp + -6 ], %g4
4001ad68: 83 28 60 10 sll %g1, 0x10, %g1
4001ad6c: 07 00 00 3f sethi %hi(0xfc00), %g3
4001ad70: 85 30 60 18 srl %g1, 0x18, %g2
4001ad74: 86 10 e3 ff or %g3, 0x3ff, %g3
4001ad78: 83 30 60 08 srl %g1, 8, %g1
4001ad7c: 82 08 40 03 and %g1, %g3, %g1
4001ad80: 89 29 20 10 sll %g4, 0x10, %g4
4001ad84: 84 10 80 01 or %g2, %g1, %g2
4001ad88: bb 31 20 18 srl %g4, 0x18, %i5
4001ad8c: 85 28 a0 10 sll %g2, 0x10, %g2
4001ad90: 89 31 20 08 srl %g4, 8, %g4
4001ad94: 86 09 00 03 and %g4, %g3, %g3
4001ad98: 82 17 40 03 or %i5, %g3, %g1
4001ad9c: 82 90 80 01 orcc %g2, %g1, %g1
4001ada0: 12 80 00 35 bne 4001ae74 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d0><== ALWAYS TAKEN
4001ada4: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4001ada8: c2 07 20 3c ld [ %i4 + 0x3c ], %g1 <== NOT EXECUTED
4001adac: c2 22 60 1c st %g1, [ %o1 + 0x1c ] <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
4001adb0: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4001adb4: 05 00 08 00 sethi %hi(0x200000), %g2
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
4001adb8: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
4001adbc: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4001adc0: c4 22 60 14 st %g2, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
4001adc4: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
4001adc8: 7f ff e5 6e call 40014380 <fat_file_size>
4001adcc: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
4001add0: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(&fs_info->fat, fat_fd);
if (rc != RC_OK)
4001add4: 80 a2 20 00 cmp %o0, 0
4001add8: 12 80 00 23 bne 4001ae64 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c0><== NEVER TAKEN
4001addc: ba 10 00 08 mov %o0, %i5
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
4001ade0: a1 2c 20 10 sll %l0, 0x10, %l0
4001ade4: b3 2e 60 10 sll %i1, 0x10, %i1
4001ade8: 95 34 20 18 srl %l0, 0x18, %o2
4001adec: 85 36 60 18 srl %i1, 0x18, %g2
4001adf0: a1 34 20 08 srl %l0, 8, %l0
4001adf4: b3 36 60 08 srl %i1, 8, %i1
4001adf8: 03 00 00 3f sethi %hi(0xfc00), %g1
4001adfc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
4001ae00: a0 0c 00 01 and %l0, %g1, %l0
4001ae04: 82 0e 40 01 and %i1, %g1, %g1
4001ae08: 82 10 80 01 or %g2, %g1, %g1
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
4001ae0c: 90 10 00 18 mov %i0, %o0
4001ae10: 96 10 00 1a mov %i2, %o3
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
4001ae14: 94 12 80 10 or %o2, %l0, %o2
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
4001ae18: 98 10 00 1b mov %i3, %o4
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
4001ae1c: 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,
4001ae20: 7f ff fe fe call 4001aa18 <msdos_find_node_by_cluster_num_in_fat_file>
4001ae24: 94 12 80 01 or %o2, %g1, %o2
dir_pos, dir_entry);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
4001ae28: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
4001ae2c: ba 10 00 08 mov %o0, %i5
dir_pos, dir_entry);
if (rc != RC_OK)
4001ae30: 80 a7 60 00 cmp %i5, 0
4001ae34: 12 80 00 12 bne 4001ae7c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d8><== NEVER TAKEN
4001ae38: 90 10 00 1c mov %i4, %o0
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
4001ae3c: 7f ff e3 95 call 40013c90 <fat_file_close>
4001ae40: 01 00 00 00 nop
4001ae44: 10 bf ff 62 b 4001abcc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28>
4001ae48: ba 10 00 08 mov %o0, %i5
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
4001ae4c: d2 07 bf bc ld [ %fp + -68 ], %o1 <== NOT EXECUTED
4001ae50: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001ae54: 7f ff e3 8f call 40013c90 <fat_file_close> <== NOT EXECUTED
4001ae58: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
4001ae5c: 81 c7 e0 08 ret <== NOT EXECUTED
4001ae60: 81 e8 00 00 restore <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(&fs_info->fat, fat_fd);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
4001ae64: 7f ff e3 8b call 40013c90 <fat_file_close> <== NOT EXECUTED
4001ae68: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
4001ae6c: 81 c7 e0 08 ret <== NOT EXECUTED
4001ae70: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
4001ae74: 10 bf ff cf b 4001adb0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x20c>
4001ae78: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
dir_pos, dir_entry);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
4001ae7c: 7f ff e3 85 call 40013c90 <fat_file_close> <== NOT EXECUTED
4001ae80: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
4001ae84: 30 bf ff f6 b,a 4001ae5c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b8><== NOT EXECUTED
4001ae88 <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
4001ae88: 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,
4001ae8c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
4001ae90: 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
)
{
4001ae94: 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,
4001ae98: 9a 10 00 1c mov %i4, %o5
4001ae9c: e0 23 a0 60 st %l0, [ %sp + 0x60 ]
4001aea0: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
4001aea4: 94 10 00 19 mov %i1, %o2
4001aea8: 96 10 00 1a mov %i2, %o3
4001aeac: 7f ff fc 44 call 40019fbc <msdos_find_name_in_fat_file>
4001aeb0: 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))
4001aeb4: 03 00 00 1f sethi %hi(0x7c00), %g1
4001aeb8: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
4001aebc: 80 a2 00 01 cmp %o0, %g1
4001aec0: 12 80 00 2a bne 4001af68 <msdos_get_name_node+0xe0>
4001aec4: b8 10 00 08 mov %o0, %i4
return rc;
if (!create_node)
4001aec8: 80 a6 60 00 cmp %i1, 0
4001aecc: 12 80 00 25 bne 4001af60 <msdos_get_name_node+0xd8>
4001aed0: 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)
4001aed4: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
4001aed8: 80 a7 00 01 cmp %i4, %g1
4001aedc: 02 80 00 21 be 4001af60 <msdos_get_name_node+0xd8>
4001aee0: 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)
4001aee4: 12 80 00 1f bne 4001af60 <msdos_get_name_node+0xd8> <== NEVER TAKEN
4001aee8: 90 10 00 1a mov %i2, %o0
{
if (strncmp(name, "..", 2) == 0)
4001aeec: 94 10 20 02 mov 2, %o2
4001aef0: 13 10 00 b8 sethi %hi(0x4002e000), %o1
4001aef4: 40 00 10 9c call 4001f164 <strncmp>
4001aef8: 92 12 60 a8 or %o1, 0xa8, %o1 ! 4002e0a8 <IMFS_memfile_handlers+0x44>
4001aefc: 80 a2 20 00 cmp %o0, 0
4001af00: 12 80 00 18 bne 4001af60 <msdos_get_name_node+0xd8>
4001af04: 05 00 00 3f sethi %hi(0xfc00), %g2
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
4001af08: c2 14 20 14 lduh [ %l0 + 0x14 ], %g1
4001af0c: c6 14 20 1a lduh [ %l0 + 0x1a ], %g3
4001af10: 83 28 60 10 sll %g1, 0x10, %g1
4001af14: b3 30 60 18 srl %g1, 0x18, %i1
4001af18: 84 10 a3 ff or %g2, 0x3ff, %g2
4001af1c: 83 30 60 08 srl %g1, 8, %g1
4001af20: 82 08 40 02 and %g1, %g2, %g1
4001af24: 87 28 e0 10 sll %g3, 0x10, %g3
4001af28: b2 16 40 01 or %i1, %g1, %i1
4001af2c: 89 30 e0 18 srl %g3, 0x18, %g4
4001af30: b3 2e 60 10 sll %i1, 0x10, %i1
4001af34: 87 30 e0 08 srl %g3, 8, %g3
4001af38: 84 08 c0 02 and %g3, %g2, %g2
4001af3c: 82 11 00 02 or %g4, %g2, %g1
/* are we right under root dir ? */
if (dotdot_cln == 0)
4001af40: b2 96 40 01 orcc %i1, %g1, %i1
4001af44: 12 80 00 0e bne 4001af7c <msdos_get_name_node+0xf4>
4001af48: 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;
4001af4c: c0 27 60 04 clr [ %i5 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
4001af50: c2 27 60 08 st %g1, [ %i5 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4001af54: 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;
4001af58: 82 10 20 01 mov 1, %g1
4001af5c: c2 27 40 00 st %g1, [ %i5 ]
}
}
}
}
return rc;
}
4001af60: 81 c7 e0 08 ret
4001af64: 91 e8 00 1c restore %g0, %i4, %o0
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
create_node, name, name_len, name_type,
dir_pos, name_dir_entry);
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
4001af68: 80 a2 20 00 cmp %o0, 0
4001af6c: 02 bf ff d8 be 4001aecc <msdos_get_name_node+0x44>
4001af70: 80 a6 60 00 cmp %i1, 0
}
}
}
}
return rc;
}
4001af74: 81 c7 e0 08 ret
4001af78: 91 e8 00 1c restore %g0, %i4, %o0
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
}
else
{
rc =
4001af7c: f0 06 20 14 ld [ %i0 + 0x14 ], %i0
4001af80: b4 10 00 1d mov %i5, %i2
4001af84: 7f ff ff 08 call 4001aba4 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
4001af88: 97 e8 00 10 restore %g0, %l0, %o3
4000f9e4 <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
)
{
4000f9e4: 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));
4000f9e8: 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;
4000f9ec: 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));
4000f9f0: 7f ff d8 b0 call 40005cb0 <calloc>
4000f9f4: 92 10 20 a4 mov 0xa4, %o1
if (!fs_info)
4000f9f8: ba 92 20 00 orcc %o0, 0, %i5
4000f9fc: 02 80 00 58 be 4000fb5c <msdos_initialize_support+0x178> <== NEVER TAKEN
4000fa00: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
4000fa04: d2 06 20 38 ld [ %i0 + 0x38 ], %o1
4000fa08: 40 00 14 42 call 40014b10 <fat_init_volume_info>
4000fa0c: fa 26 20 08 st %i5, [ %i0 + 8 ]
if (rc != RC_OK)
4000fa10: b8 92 20 00 orcc %o0, 0, %i4
4000fa14: 12 80 00 34 bne 4000fae4 <msdos_initialize_support+0x100> <== NEVER TAKEN
4000fa18: 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;
4000fa1c: c2 27 bf f8 st %g1, [ %fp + -8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
4000fa20: 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;
4000fa24: 82 10 20 01 mov 1, %g1
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
4000fa28: f4 27 60 98 st %i2, [ %i5 + 0x98 ]
fs_info->directory_handlers = directory_handlers;
4000fa2c: 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;
4000fa30: c0 27 bf f4 clr [ %fp + -12 ]
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
4000fa34: 90 10 00 1d mov %i5, %o0
/*
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
4000fa38: c2 27 bf f0 st %g1, [ %fp + -16 ]
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
4000fa3c: 92 07 bf f0 add %fp, -16, %o1
4000fa40: 40 00 0f 1a call 400136a8 <fat_file_open>
4000fa44: 94 07 bf ec add %fp, -20, %o2
if (rc != RC_OK)
4000fa48: b8 92 20 00 orcc %o0, 0, %i4
4000fa4c: 12 80 00 24 bne 4000fadc <msdos_initialize_support+0xf8> <== NEVER TAKEN
4000fa50: d2 07 bf ec ld [ %fp + -20 ], %o1
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4000fa54: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4000fa58: 05 00 08 00 sethi %hi(0x200000), %g2
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
4000fa5c: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
4000fa60: c4 22 60 14 st %g2, [ %o1 + 0x14 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
4000fa64: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
fat_fd->map.file_cln = 0;
4000fa68: 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 )
4000fa6c: 80 a0 60 00 cmp %g1, 0
4000fa70: 12 80 00 24 bne 4000fb00 <msdos_initialize_support+0x11c>
4000fa74: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
4000fa78: 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 :
4000fa7c: 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) ?
4000fa80: 80 a2 00 01 cmp %o0, %g1
4000fa84: 0a 80 00 1d bcs 4000faf8 <msdos_initialize_support+0x114>
4000fa88: c2 22 60 18 st %g1, [ %o1 + 0x18 ]
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
4000fa8c: 7f ff d8 89 call 40005cb0 <calloc>
4000fa90: 92 10 20 01 mov 1, %o1
if (fs_info->cl_buf == NULL)
4000fa94: 80 a2 20 00 cmp %o0, 0
4000fa98: 02 80 00 2a be 4000fb40 <msdos_initialize_support+0x15c> <== NEVER TAKEN
4000fa9c: d0 27 60 a0 st %o0, [ %i5 + 0xa0 ]
fat_shutdown_drive(&fs_info->fat);
free(fs_info);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
sc = rtems_semaphore_create(3,
4000faa0: 90 10 20 03 mov 3, %o0
4000faa4: 92 10 20 01 mov 1, %o1
4000faa8: 94 10 20 10 mov 0x10, %o2
4000faac: 96 10 20 00 clr %o3
4000fab0: 7f ff ea 2a call 4000a358 <rtems_semaphore_create>
4000fab4: 98 07 60 9c add %i5, 0x9c, %o4
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
4000fab8: 80 a2 20 00 cmp %o0, 0
4000fabc: 12 80 00 2d bne 4000fb70 <msdos_initialize_support+0x18c> <== NEVER TAKEN
4000fac0: c4 07 bf ec ld [ %fp + -20 ], %g2
free(fs_info->cl_buf);
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
4000fac4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
4000fac8: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
free(fs_info->cl_buf);
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
4000facc: c4 20 60 08 st %g2, [ %g1 + 8 ]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
4000fad0: f2 26 20 0c st %i1, [ %i0 + 0xc ]
return rc;
}
4000fad4: 81 c7 e0 08 ret
4000fad8: 91 e8 00 1c restore %g0, %i4, %o0
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
if (rc != RC_OK)
{
fat_shutdown_drive(&fs_info->fat);
4000fadc: 40 00 16 5c call 4001544c <fat_shutdown_drive> <== NOT EXECUTED
4000fae0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
4000fae4: 7f ff d8 aa call 40005d8c <free> <== NOT EXECUTED
4000fae8: 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;
}
4000faec: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
4000faf0: 81 c7 e0 08 ret <== NOT EXECUTED
4000faf4: 81 e8 00 00 restore <== NOT EXECUTED
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
4000faf8: 10 bf ff e5 b 4000fa8c <msdos_initialize_support+0xa8>
4000fafc: 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);
4000fb00: 40 00 12 20 call 40014380 <fat_file_size>
4000fb04: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
4000fb08: 82 92 20 00 orcc %o0, 0, %g1
4000fb0c: 12 80 00 04 bne 4000fb1c <msdos_initialize_support+0x138> <== NEVER TAKEN
4000fb10: d2 07 bf ec ld [ %fp + -20 ], %o1
fat_file_close(&fs_info->fat, fat_fd);
fat_shutdown_drive(&fs_info->fat);
free(fs_info);
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
4000fb14: 10 bf ff de b 4000fa8c <msdos_initialize_support+0xa8>
4000fb18: d0 17 60 06 lduh [ %i5 + 6 ], %o0
rc = fat_file_size(&fs_info->fat, fat_fd);
if ( rc != RC_OK )
{
fat_file_close(&fs_info->fat, fat_fd);
fat_shutdown_drive(&fs_info->fat);
free(fs_info);
4000fb1c: b8 10 00 01 mov %g1, %i4 <== NOT EXECUTED
else
{
rc = fat_file_size(&fs_info->fat, fat_fd);
if ( rc != RC_OK )
{
fat_file_close(&fs_info->fat, fat_fd);
4000fb20: 40 00 10 5c call 40013c90 <fat_file_close> <== NOT EXECUTED
4000fb24: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
4000fb28: 40 00 16 49 call 4001544c <fat_shutdown_drive> <== NOT EXECUTED
4000fb2c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
4000fb30: 7f ff d8 97 call 40005d8c <free> <== NOT EXECUTED
4000fb34: 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;
}
4000fb38: 81 c7 e0 08 ret <== NOT EXECUTED
4000fb3c: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
if (fs_info->cl_buf == NULL)
{
fat_file_close(&fs_info->fat, fat_fd);
4000fb40: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
4000fb44: 40 00 10 53 call 40013c90 <fat_file_close> <== NOT EXECUTED
4000fb48: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
4000fb4c: 40 00 16 40 call 4001544c <fat_shutdown_drive> <== NOT EXECUTED
4000fb50: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
4000fb54: 7f ff d8 8e call 40005d8c <free> <== NOT EXECUTED
4000fb58: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
4000fb5c: 40 00 36 8d call 4001d590 <__errno> <== NOT EXECUTED
4000fb60: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
4000fb64: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
4000fb68: 10 bf ff e1 b 4000faec <msdos_initialize_support+0x108> <== NOT EXECUTED
4000fb6c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
{
fat_file_close(&fs_info->fat, fat_fd);
4000fb70: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
4000fb74: 40 00 10 47 call 40013c90 <fat_file_close> <== NOT EXECUTED
4000fb78: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
4000fb7c: 40 00 16 34 call 4001544c <fat_shutdown_drive> <== NOT EXECUTED
4000fb80: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info->cl_buf);
4000fb84: d0 07 60 a0 ld [ %i5 + 0xa0 ], %o0 <== NOT EXECUTED
4000fb88: 7f ff d8 81 call 40005d8c <free> <== NOT EXECUTED
4000fb8c: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
free(fs_info);
4000fb90: 7f ff d8 7f call 40005d8c <free> <== NOT EXECUTED
4000fb94: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
4000fb98: 40 00 36 7e call 4001d590 <__errno> <== NOT EXECUTED
4000fb9c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
4000fba0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4000fba4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000fba8: 81 c7 e0 08 ret <== NOT EXECUTED
4000fbac: 81 e8 00 00 restore <== NOT EXECUTED
4000f9ac <msdos_lock>:
.rename_h = msdos_rename,
.statvfs_h = rtems_filesystem_default_statvfs
};
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
4000f9ac: 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,
4000f9b0: 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(
4000f9b4: 92 10 20 00 clr %o1
4000f9b8: d0 00 60 9c ld [ %g1 + 0x9c ], %o0
4000f9bc: 7f ff eb 0f call 4000a5f8 <rtems_semaphore_obtain>
4000f9c0: 94 10 20 00 clr %o2
fs_info->vol_sema,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if (sc != RTEMS_SUCCESSFUL) {
4000f9c4: 80 a2 20 00 cmp %o0, 0
4000f9c8: 12 80 00 04 bne 4000f9d8 <msdos_lock+0x2c> <== NEVER TAKEN
4000f9cc: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
4000f9d0: 81 c7 e0 08 ret
4000f9d4: 81 e8 00 00 restore
rtems_fatal_error_occurred(0xdeadbeef);
4000f9d8: 7f ff ec e9 call 4000ad7c <rtems_fatal_error_occurred> <== NOT EXECUTED
4000f9dc: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
400197dc <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)
{
400197dc: 9d e3 bf a0 save %sp, -96, %sp
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
400197e0: 92 10 20 20 mov 0x20, %o1
400197e4: 90 10 00 1a mov %i2, %o0
400197e8: 40 00 12 4c call 4001e118 <memset>
400197ec: 94 10 00 1b mov %i3, %o2
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
400197f0: f8 0e 00 00 ldub [ %i0 ], %i4
400197f4: 85 2f 20 18 sll %i4, 0x18, %g2
400197f8: 83 38 a0 18 sra %g2, 0x18, %g1
400197fc: 80 a0 60 2e cmp %g1, 0x2e
40019800: 02 80 00 17 be 4001985c <msdos_long_to_short+0x80>
40019804: a0 10 00 18 mov %i0, %l0
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
40019808: 80 a6 60 00 cmp %i1, 0
4001980c: 04 80 00 70 ble 400199cc <msdos_long_to_short+0x1f0> <== NEVER TAKEN
40019810: 83 38 a0 18 sra %g2, 0x18, %g1
if ((lfn[i] != ' ') && (lfn[i] != '.'))
40019814: 80 a0 60 2e cmp %g1, 0x2e
40019818: 12 80 00 1f bne 40019894 <msdos_long_to_short+0xb8> <== ALWAYS TAKEN
4001981c: 80 a0 60 20 cmp %g1, 0x20
40019820: 10 80 00 05 b 40019834 <msdos_long_to_short+0x58> <== NOT EXECUTED
40019824: 82 10 20 00 clr %g1 <== NOT EXECUTED
40019828: 80 a0 e0 2e cmp %g3, 0x2e
4001982c: 12 80 00 08 bne 4001984c <msdos_long_to_short+0x70> <== ALWAYS TAKEN
40019830: 80 a0 e0 20 cmp %g3, 0x20
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
40019834: 82 00 60 01 inc %g1
40019838: 80 a0 40 19 cmp %g1, %i1
4001983c: 32 bf ff fb bne,a 40019828 <msdos_long_to_short+0x4c> <== ALWAYS TAKEN
40019840: c6 4c 00 01 ldsb [ %l0 + %g1 ], %g3
if (type == MSDOS_NAME_INVALID)
{
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
40019844: 81 c7 e0 08 ret <== NOT EXECUTED
40019848: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
4001984c: 02 bf ff fb be 40019838 <msdos_long_to_short+0x5c> <== NEVER TAKEN
40019850: 82 00 60 01 inc %g1
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
40019854: 10 80 00 13 b 400198a0 <msdos_long_to_short+0xc4>
40019858: 80 a0 a0 00 cmp %g2, 0
memset (sfn, ' ', sfn_len);
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
4001985c: 80 a6 60 01 cmp %i1, 1
40019860: 22 80 00 0b be,a 4001988c <msdos_long_to_short+0xb0>
40019864: 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))
40019868: c2 4e 20 01 ldsb [ %i0 + 1 ], %g1
4001986c: 80 a0 60 2e cmp %g1, 0x2e
40019870: 12 bf ff e7 bne 4001980c <msdos_long_to_short+0x30> <== NEVER TAKEN
40019874: 80 a6 60 00 cmp %i1, 0
40019878: 80 a6 60 02 cmp %i1, 2
4001987c: 12 bf ff e4 bne 4001980c <msdos_long_to_short+0x30> <== NEVER TAKEN
40019880: 80 a6 60 00 cmp %i1, 0
{
sfn[0] = sfn[1] = '.';
40019884: c2 2e a0 01 stb %g1, [ %i2 + 1 ]
40019888: 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;
4001988c: 81 c7 e0 08 ret
40019890: 91 e8 20 01 restore %g0, 1, %o0
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
40019894: 02 bf ff e8 be 40019834 <msdos_long_to_short+0x58>
40019898: 82 10 20 00 clr %g1
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
4001989c: 80 a0 a0 00 cmp %g2, 0
400198a0: 02 80 00 44 be 400199b0 <msdos_long_to_short+0x1d4> <== NEVER TAKEN
400198a4: 03 10 00 bb sethi %hi(0x4002ec00), %g1
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
400198a8: e8 00 61 48 ld [ %g1 + 0x148 ], %l4 ! 4002ed48 <__ctype_ptr__>
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
400198ac: 31 10 00 b8 sethi %hi(0x4002e000), %i0
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
400198b0: 2b 10 00 b8 sethi %hi(0x4002e000), %l5
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
400198b4: a4 10 20 00 clr %l2
400198b8: a6 10 20 00 clr %l3
400198bc: ba 10 20 00 clr %i5
400198c0: a2 10 3f ff mov -1, %l1
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
400198c4: b0 16 22 d8 or %i0, 0x2d8, %i0
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
400198c8: aa 15 62 e0 or %l5, 0x2e0, %l5
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
400198cc: b7 38 a0 18 sra %g2, 0x18, %i3
400198d0: 90 10 00 18 mov %i0, %o0
400198d4: 40 00 15 55 call 4001ee28 <strchr>
400198d8: 92 10 00 1b mov %i3, %o1
400198dc: 80 a2 20 00 cmp %o0, 0
400198e0: 02 80 00 09 be 40019904 <msdos_long_to_short+0x128>
400198e4: 82 1e e0 2e xor %i3, 0x2e, %g1
return MSDOS_NAME_LONG;
400198e8: b0 10 20 02 mov 2, %i0
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
400198ec: 90 10 00 10 mov %l0, %o0
400198f0: 92 10 00 19 mov %i1, %o1
400198f4: 40 00 0b c1 call 4001c7f8 <msdos_filename_unix2dos>
400198f8: 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;
400198fc: 81 c7 e0 08 ret
40019900: 81 e8 00 00 restore
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
40019904: 80 a0 00 01 cmp %g0, %g1
40019908: ac 60 3f ff subx %g0, -1, %l6
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
4001990c: 80 a5 a0 00 cmp %l6, 0
40019910: 12 80 00 3c bne 40019a00 <msdos_long_to_short+0x224>
40019914: 82 0f 20 ff and %i4, 0xff, %g1
40019918: 82 05 00 01 add %l4, %g1, %g1
4001991c: c2 08 60 01 ldub [ %g1 + 1 ], %g1
40019920: 80 88 60 07 btst 7, %g1
40019924: 12 80 00 07 bne 40019940 <msdos_long_to_short+0x164>
40019928: 90 10 00 15 mov %l5, %o0
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
4001992c: 40 00 15 3f call 4001ee28 <strchr>
40019930: 92 10 00 1b mov %i3, %o1
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
40019934: 80 a2 20 00 cmp %o0, 0
40019938: 02 bf ff c3 be 40019844 <msdos_long_to_short+0x68> <== NEVER TAKEN
4001993c: 01 00 00 00 nop
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
40019940: 80 a4 7f ff cmp %l1, -1
40019944: 02 80 00 27 be 400199e0 <msdos_long_to_short+0x204>
40019948: 82 27 40 11 sub %i5, %l1, %g1
{
if (is_dot || ((count - dot_at) > 3))
4001994c: 80 a0 60 03 cmp %g1, 3
40019950: 34 bf ff e7 bg,a 400198ec <msdos_long_to_short+0x110> <== NEVER TAKEN
40019954: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
}
}
if (is_dot)
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
40019958: 82 07 3f bf add %i4, -65, %g1
4001995c: 82 08 60 ff and %g1, 0xff, %g1
40019960: 80 a0 60 19 cmp %g1, 0x19
40019964: 28 80 00 07 bleu,a 40019980 <msdos_long_to_short+0x1a4>
40019968: a4 10 20 01 mov 1, %l2
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
4001996c: b8 07 3f 9f add %i4, -97, %i4
40019970: b8 0f 20 ff and %i4, 0xff, %i4
40019974: 80 a7 20 19 cmp %i4, 0x19
40019978: 28 80 00 02 bleu,a 40019980 <msdos_long_to_short+0x1a4>
4001997c: a6 10 20 01 mov 1, %l3
lowercase = true;
count++;
40019980: ba 07 60 01 inc %i5
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
40019984: f8 0c 00 1d ldub [ %l0 + %i5 ], %i4
40019988: 85 2f 20 18 sll %i4, 0x18, %g2
4001998c: 80 a0 a0 00 cmp %g2, 0
40019990: 02 80 00 04 be 400199a0 <msdos_long_to_short+0x1c4>
40019994: 80 a6 40 1d cmp %i1, %i5
40019998: 34 bf ff ce bg,a 400198d0 <msdos_long_to_short+0xf4>
4001999c: b7 38 a0 18 sra %g2, 0x18, %i3
400199a0: a4 0c c0 12 and %l3, %l2, %l2
count++;
name++;
}
if (lowercase && uppercase)
400199a4: 80 8c a0 ff btst 0xff, %l2
400199a8: 12 bf ff d1 bne 400198ec <msdos_long_to_short+0x110> <== NEVER TAKEN
400199ac: b0 10 20 02 mov 2, %i0
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
400199b0: b0 10 20 01 mov 1, %i0
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
400199b4: 90 10 00 10 mov %l0, %o0
400199b8: 92 10 00 19 mov %i1, %o1
400199bc: 40 00 0b 8f call 4001c7f8 <msdos_filename_unix2dos>
400199c0: 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;
400199c4: 81 c7 e0 08 ret
400199c8: 81 e8 00 00 restore
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
400199cc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
400199d0: 12 bf ff f8 bne 400199b0 <msdos_long_to_short+0x1d4> <== NOT EXECUTED
400199d4: b0 10 20 00 clr %i0 <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
400199d8: 81 c7 e0 08 ret <== NOT EXECUTED
400199dc: 81 e8 00 00 restore <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
400199e0: 80 a5 a0 00 cmp %l6, 0
400199e4: 12 bf ff de bne 4001995c <msdos_long_to_short+0x180> <== NEVER TAKEN
400199e8: 82 07 3f bf add %i4, -65, %g1
400199ec: 80 a7 60 08 cmp %i5, 8
400199f0: 12 bf ff dc bne 40019960 <msdos_long_to_short+0x184>
400199f4: 82 08 60 ff and %g1, 0xff, %g1
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
400199f8: 10 bf ff bd b 400198ec <msdos_long_to_short+0x110>
400199fc: b0 10 20 02 mov 2, %i0
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
40019a00: 80 a4 7f ff cmp %l1, -1
40019a04: 32 bf ff ba bne,a 400198ec <msdos_long_to_short+0x110>
40019a08: b0 10 20 02 mov 2, %i0
40019a0c: 10 bf ff dd b 40019980 <msdos_long_to_short+0x1a4>
40019a10: a2 10 00 1d mov %i5, %l1
4000fbb0 <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
4000fbb0: 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))
4000fbb4: 03 00 00 3c sethi %hi(0xf000), %g1
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
4000fbb8: b8 10 00 1b mov %i3, %i4
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
4000fbbc: 82 0e c0 01 and %i3, %g1, %g1
4000fbc0: 05 00 00 10 sethi %hi(0x4000), %g2
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
4000fbc4: 86 10 00 19 mov %i1, %g3
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
4000fbc8: 80 a0 40 02 cmp %g1, %g2
4000fbcc: 02 80 00 09 be 4000fbf0 <msdos_mknod+0x40>
4000fbd0: b6 10 00 1a mov %i2, %i3
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
4000fbd4: 05 00 00 20 sethi %hi(0x8000), %g2
4000fbd8: 80 a0 40 02 cmp %g1, %g2
4000fbdc: 12 80 00 09 bne 4000fc00 <msdos_mknod+0x50> <== NEVER TAKEN
4000fbe0: b2 10 20 04 mov 4, %i1
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
4000fbe4: b4 10 00 03 mov %g3, %i2
4000fbe8: 40 00 25 9c call 40019258 <msdos_creat_node>
4000fbec: 9b e8 20 00 restore %g0, 0, %o5
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
4000fbf0: 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);
4000fbf4: b4 10 00 03 mov %g3, %i2
4000fbf8: 40 00 25 98 call 40019258 <msdos_creat_node>
4000fbfc: 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);
4000fc00: 40 00 36 64 call 4001d590 <__errno> <== NOT EXECUTED
4000fc04: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000fc08: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000fc0c: 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;
}
4000fc10: 81 c7 e0 08 ret <== NOT EXECUTED
4000fc14: 81 e8 00 00 restore <== NOT EXECUTED
4000fc24 <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
)
{
4000fc24: 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;
4000fc28: 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,
4000fc2c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4000fc30: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000fc34: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4000fc38: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4000fc3c: 19 00 00 20 sethi %hi(0x8000), %o4 <== NOT EXECUTED
4000fc40: 40 00 25 86 call 40019258 <msdos_creat_node> <== NOT EXECUTED
4000fc44: 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)
4000fc48: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000fc4c: 02 80 00 04 be 4000fc5c <msdos_rename+0x38> <== NOT EXECUTED
4000fc50: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
4000fc54: 81 c7 e0 08 ret <== NOT EXECUTED
4000fc58: 81 e8 00 00 restore <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
4000fc5c: f0 06 60 14 ld [ %i1 + 0x14 ], %i0 <== NOT EXECUTED
4000fc60: b4 10 20 e5 mov 0xe5, %i2 <== NOT EXECUTED
4000fc64: 40 00 28 15 call 40019cb8 <msdos_set_first_char4file_name><== NOT EXECUTED
4000fc68: 93 ef 60 20 restore %i5, 0x20, %o1 <== NOT EXECUTED
4000fc6c <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
4000fc6c: 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;
4000fc70: 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;
4000fc74: 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)
4000fc78: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000fc7c: 80 a0 60 00 cmp %g1, 0
4000fc80: 12 80 00 16 bne 4000fcd8 <msdos_rmnod+0x6c>
4000fc84: f8 02 20 08 ld [ %o0 + 8 ], %i4
{
bool is_empty = false;
4000fc88: 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);
4000fc8c: 92 10 00 1d mov %i5, %o1
4000fc90: 40 00 28 76 call 40019e68 <msdos_dir_is_empty>
4000fc94: 94 07 bf ff add %fp, -1, %o2
if (rc != RC_OK)
4000fc98: b0 92 20 00 orcc %o0, 0, %i0
4000fc9c: 12 80 00 0d bne 4000fcd0 <msdos_rmnod+0x64> <== NEVER TAKEN
4000fca0: c2 0f bf ff ldub [ %fp + -1 ], %g1
{
return rc;
}
if (!is_empty)
4000fca4: 80 a0 60 00 cmp %g1, 0
4000fca8: 02 80 00 16 be 4000fd00 <msdos_rmnod+0x94>
4000fcac: 01 00 00 00 nop
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
4000fcb0: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000fcb4: 80 a0 60 01 cmp %g1, 1
4000fcb8: 28 80 00 08 bleu,a 4000fcd8 <msdos_rmnod+0x6c> <== ALWAYS TAKEN
4000fcbc: d0 06 60 14 ld [ %i1 + 0x14 ], %o0
{
rtems_set_errno_and_return_minus_one(EBUSY);
4000fcc0: 40 00 36 34 call 4001d590 <__errno> <== NOT EXECUTED
4000fcc4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000fcc8: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
4000fccc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000fcd0: 81 c7 e0 08 ret <== NOT EXECUTED
4000fcd4: 81 e8 00 00 restore <== NOT EXECUTED
* not used - mount() not implemenetd yet.
*/
}
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
4000fcd8: 92 07 60 20 add %i5, 0x20, %o1
4000fcdc: 40 00 27 f7 call 40019cb8 <msdos_set_first_char4file_name>
4000fce0: 94 10 20 e5 mov 0xe5, %o2
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
4000fce4: b0 92 20 00 orcc %o0, 0, %i0
4000fce8: 12 bf ff fa bne 4000fcd0 <msdos_rmnod+0x64> <== NEVER TAKEN
4000fcec: 90 10 00 1c mov %i4, %o0
{
return rc;
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
4000fcf0: 40 00 11 79 call 400142d4 <fat_file_mark_removed>
4000fcf4: 92 10 00 1d mov %i5, %o1
return rc;
}
4000fcf8: 81 c7 e0 08 ret
4000fcfc: 81 e8 00 00 restore
return rc;
}
if (!is_empty)
{
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
4000fd00: 40 00 36 24 call 4001d590 <__errno>
4000fd04: b0 10 3f ff mov -1, %i0
4000fd08: 82 10 20 5a mov 0x5a, %g1
4000fd0c: c2 22 00 00 st %g1, [ %o0 ]
4000fd10: 81 c7 e0 08 ret
4000fd14: 81 e8 00 00 restore
40019a14 <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
)
{
40019a14: 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);
40019a18: 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;
40019a1c: 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);
40019a20: 92 07 bf fe add %fp, -2, %o1
40019a24: 40 00 0a c9 call 4001c548 <msdos_date_unix2dos>
40019a28: 94 07 bf fc add %fp, -4, %o2
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
40019a2c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40019a30: 80 a0 60 00 cmp %g1, 0
40019a34: 32 80 00 07 bne,a 40019a50 <msdos_set_dir_wrt_time_and_date+0x3c>
40019a38: c6 0f 60 05 ldub [ %i5 + 5 ], %g3
40019a3c: c4 0f 60 0e ldub [ %i5 + 0xe ], %g2
40019a40: 80 88 a0 03 btst 3, %g2
40019a44: 32 80 00 07 bne,a 40019a60 <msdos_set_dir_wrt_time_and_date+0x4c><== ALWAYS TAKEN
40019a48: f6 07 60 20 ld [ %i5 + 0x20 ], %i3
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40019a4c: c6 0f 60 05 ldub [ %i5 + 5 ], %g3 <== NOT EXECUTED
40019a50: c4 07 60 34 ld [ %i5 + 0x34 ], %g2
40019a54: b6 00 7f fe add %g1, -2, %i3
40019a58: b7 2e c0 03 sll %i3, %g3, %i3
40019a5c: b6 06 c0 02 add %i3, %g2, %i3
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40019a60: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
40019a64: f8 17 40 00 lduh [ %i5 ], %i4
time_val = CT_LE_W(time_val);
40019a68: 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);
40019a6c: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
40019a70: 83 28 60 10 sll %g1, 0x10, %g1
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40019a74: 87 30 80 03 srl %g2, %g3, %g3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
40019a78: b8 07 3f ff add %i4, -1, %i4
40019a7c: b8 0f 00 02 and %i4, %g2, %i4
time_val = CT_LE_W(time_val);
40019a80: 85 30 60 08 srl %g1, 8, %g2
40019a84: 83 30 60 18 srl %g1, 0x18, %g1
40019a88: 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);
40019a8c: b6 06 c0 03 add %i3, %g3, %i3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
40019a90: 94 07 20 16 add %i4, 0x16, %o2
40019a94: 92 10 00 1b mov %i3, %o1
40019a98: 96 10 20 02 mov 2, %o3
40019a9c: 98 07 bf fc add %fp, -4, %o4
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
40019aa0: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
40019aa4: 7f ff eb 2d call 40014758 <fat_sector_write>
40019aa8: 90 10 00 1d mov %i5, %o0
2, (char *)(&time_val));
date = CT_LE_W(date);
40019aac: c2 17 bf fe lduh [ %fp + -2 ], %g1
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
40019ab0: 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);
40019ab4: 83 28 60 10 sll %g1, 0x10, %g1
40019ab8: 85 30 60 08 srl %g1, 8, %g2
40019abc: 83 30 60 18 srl %g1, 0x18, %g1
40019ac0: 82 10 80 01 or %g2, %g1, %g1
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
40019ac4: 96 10 20 02 mov 2, %o3
40019ac8: 98 07 bf fe add %fp, -2, %o4
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
40019acc: c2 37 bf fe sth %g1, [ %fp + -2 ]
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
40019ad0: 92 10 00 1b mov %i3, %o1
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
40019ad4: b2 10 00 08 mov %o0, %i1
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
40019ad8: 7f ff eb 20 call 40014758 <fat_sector_write>
40019adc: 90 10 00 1d mov %i5, %o0
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
40019ae0: 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,
40019ae4: b4 10 00 08 mov %o0, %i2
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
40019ae8: 94 07 20 12 add %i4, 0x12, %o2
40019aec: 90 10 00 1d mov %i5, %o0
40019af0: 96 10 20 02 mov 2, %o3
40019af4: 7f ff eb 19 call 40014758 <fat_sector_write>
40019af8: 98 07 bf fe add %fp, -2, %o4
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
40019afc: 80 a6 a0 00 cmp %i2, 0
40019b00: 06 80 00 08 bl 40019b20 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
40019b04: 80 a6 60 00 cmp %i1, 0
40019b08: 06 80 00 06 bl 40019b20 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
40019b0c: 80 a2 20 00 cmp %o0, 0
40019b10: 06 80 00 04 bl 40019b20 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
40019b14: 01 00 00 00 nop
return -1;
return RC_OK;
}
40019b18: 81 c7 e0 08 ret
40019b1c: 91 e8 20 00 restore %g0, 0, %o0
2, (char *)(&date));
ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
return -1;
40019b20: 81 c7 e0 08 ret <== NOT EXECUTED
40019b24: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
40019c14 <msdos_set_file_size>:
int
msdos_set_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
40019c14: 9d e3 bf 98 save %sp, -104, %sp
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
40019c18: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40019c1c: 80 a0 60 00 cmp %g1, 0
40019c20: 12 80 00 06 bne 40019c38 <msdos_set_file_size+0x24>
40019c24: d0 06 20 08 ld [ %i0 + 8 ], %o0
40019c28: c4 0a 20 0e ldub [ %o0 + 0xe ], %g2
40019c2c: 80 88 a0 03 btst 3, %g2
40019c30: 32 80 00 07 bne,a 40019c4c <msdos_set_file_size+0x38> <== ALWAYS TAKEN
40019c34: d2 02 20 20 ld [ %o0 + 0x20 ], %o1
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40019c38: c6 0a 20 05 ldub [ %o0 + 5 ], %g3
40019c3c: c4 02 20 34 ld [ %o0 + 0x34 ], %g2
40019c40: 92 00 7f fe add %g1, -2, %o1
40019c44: 93 2a 40 03 sll %o1, %g3, %o1
40019c48: 92 02 40 02 add %o1, %g2, %o1
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40019c4c: c6 12 00 00 lduh [ %o0 ], %g3
le_new_length = CT_LE_L((fat_fd->fat_file_size));
40019c50: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40019c54: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
40019c58: c8 0a 20 02 ldub [ %o0 + 2 ], %g4
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40019c5c: 86 00 ff ff add %g3, -1, %g3
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40019c60: 89 30 80 04 srl %g2, %g4, %g4
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
40019c64: 94 08 c0 02 and %g3, %g2, %o2
40019c68: b9 28 60 18 sll %g1, 0x18, %i4
uint32_t value
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
40019c6c: 87 30 60 18 srl %g1, 0x18, %g3
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
40019c70: bb 30 60 08 srl %g1, 8, %i5
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40019c74: 86 17 00 03 or %i4, %g3, %g3
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
byte2 = (value >> 8) & 0xff;
40019c78: ba 0f 60 ff and %i5, 0xff, %i5
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
40019c7c: 83 30 60 10 srl %g1, 0x10, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40019c80: bb 2f 60 10 sll %i5, 0x10, %i5
)
{
uint32_t byte1, byte2, byte3, byte4, swapped;
byte4 = (value >> 24) & 0xff;
byte3 = (value >> 16) & 0xff;
40019c84: 82 08 60 ff and %g1, 0xff, %g1
byte2 = (value >> 8) & 0xff;
byte1 = value & 0xff;
swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
40019c88: 86 10 c0 1d or %g3, %i5, %g3
40019c8c: 83 28 60 08 sll %g1, 8, %g1
40019c90: 86 10 c0 01 or %g3, %g1, %g3
le_new_length = CT_LE_L((fat_fd->fat_file_size));
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
40019c94: 92 02 40 04 add %o1, %g4, %o1
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
le_new_length = CT_LE_L((fat_fd->fat_file_size));
40019c98: c6 27 bf fc st %g3, [ %fp + -4 ]
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
40019c9c: 94 02 a0 1c add %o2, 0x1c, %o2
40019ca0: 96 10 20 04 mov 4, %o3
40019ca4: 7f ff ea ad call 40014758 <fat_sector_write>
40019ca8: 98 07 bf fc add %fp, -4, %o4
(char *)(&le_new_length));
if ( ret < 0 )
return -1;
return RC_OK;
}
40019cac: b1 3a 20 1f sra %o0, 0x1f, %i0
40019cb0: 81 c7 e0 08 ret
40019cb4: 81 e8 00 00 restore
40019cb8 <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
)
{
40019cb8: 9d e3 bf 90 save %sp, -112, %sp
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40019cbc: fa 06 20 08 ld [ %i0 + 8 ], %i5
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
40019cc0: 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;
40019cc4: c8 06 60 08 ld [ %i1 + 8 ], %g4
40019cc8: c6 06 60 0c ld [ %i1 + 0xc ], %g3
fat_pos_t end = dir_pos->sname;
40019ccc: c2 06 60 04 ld [ %i1 + 4 ], %g1
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40019cd0: c4 07 60 3c ld [ %i5 + 0x3c ], %g2
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
40019cd4: 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;
40019cd8: c8 27 bf f0 st %g4, [ %fp + -16 ]
40019cdc: c6 27 bf f4 st %g3, [ %fp + -12 ]
fat_pos_t end = dir_pos->sname;
40019ce0: f8 27 bf f8 st %i4, [ %fp + -8 ]
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40019ce4: 80 a7 00 02 cmp %i4, %g2
40019ce8: 02 80 00 56 be 40019e40 <msdos_set_first_char4file_name+0x188><== ALWAYS TAKEN
40019cec: c2 27 bf fc st %g1, [ %fp + -4 ]
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
40019cf0: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
40019cf4: 80 a0 bf ff cmp %g2, -1 <== NOT EXECUTED
40019cf8: 02 80 00 59 be 40019e5c <msdos_set_first_char4file_name+0x1a4><== NOT EXECUTED
40019cfc: f6 17 60 06 lduh [ %i5 + 6 ], %i3 <== NOT EXECUTED
40019d00: c2 07 bf f4 ld [ %fp + -12 ], %g1
40019d04: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
40019d08: d4 17 40 00 lduh [ %i5 ], %o2
40019d0c: 10 80 00 1d b 40019d80 <msdos_set_first_char4file_name+0xc8>
40019d10: d2 07 bf f0 ld [ %fp + -16 ], %o1
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40019d14: 80 88 e0 03 btst 3, %g3
40019d18: 22 80 00 1e be,a 40019d90 <msdos_set_first_char4file_name+0xd8><== NEVER TAKEN
40019d1c: c8 0f 60 05 ldub [ %i5 + 5 ], %g4 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
40019d20: d2 07 60 20 ld [ %i5 + 0x20 ], %o1
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
40019d24: 85 30 40 02 srl %g1, %g2, %g2
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40019d28: 95 2a a0 10 sll %o2, 0x10, %o2
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40019d2c: 90 10 00 1d mov %i5, %o0
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40019d30: 95 32 a0 10 srl %o2, 0x10, %o2
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40019d34: 92 02 40 02 add %o1, %g2, %o1
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40019d38: 94 02 bf ff add %o2, -1, %o2
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40019d3c: 96 10 20 01 mov 1, %o3
40019d40: 94 08 40 0a and %g1, %o2, %o2
40019d44: 7f ff ea 85 call 40014758 <fat_sector_write>
40019d48: 98 07 a0 4c add %fp, 0x4c, %o4
1, &fchar);
if (ret < 0)
40019d4c: 80 a2 20 00 cmp %o0, 0
40019d50: 06 80 00 22 bl 40019dd8 <msdos_set_first_char4file_name+0x120><== NEVER TAKEN
40019d54: 90 10 3f ff mov -1, %o0
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
40019d58: d2 07 bf f0 ld [ %fp + -16 ], %o1
40019d5c: 80 a7 00 09 cmp %i4, %o1
40019d60: 02 80 00 20 be 40019de0 <msdos_set_first_char4file_name+0x128><== ALWAYS TAKEN
40019d64: c2 07 bf f4 ld [ %fp + -12 ], %g1
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
40019d68: 82 00 60 20 add %g1, 0x20, %g1 <== NOT EXECUTED
if (start.ofs >= dir_block_size)
40019d6c: 80 a6 c0 01 cmp %i3, %g1
40019d70: 08 80 00 23 bleu 40019dfc <msdos_set_first_char4file_name+0x144><== NEVER TAKEN
40019d74: c2 27 bf f4 st %g1, [ %fp + -12 ]
40019d78: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
40019d7c: d4 17 40 00 lduh [ %i5 ], %o2
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40019d80: 80 a2 60 00 cmp %o1, 0
40019d84: 22 bf ff e4 be,a 40019d14 <msdos_set_first_char4file_name+0x5c><== ALWAYS TAKEN
40019d88: c6 0f 60 0e ldub [ %i5 + 0xe ], %g3
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40019d8c: c8 0f 60 05 ldub [ %i5 + 5 ], %g4 <== NOT EXECUTED
40019d90: c6 07 60 34 ld [ %i5 + 0x34 ], %g3 <== NOT EXECUTED
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
40019d94: 85 30 40 02 srl %g1, %g2, %g2 <== NOT EXECUTED
40019d98: 92 02 7f fe add %o1, -2, %o1 <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40019d9c: 95 2a a0 10 sll %o2, 0x10, %o2 <== NOT EXECUTED
40019da0: 93 2a 40 04 sll %o1, %g4, %o1 <== NOT EXECUTED
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40019da4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40019da8: 92 02 40 03 add %o1, %g3, %o1 <== NOT EXECUTED
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40019dac: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40019db0: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
40019db4: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40019db8: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
40019dbc: 94 08 40 0a and %g1, %o2, %o2 <== NOT EXECUTED
40019dc0: 7f ff ea 66 call 40014758 <fat_sector_write> <== NOT EXECUTED
40019dc4: 98 07 a0 4c add %fp, 0x4c, %o4 <== NOT EXECUTED
1, &fchar);
if (ret < 0)
40019dc8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40019dcc: 16 bf ff e4 bge 40019d5c <msdos_set_first_char4file_name+0xa4><== NOT EXECUTED
40019dd0: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
return -1;
40019dd4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
start.ofs = 0;
}
}
return RC_OK;
}
40019dd8: 81 c7 e0 08 ret <== NOT EXECUTED
40019ddc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
1, &fchar);
if (ret < 0)
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
40019de0: c4 07 bf fc ld [ %fp + -4 ], %g2
40019de4: 80 a0 40 02 cmp %g1, %g2
40019de8: 32 bf ff e1 bne,a 40019d6c <msdos_set_first_char4file_name+0xb4>
40019dec: 82 00 60 20 add %g1, 0x20, %g1
return rc;
start.ofs = 0;
}
}
return RC_OK;
40019df0: 90 10 20 00 clr %o0
}
40019df4: 81 c7 e0 08 ret
40019df8: 91 e8 00 08 restore %g0, %o0, %o0
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
if (start.ofs >= dir_block_size)
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40019dfc: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
40019e00: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
40019e04: 12 80 00 06 bne 40019e1c <msdos_set_first_char4file_name+0x164><== NOT EXECUTED
40019e08: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
40019e0c: 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) &&
40019e10: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
40019e14: 32 bf ff f8 bne,a 40019df4 <msdos_set_first_char4file_name+0x13c><== NOT EXECUTED
40019e18: 90 10 20 00 clr %o0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
40019e1c: 40 00 05 48 call 4001b33c <fat_get_fat_cluster> <== NOT EXECUTED
40019e20: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
40019e24: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40019e28: 12 bf ff ec bne 40019dd8 <msdos_set_first_char4file_name+0x120><== NOT EXECUTED
40019e2c: 82 10 20 00 clr %g1 <== NOT EXECUTED
return rc;
start.ofs = 0;
40019e30: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
40019e34: d4 17 40 00 lduh [ %i5 ], %o2 <== NOT EXECUTED
40019e38: 10 bf ff b5 b 40019d0c <msdos_set_first_char4file_name+0x54><== NOT EXECUTED
40019e3c: c4 0f 60 02 ldub [ %i5 + 2 ], %g2 <== NOT EXECUTED
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
40019e40: c4 0f 60 0e ldub [ %i5 + 0xe ], %g2
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
40019e44: 80 88 a0 03 btst 3, %g2
40019e48: 02 bf ff ab be 40019cf4 <msdos_set_first_char4file_name+0x3c><== NEVER TAKEN
40019e4c: c4 06 60 08 ld [ %i1 + 8 ], %g2
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
40019e50: 80 a0 bf ff cmp %g2, -1
40019e54: 12 bf ff ab bne 40019d00 <msdos_set_first_char4file_name+0x48>
40019e58: f6 07 60 2c ld [ %i5 + 0x2c ], %i3
start = dir_pos->sname;
40019e5c: f8 27 bf f0 st %i4, [ %fp + -16 ]
40019e60: 10 bf ff a8 b 40019d00 <msdos_set_first_char4file_name+0x48>
40019e64: c2 27 bf f4 st %g1, [ %fp + -12 ]
40019b28 <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
)
{
40019b28: 9d e3 bf 98 save %sp, -104, %sp
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
40019b2c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
uint16_t le_cl_hi = 0;
40019b30: c0 37 bf fe clrh [ %fp + -2 ]
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
40019b34: fa 06 20 08 ld [ %i0 + 8 ], %i5
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
40019b38: 80 a0 60 00 cmp %g1, 0
40019b3c: 12 80 00 06 bne 40019b54 <msdos_set_first_cluster_num+0x2c>
40019b40: f8 06 60 1c ld [ %i1 + 0x1c ], %i4
40019b44: c4 0f 60 0e ldub [ %i5 + 0xe ], %g2
40019b48: 80 88 a0 03 btst 3, %g2
40019b4c: 32 80 00 07 bne,a 40019b68 <msdos_set_first_cluster_num+0x40><== ALWAYS TAKEN
40019b50: f4 07 60 20 ld [ %i5 + 0x20 ], %i2
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
40019b54: c6 0f 60 05 ldub [ %i5 + 5 ], %g3
40019b58: c4 07 60 34 ld [ %i5 + 0x34 ], %g2
40019b5c: b4 00 7f fe add %g1, -2, %i2
40019b60: b5 2e 80 03 sll %i2, %g3, %i2
40019b64: b4 06 80 02 add %i2, %g2, %i2
/*
* calculate input for fat_sector_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
40019b68: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40019b6c: c4 0f 60 02 ldub [ %i5 + 2 ], %g2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
40019b70: 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);
40019b74: 85 30 40 02 srl %g1, %g2, %g2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
40019b78: 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);
40019b7c: b4 06 80 02 add %i2, %g2, %i2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
40019b80: b6 0e c0 01 and %i3, %g1, %i3
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
40019b84: 85 2f 20 10 sll %i4, 0x10, %g2
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
40019b88: 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));
40019b8c: 85 30 a0 18 srl %g2, 0x18, %g2
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
40019b90: b2 16 63 ff or %i1, 0x3ff, %i1
40019b94: 82 0f 00 19 and %i4, %i1, %g1
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
40019b98: 83 28 60 08 sll %g1, 8, %g1
40019b9c: 82 10 40 02 or %g1, %g2, %g1
ret1 = fat_sector_write(&fs_info->fat, sec,
40019ba0: 94 06 e0 1a add %i3, 0x1a, %o2
40019ba4: 92 10 00 1a mov %i2, %o1
40019ba8: 96 10 20 02 mov 2, %o3
40019bac: 98 07 bf fc add %fp, -4, %o4
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
40019bb0: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = fat_sector_write(&fs_info->fat, sec,
40019bb4: 7f ff ea e9 call 40014758 <fat_sector_write>
40019bb8: 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));
40019bbc: 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,
40019bc0: a0 10 00 08 mov %o0, %l0
rc = fat_sync(&fs_info->fat);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
40019bc4: 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,
40019bc8: 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));
40019bcc: b9 37 20 08 srl %i4, 8, %i4
40019bd0: b3 2e 60 08 sll %i1, 8, %i1
ret2 = fat_sector_write(&fs_info->fat, sec,
40019bd4: 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));
40019bd8: b8 16 40 1c or %i1, %i4, %i4
ret2 = fat_sector_write(&fs_info->fat, sec,
40019bdc: 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));
40019be0: f8 37 bf fe sth %i4, [ %fp + -2 ]
ret2 = fat_sector_write(&fs_info->fat, sec,
40019be4: 96 10 20 02 mov 2, %o3
40019be8: 7f ff ea dc call 40014758 <fat_sector_write>
40019bec: 98 07 bf fe add %fp, -2, %o4
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
40019bf0: 80 a2 20 00 cmp %o0, 0
40019bf4: 06 80 00 06 bl 40019c0c <msdos_set_first_cluster_num+0xe4><== NEVER TAKEN
40019bf8: 80 a4 20 00 cmp %l0, 0
40019bfc: 06 80 00 04 bl 40019c0c <msdos_set_first_cluster_num+0xe4><== NEVER TAKEN
40019c00: b0 10 20 00 clr %i0
return -1;
return RC_OK;
}
40019c04: 81 c7 e0 08 ret
40019c08: 81 e8 00 00 restore
40019c0c: 81 c7 e0 08 ret <== NOT EXECUTED
40019c10: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
4000e7c4 <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 )
{
4000e7c4: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = -1;
uint32_t onebit;
if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {
4000e7c8: 80 a6 20 00 cmp %i0, 0
4000e7cc: 22 80 00 07 be,a 4000e7e8 <msdos_set_sectors_per_cluster_from_request+0x24>
4000e7d0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000e7d4: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000e7d8: 80 a0 60 00 cmp %g1, 0
4000e7dc: 22 80 00 03 be,a 4000e7e8 <msdos_set_sectors_per_cluster_from_request+0x24>
4000e7e0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
fmt_params->sectors_per_cluster = rqdata->sectors_per_cluster;
4000e7e4: 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 )
{
4000e7e8: b8 10 20 08 mov 8, %i4
4000e7ec: ba 10 20 80 mov 0x80, %i5
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for ( onebit = 128; onebit >= 1; onebit = onebit >> 1 ) {
if ( fmt_params->sectors_per_cluster >= onebit ) {
4000e7f0: 80 a0 40 1d cmp %g1, %i5
4000e7f4: 2a 80 00 0b bcs,a 4000e820 <msdos_set_sectors_per_cluster_from_request+0x5c>
4000e7f8: b8 87 3f ff addcc %i4, -1, %i4
fmt_params->sectors_per_cluster = onebit;
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
4000e7fc: 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;
4000e800: fa 26 60 0c st %i5, [ %i1 + 0xc ]
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
4000e804: 7f ff cf 9c call 40002674 <.udiv>
4000e808: 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
4000e80c: 80 a2 00 1d cmp %o0, %i5
4000e810: 0a 80 00 04 bcs 4000e820 <msdos_set_sectors_per_cluster_from_request+0x5c><== NEVER TAKEN
4000e814: b8 87 3f ff addcc %i4, -1, %i4
<= 32768L / fmt_params->bytes_per_sector ) {
/* value is small enough so this value is ok */
onebit = 1;
ret_val = 0;
4000e818: 81 c7 e0 08 ret
4000e81c: 91 e8 20 00 restore %g0, 0, %o0
* check sectors per cluster.
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for ( onebit = 128; onebit >= 1; onebit = onebit >> 1 ) {
4000e820: 02 80 00 04 be 4000e830 <msdos_set_sectors_per_cluster_from_request+0x6c><== NEVER TAKEN
4000e824: bb 37 60 01 srl %i5, 1, %i5
4000e828: 10 bf ff f2 b 4000e7f0 <msdos_set_sectors_per_cluster_from_request+0x2c>
4000e82c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
}
}
}
if (ret_val != 0) {
errno = EINVAL;
4000e830: 40 00 3b 58 call 4001d590 <__errno> <== NOT EXECUTED
4000e834: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000e838: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000e83c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return ret_val;
}
4000e840: 81 c7 e0 08 ret <== NOT EXECUTED
4000e844: 81 e8 00 00 restore <== NOT EXECUTED
4001b1dc <msdos_sync>:
return MSDOS_NAME_NOT_FOUND_ERR;
}
int
msdos_sync(rtems_libio_t *iop)
{
4001b1dc: 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;
4001b1e0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001b1e4: 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;
4001b1e8: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4001b1ec: 94 10 20 00 clr %o2
4001b1f0: 7f ff bd 02 call 4000a5f8 <rtems_semaphore_obtain>
4001b1f4: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4001b1f8: 80 a2 20 00 cmp %o0, 0
4001b1fc: 12 80 00 09 bne 4001b220 <msdos_sync+0x44> <== NEVER TAKEN
4001b200: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_sync(&fs_info->fat);
4001b204: 7f ff e8 48 call 40015324 <fat_sync>
4001b208: 90 10 00 1d mov %i5, %o0
4001b20c: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
4001b210: 7f ff bd 49 call 4000a734 <rtems_semaphore_release>
4001b214: d0 07 60 9c ld [ %i5 + 0x9c ], %o0
return rc;
}
4001b218: 81 c7 e0 08 ret
4001b21c: 81 e8 00 00 restore
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
4001b220: 40 00 08 dc call 4001d590 <__errno> <== NOT EXECUTED
4001b224: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001b228: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
4001b22c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001b230: 81 c7 e0 08 ret <== NOT EXECUTED
4001b234: 81 e8 00 00 restore <== NOT EXECUTED
4000f97c <msdos_unlock>:
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
4000f97c: 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);
4000f980: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000f984: 7f ff eb 6c call 4000a734 <rtems_semaphore_release>
4000f988: d0 00 60 9c ld [ %g1 + 0x9c ], %o0
if (sc != RTEMS_SUCCESSFUL) {
4000f98c: 80 a2 20 00 cmp %o0, 0
4000f990: 12 80 00 04 bne 4000f9a0 <msdos_unlock+0x24> <== NEVER TAKEN
4000f994: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
4000f998: 81 c7 e0 08 ret
4000f99c: 81 e8 00 00 restore
rtems_fatal_error_occurred(0xdeadbeef);
4000f9a0: 7f ff ec f7 call 4000ad7c <rtems_fatal_error_occurred> <== NOT EXECUTED
4000f9a4: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
40004d74 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
40004d74: 9d e3 bf a0 save %sp, -96, %sp
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
40004d78: 03 10 00 7d sethi %hi(0x4001f400), %g1
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
40004d7c: 80 a6 00 19 cmp %i0, %i1
40004d80: 02 80 00 03 be 40004d8c <newlib_delete_hook+0x18>
40004d84: fa 00 63 68 ld [ %g1 + 0x368 ], %i5
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
40004d88: fa 06 61 48 ld [ %i1 + 0x148 ], %i5
}
if (ptr && ptr != _global_impure_ptr) {
40004d8c: 80 a7 60 00 cmp %i5, 0
40004d90: 02 80 00 0b be 40004dbc <newlib_delete_hook+0x48> <== NEVER TAKEN
40004d94: 03 10 00 7a sethi %hi(0x4001e800), %g1
40004d98: c2 00 62 a8 ld [ %g1 + 0x2a8 ], %g1 ! 4001eaa8 <_global_impure_ptr>
40004d9c: 80 a7 40 01 cmp %i5, %g1
40004da0: 02 80 00 07 be 40004dbc <newlib_delete_hook+0x48>
40004da4: 13 10 00 12 sethi %hi(0x40004800), %o1
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
40004da8: 90 10 00 1d mov %i5, %o0
40004dac: 40 00 30 f2 call 40011174 <_fwalk>
40004db0: 92 12 63 64 or %o1, 0x364, %o1
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
40004db4: 40 00 1d 1e call 4000c22c <_Workspace_Free>
40004db8: 90 10 00 1d mov %i5, %o0
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
40004dbc: 80 a6 00 19 cmp %i0, %i1
40004dc0: 12 80 00 04 bne 40004dd0 <newlib_delete_hook+0x5c>
40004dc4: c0 26 61 48 clr [ %i1 + 0x148 ]
_REENT = 0;
40004dc8: 03 10 00 7d sethi %hi(0x4001f400), %g1
40004dcc: c0 20 63 68 clr [ %g1 + 0x368 ] ! 4001f768 <_impure_ptr>
40004dd0: 81 c7 e0 08 ret
40004dd4: 81 e8 00 00 restore
40004b64 <newlib_free_buffers>:
* task.
*/
int newlib_free_buffers(
FILE *fp
)
{
40004b64: 9d e3 bf a0 save %sp, -96, %sp
switch ( fileno(fp) ) {
40004b68: 40 00 30 88 call 40010d88 <fileno>
40004b6c: 90 10 00 18 mov %i0, %o0
40004b70: 80 a2 20 02 cmp %o0, 2
40004b74: 28 80 00 06 bleu,a 40004b8c <newlib_free_buffers+0x28> <== ALWAYS TAKEN
40004b78: c2 16 20 0c lduh [ %i0 + 0xc ], %g1
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
40004b7c: 40 00 2f c3 call 40010a88 <fclose> <== NOT EXECUTED
40004b80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
return 0;
}
40004b84: 81 c7 e0 08 ret
40004b88: 91 e8 20 00 restore %g0, 0, %o0
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
40004b8c: 80 88 60 80 btst 0x80, %g1
40004b90: 02 bf ff fd be 40004b84 <newlib_free_buffers+0x20> <== ALWAYS TAKEN
40004b94: 01 00 00 00 nop
free( fp->_bf._base );
40004b98: 7f ff fd 9c call 40004208 <free> <== NOT EXECUTED
40004b9c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
fp->_flags &= ~__SMBF;
40004ba0: c2 16 20 0c lduh [ %i0 + 0xc ], %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
40004ba4: 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;
40004ba8: 82 08 7f 7f and %g1, -129, %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
40004bac: 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;
40004bb0: c2 36 20 0c sth %g1, [ %i0 + 0xc ] <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
40004bb4: 81 c7 e0 08 ret <== NOT EXECUTED
40004bb8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
4000202c <notify>:
}
void
notify (s)
char *s;
{
4000202c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
printf ("%s test appears to be inconsistent...\n", s);
40002030: 11 10 00 a2 sethi %hi(0x40028800), %o0 <== NOT EXECUTED
40002034: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40002038: 90 12 23 b8 or %o0, 0x3b8, %o0 <== NOT EXECUTED
4000203c: 40 00 70 c9 call 4001e360 <printf> <== NOT EXECUTED
40002040: 31 10 00 a2 sethi %hi(0x40028800), %i0 <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
40002044: 40 00 71 08 call 4001e464 <puts> <== NOT EXECUTED
40002048: 91 ee 23 e0 restore %i0, 0x3e0, %o0 <== NOT EXECUTED
40007a28 <null_op_fsmount_me>:
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
return -1;
}
40007a28: 81 c3 e0 08 retl <== NOT EXECUTED
40007a2c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40007a38 <null_op_fsunmount_me>:
static void null_op_fsunmount_me(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40007a38: 81 c3 e0 08 retl <== NOT EXECUTED
40007a00 <null_op_link>:
const char *name,
size_t namelen
)
{
return -1;
}
40007a00: 81 c3 e0 08 retl <== NOT EXECUTED
40007a04: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40007a20 <null_op_mount>:
static int null_op_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
return -1;
}
40007a20: 81 c3 e0 08 retl <== NOT EXECUTED
40007a24: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40007a50 <null_op_readlink>:
char *buf,
size_t bufsize
)
{
return -1;
}
40007a50: 81 c3 e0 08 retl <== NOT EXECUTED
40007a54: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40007a58 <null_op_rename>:
const char *name,
size_t namelen
)
{
return -1;
}
40007a58: 81 c3 e0 08 retl <== NOT EXECUTED
40007a5c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
400079f8 <null_op_rmnod>:
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
return -1;
}
400079f8: 81 c3 e0 08 retl <== NOT EXECUTED
400079fc: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40006a6c <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
40006a6c: 9d e3 bf a0 save %sp, -96, %sp
int i;
if (tty->termios.c_oflag & OPOST) {
40006a70: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
40006a74: 80 88 60 01 btst 1, %g1
40006a78: 02 80 00 21 be 40006afc <oproc+0x90> <== NEVER TAKEN
40006a7c: f0 2f a0 44 stb %i0, [ %fp + 0x44 ]
switch (c) {
40006a80: 80 a6 20 09 cmp %i0, 9
40006a84: 22 80 00 3d be,a 40006b78 <oproc+0x10c>
40006a88: c6 06 60 28 ld [ %i1 + 0x28 ], %g3
40006a8c: 08 80 00 22 bleu 40006b14 <oproc+0xa8> <== NEVER TAKEN
40006a90: 80 a6 20 08 cmp %i0, 8
40006a94: 80 a6 20 0a cmp %i0, 0xa
40006a98: 02 80 00 2b be 40006b44 <oproc+0xd8>
40006a9c: 80 a6 20 0d cmp %i0, 0xd
40006aa0: 02 80 00 45 be 40006bb4 <oproc+0x148> <== NEVER TAKEN
40006aa4: 80 88 60 10 btst 0x10, %g1
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
40006aa8: 80 88 60 02 btst 2, %g1
c = toupper(c);
40006aac: 03 10 00 7d sethi %hi(0x4001f400), %g1
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
40006ab0: 02 80 00 0b be 40006adc <oproc+0x70> <== ALWAYS TAKEN
40006ab4: c2 00 63 60 ld [ %g1 + 0x360 ], %g1 ! 4001f760 <__ctype_ptr__>
c = toupper(c);
40006ab8: 84 10 00 18 mov %i0, %g2 <== NOT EXECUTED
40006abc: b0 00 40 18 add %g1, %i0, %i0 <== NOT EXECUTED
40006ac0: c6 0e 20 01 ldub [ %i0 + 1 ], %g3 <== NOT EXECUTED
40006ac4: 86 08 e0 03 and %g3, 3, %g3 <== NOT EXECUTED
40006ac8: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED
40006acc: 22 80 00 02 be,a 40006ad4 <oproc+0x68> <== NOT EXECUTED
40006ad0: 84 00 bf e0 add %g2, -32, %g2 <== NOT EXECUTED
40006ad4: c4 2f a0 44 stb %g2, [ %fp + 0x44 ] <== NOT EXECUTED
40006ad8: b0 08 a0 ff and %g2, 0xff, %i0 <== NOT EXECUTED
if (!iscntrl(c))
40006adc: b0 00 40 18 add %g1, %i0, %i0
40006ae0: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
40006ae4: 80 88 60 20 btst 0x20, %g1
40006ae8: 12 80 00 06 bne 40006b00 <oproc+0x94> <== NEVER TAKEN
40006aec: 90 07 a0 44 add %fp, 0x44, %o0
tty->column++;
40006af0: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
40006af4: 82 00 60 01 inc %g1
40006af8: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
break;
}
}
rtems_termios_puts (&c, 1, tty);
40006afc: 90 07 a0 44 add %fp, 0x44, %o0
40006b00: 92 10 20 01 mov 1, %o1
40006b04: 7f ff ff 8a call 4000692c <rtems_termios_puts>
40006b08: 94 10 00 19 mov %i1, %o2
40006b0c: 81 c7 e0 08 ret
40006b10: 81 e8 00 00 restore
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
40006b14: 12 bf ff e6 bne 40006aac <oproc+0x40> <== NOT EXECUTED
40006b18: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
40006b1c: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED
40006b20: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006b24: 04 bf ff f6 ble 40006afc <oproc+0x90> <== NOT EXECUTED
40006b28: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
if (!iscntrl(c))
tty->column++;
break;
}
}
rtems_termios_puts (&c, 1, tty);
40006b2c: 90 07 a0 44 add %fp, 0x44, %o0 <== NOT EXECUTED
tty->column += i;
break;
case '\b':
if (tty->column > 0)
tty->column--;
40006b30: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (!iscntrl(c))
tty->column++;
break;
}
}
rtems_termios_puts (&c, 1, tty);
40006b34: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40006b38: 7f ff ff 7d call 4000692c <rtems_termios_puts> <== NOT EXECUTED
40006b3c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40006b40: 30 80 00 1b b,a 40006bac <oproc+0x140> <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
40006b44: 80 88 60 20 btst 0x20, %g1
40006b48: 32 80 00 02 bne,a 40006b50 <oproc+0xe4> <== NEVER TAKEN
40006b4c: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
tty->column = 0;
if (tty->termios.c_oflag & ONLCR) {
40006b50: 80 88 60 04 btst 4, %g1
40006b54: 22 bf ff eb be,a 40006b00 <oproc+0x94> <== NEVER TAKEN
40006b58: 90 07 a0 44 add %fp, 0x44, %o0 <== NOT EXECUTED
rtems_termios_puts ("\r", 1, tty);
40006b5c: 92 10 20 01 mov 1, %o1
40006b60: 11 10 00 78 sethi %hi(0x4001e000), %o0
40006b64: 94 10 00 19 mov %i1, %o2
40006b68: 7f ff ff 71 call 4000692c <rtems_termios_puts>
40006b6c: 90 12 21 38 or %o0, 0x138, %o0
tty->column = 0;
40006b70: 10 bf ff e3 b 40006afc <oproc+0x90>
40006b74: c0 26 60 28 clr [ %i1 + 0x28 ]
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
40006b78: 92 10 20 08 mov 8, %o1
40006b7c: 88 08 e0 07 and %g3, 7, %g4
40006b80: 92 22 40 04 sub %o1, %g4, %o1
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
40006b84: 86 00 c0 09 add %g3, %o1, %g3
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
40006b88: 05 00 00 06 sethi %hi(0x1800), %g2
40006b8c: 82 08 40 02 and %g1, %g2, %g1
40006b90: 80 a0 40 02 cmp %g1, %g2
40006b94: 12 bf ff da bne 40006afc <oproc+0x90> <== NEVER TAKEN
40006b98: c6 26 60 28 st %g3, [ %i1 + 0x28 ]
tty->column += i;
rtems_termios_puts ( " ", i, tty);
40006b9c: 11 10 00 78 sethi %hi(0x4001e000), %o0
40006ba0: 94 10 00 19 mov %i1, %o2
40006ba4: 7f ff ff 62 call 4000692c <rtems_termios_puts>
40006ba8: 90 12 21 40 or %o0, 0x140, %o0
return;
40006bac: 81 c7 e0 08 ret
40006bb0: 81 e8 00 00 restore
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
40006bb4: 02 80 00 06 be 40006bcc <oproc+0x160> <== NOT EXECUTED
40006bb8: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
40006bbc: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 <== NOT EXECUTED
40006bc0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40006bc4: 02 bf ff d2 be 40006b0c <oproc+0xa0> <== NOT EXECUTED
40006bc8: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
40006bcc: 22 bf ff cc be,a 40006afc <oproc+0x90> <== NOT EXECUTED
40006bd0: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
c = '\n';
40006bd4: 84 10 20 0a mov 0xa, %g2 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
40006bd8: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
40006bdc: 02 bf ff c8 be 40006afc <oproc+0x90> <== NOT EXECUTED
40006be0: c4 2f a0 44 stb %g2, [ %fp + 0x44 ] <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
break;
40006be4: 10 bf ff c6 b 40006afc <oproc+0x90> <== NOT EXECUTED
40006be8: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
40005644 <partition_free>:
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
{
40005644: 9d e3 bf a0 save %sp, -96, %sp
int part_num;
if (part_desc == NULL)
40005648: 80 a6 20 00 cmp %i0, 0
4000564c: 02 80 00 11 be 40005690 <partition_free+0x4c>
40005650: 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));
40005654: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
int part_num;
if (part_desc == NULL)
return;
if (is_extended(part_desc->sys_type))
40005658: 82 08 60 7f and %g1, 0x7f, %g1
4000565c: 80 a0 60 05 cmp %g1, 5
40005660: 12 80 00 0a bne 40005688 <partition_free+0x44> <== ALWAYS TAKEN
40005664: 01 00 00 00 nop
40005668: ba 10 20 00 clr %i5 ! 0 <PROM_START> <== NOT EXECUTED
*
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
4000566c: 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]);
40005670: d0 00 60 18 ld [ %g1 + 0x18 ], %o0 <== NOT EXECUTED
40005674: 7f ff ff f4 call 40005644 <partition_free> <== NOT EXECUTED
40005678: 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;
4000567c: 80 a7 60 10 cmp %i5, 0x10 <== NOT EXECUTED
40005680: 12 bf ff fc bne 40005670 <partition_free+0x2c> <== NOT EXECUTED
40005684: 82 06 00 1d add %i0, %i5, %g1 <== NOT EXECUTED
{
partition_free(part_desc->sub_part[part_num]);
}
}
free(part_desc);
40005688: 40 00 03 b4 call 40006558 <free>
4000568c: 81 e8 00 00 restore
40005690: 81 c7 e0 08 ret
40005694: 81 e8 00 00 restore
400059dc <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)
{
400059dc: 9d e3 bf 50 save %sp, -176, %sp
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
400059e0: 92 10 20 00 clr %o1
400059e4: 90 10 00 18 mov %i0, %o0
400059e8: 40 00 06 8e call 40007420 <open>
400059ec: b8 10 00 18 mov %i0, %i4
if (fd < 0)
{
return RTEMS_INTERNAL_ERROR;
400059f0: b0 10 20 19 mov 0x19, %i0
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
if (fd < 0)
400059f4: 80 a2 20 00 cmp %o0, 0
400059f8: 06 80 00 09 bl 40005a1c <partition_table_get+0x40> <== NEVER TAKEN
400059fc: ba 10 00 08 mov %o0, %i5
{
return RTEMS_INTERNAL_ERROR;
}
rc = fstat(fd, &dev_stat);
40005a00: 40 00 03 00 call 40006600 <fstat>
40005a04: 92 07 bf b8 add %fp, -72, %o1
if (rc != RTEMS_SUCCESSFUL)
40005a08: 80 a2 20 00 cmp %o0, 0
40005a0c: 02 80 00 06 be 40005a24 <partition_table_get+0x48> <== ALWAYS TAKEN
40005a10: 90 06 60 08 add %i1, 8, %o0
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
RTEMS_IDE_SECTOR_SIZE;
rc = read_mbr(fd, disk_desc);
close(fd);
40005a14: 40 00 02 af call 400064d0 <close>
40005a18: 90 10 00 1d mov %i5, %o0
40005a1c: 81 c7 e0 08 ret
40005a20: 81 e8 00 00 restore
{
close(fd);
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
40005a24: 92 10 00 1c mov %i4, %o1
40005a28: 40 00 47 c1 call 4001792c <strncpy>
40005a2c: 94 10 20 0f mov 0xf, %o2
disk_desc->dev = dev_stat.st_rdev;
40005a30: c4 1f bf d0 ldd [ %fp + -48 ], %g2
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
40005a34: c8 07 bf f8 ld [ %fp + -8 ], %g4
close(fd);
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
disk_desc->dev = dev_stat.st_rdev;
40005a38: c4 3e 40 00 std %g2, [ %i1 ]
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
40005a3c: 80 a1 20 00 cmp %g4, 0
40005a40: 02 80 00 03 be 40005a4c <partition_table_get+0x70> <== ALWAYS TAKEN
40005a44: 82 10 22 00 mov 0x200, %g1
40005a48: 82 10 00 04 mov %g4, %g1 <== NOT EXECUTED
40005a4c: 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;
40005a50: 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);
40005a54: 90 10 00 1d mov %i5, %o0
40005a58: 92 10 20 00 clr %o1
40005a5c: 94 10 20 00 clr %o2
40005a60: 96 10 20 00 clr %o3
40005a64: 40 00 03 e1 call 400069e8 <lseek>
40005a68: b0 10 20 1b mov 0x1b, %i0
if (new_off != off) {
40005a6c: 80 92 00 09 orcc %o0, %o1, %g0
40005a70: 02 80 00 09 be 40005a94 <partition_table_get+0xb8> <== ALWAYS TAKEN
40005a74: 90 10 00 1d mov %i5, %o0
/* get MBR sector */
rc = get_sector(fd, 0, §or);
if (rc != RTEMS_SUCCESSFUL)
{
if (sector)
40005a78: d0 07 bf b0 ld [ %fp + -80 ], %o0 <== NOT EXECUTED
40005a7c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40005a80: 02 bf ff e5 be 40005a14 <partition_table_get+0x38> <== NOT EXECUTED
40005a84: 01 00 00 00 nop <== NOT EXECUTED
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
{
free(sector);
40005a88: 40 00 02 b4 call 40006558 <free> <== NOT EXECUTED
40005a8c: 01 00 00 00 nop <== NOT EXECUTED
40005a90: 30 bf ff e1 b,a 40005a14 <partition_table_get+0x38> <== NOT EXECUTED
40005a94: 92 10 20 00 clr %o1 ! 0 <PROM_START>
40005a98: 7f ff ff 0b call 400056c4 <get_sector.part.0>
40005a9c: 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)
40005aa0: b0 92 20 00 orcc %o0, 0, %i0
40005aa4: 12 bf ff f5 bne 40005a78 <partition_table_get+0x9c> <== NEVER TAKEN
40005aa8: d0 07 bf b0 ld [ %fp + -80 ], %o0
static bool
msdos_signature_check (rtems_sector_data_t *sector)
{
uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&
40005aac: c2 0a 22 02 ldub [ %o0 + 0x202 ], %g1
40005ab0: 80 a0 60 55 cmp %g1, 0x55
40005ab4: 22 80 00 05 be,a 40005ac8 <partition_table_get+0xec> <== ALWAYS TAKEN
40005ab8: c2 0a 22 03 ldub [ %o0 + 0x203 ], %g1
}
/* check if the partition table structure is MS-DOS style */
if (!msdos_signature_check(sector))
{
free(sector);
40005abc: 40 00 02 a7 call 40006558 <free> <== NOT EXECUTED
40005ac0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED
40005ac4: 30 bf ff d4 b,a 40005a14 <partition_table_get+0x38> <== NOT EXECUTED
static bool
msdos_signature_check (rtems_sector_data_t *sector)
{
uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&
40005ac8: 80 a0 60 aa cmp %g1, 0xaa
40005acc: 12 bf ff fc bne 40005abc <partition_table_get+0xe0> <== NEVER TAKEN
40005ad0: b4 02 21 c2 add %o0, 0x1c2, %i2
40005ad4: b6 10 00 19 mov %i1, %i3
return RTEMS_INTERNAL_ERROR;
}
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
40005ad8: a0 10 00 19 mov %i1, %l0
40005adc: b8 10 20 01 mov 1, %i4
40005ae0: 90 10 00 1a mov %i2, %o0
40005ae4: 7f ff ff 0f call 40005720 <data_to_part_desc.part.1>
40005ae8: 92 07 bf b4 add %fp, -76, %o1
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
40005aec: b0 92 20 00 orcc %o0, 0, %i0
40005af0: 12 80 00 2b bne 40005b9c <partition_table_get+0x1c0> <== NEVER TAKEN
40005af4: c2 07 bf b4 ld [ %fp + -76 ], %g1
{
free(sector);
return rc;
}
if (part_desc != NULL)
40005af8: 80 a0 60 00 cmp %g1, 0
40005afc: 22 80 00 0a be,a 40005b24 <partition_table_get+0x148> <== NEVER TAKEN
40005b00: c0 24 20 28 clr [ %l0 + 0x28 ] <== NOT EXECUTED
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
part_desc->end = part_desc->start + part_desc->size - 1;
40005b04: c6 00 60 04 ld [ %g1 + 4 ], %g3
40005b08: c4 00 60 08 ld [ %g1 + 8 ], %g2
return rc;
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
40005b0c: f8 28 60 02 stb %i4, [ %g1 + 2 ]
part_desc->disk_desc = disk_desc;
40005b10: f2 20 60 10 st %i1, [ %g1 + 0x10 ]
part_desc->end = part_desc->start + part_desc->size - 1;
40005b14: 84 00 c0 02 add %g3, %g2, %g2
40005b18: 84 00 bf ff add %g2, -1, %g2
40005b1c: c4 20 60 0c st %g2, [ %g1 + 0xc ]
disk_desc->partitions[part_num] = part_desc;
40005b20: c2 24 20 28 st %g1, [ %l0 + 0x28 ]
40005b24: b8 07 20 01 inc %i4
else
{
disk_desc->partitions[part_num] = NULL;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
40005b28: b4 06 a0 10 add %i2, 0x10, %i2
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
40005b2c: 82 0f 20 ff and %i4, 0xff, %g1
40005b30: 80 a0 60 05 cmp %g1, 5
40005b34: 12 bf ff eb bne 40005ae0 <partition_table_get+0x104>
40005b38: a0 04 20 04 add %l0, 4, %l0
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
40005b3c: d0 07 bf b0 ld [ %fp + -80 ], %o0
40005b40: 40 00 02 86 call 40006558 <free>
40005b44: b8 10 20 04 mov 4, %i4
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
40005b48: 82 10 20 04 mov 4, %g1
40005b4c: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
but we are to process each primary partition */
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
part_desc = disk_desc->partitions[part_num];
40005b50: d4 06 e0 28 ld [ %i3 + 0x28 ], %o2
if (part_desc != NULL && is_extended(part_desc->sys_type))
40005b54: 80 a2 a0 00 cmp %o2, 0
40005b58: 02 80 00 07 be 40005b74 <partition_table_get+0x198> <== NEVER TAKEN
40005b5c: 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));
40005b60: 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))
40005b64: 82 08 60 7f and %g1, 0x7f, %g1
40005b68: 80 a0 60 05 cmp %g1, 5
40005b6c: 22 80 00 06 be,a 40005b84 <partition_table_get+0x1a8>
40005b70: d2 02 a0 04 ld [ %o2 + 4 ], %o1
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
/* There cannot be more than one extended partition,
but we are to process each primary partition */
for (part_num = 0;
40005b74: b8 87 3f ff addcc %i4, -1, %i4
40005b78: 12 bf ff f6 bne 40005b50 <partition_table_get+0x174>
40005b7c: b6 06 e0 04 add %i3, 4, %i3
40005b80: 30 bf ff a5 b,a 40005a14 <partition_table_get+0x38>
part_num++)
{
part_desc = disk_desc->partitions[part_num];
if (part_desc != NULL && is_extended(part_desc->sys_type))
{
read_extended_partition(fd, part_desc->start, part_desc);
40005b84: 7f ff ff 34 call 40005854 <read_extended_partition>
40005b88: 90 10 00 1d mov %i5, %o0
free(part_desc);
40005b8c: 40 00 02 73 call 40006558 <free>
40005b90: d0 07 bf b4 ld [ %fp + -76 ], %o0
disk_desc->partitions[part_num] = NULL;
40005b94: 10 bf ff f8 b 40005b74 <partition_table_get+0x198>
40005b98: c0 26 e0 28 clr [ %i3 + 0x28 ]
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
{
free(sector);
40005b9c: 40 00 02 6f call 40006558 <free> <== NOT EXECUTED
40005ba0: d0 07 bf b0 ld [ %fp + -80 ], %o0 <== NOT EXECUTED
40005ba4: 30 bf ff 9c b,a 40005a14 <partition_table_get+0x38> <== NOT EXECUTED
4000556c <pathconf>:
*/
long pathconf(
const char *path,
int name
)
{
4000556c: 9d e3 bf a0 save %sp, -96, %sp
int status;
int fd;
fd = open( path, O_RDONLY );
40005570: 92 10 20 00 clr %o1
40005574: 7f ff ff 6d call 40005328 <open>
40005578: 90 10 00 18 mov %i0, %o0
if ( fd == -1 )
4000557c: 80 a2 3f ff cmp %o0, -1
40005580: 02 80 00 09 be 400055a4 <pathconf+0x38> <== ALWAYS TAKEN
40005584: ba 10 00 08 mov %o0, %i5
return -1;
status = fpathconf( fd, name );
40005588: 40 00 15 3b call 4000aa74 <fpathconf> <== NOT EXECUTED
4000558c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40005590: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
(void) close( fd );
40005594: 40 00 15 0a call 4000a9bc <close> <== NOT EXECUTED
40005598: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return status;
4000559c: 81 c7 e0 08 ret <== NOT EXECUTED
400055a0: 81 e8 00 00 restore <== NOT EXECUTED
}
400055a4: 81 c7 e0 08 ret
400055a8: 91 e8 3f ff restore %g0, -1, %o0
4000df60 <pipe_create>:
static uint16_t rtems_pipe_no = 0;
int pipe_create(
int filsdes[2]
)
{
4000df60: 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)
4000df64: 92 10 21 ff mov 0x1ff, %o1
4000df68: 11 10 00 7f sethi %hi(0x4001fc00), %o0
4000df6c: 40 00 05 93 call 4000f5b8 <rtems_mkdir>
4000df70: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 4001fec0 <_CPU_Trap_slot_template+0x10>
4000df74: 80 a2 20 00 cmp %o0, 0
4000df78: 12 80 00 49 bne 4000e09c <pipe_create+0x13c>
4000df7c: 03 10 00 84 sethi %hi(0x40021000), %g1
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000df80: d4 10 60 e0 lduh [ %g1 + 0xe0 ], %o2 ! 400210e0 <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);
4000df84: 05 0b dd 1b sethi %hi(0x2f746c00), %g2
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000df88: 88 02 a0 01 add %o2, 1, %g4
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
4000df8c: 84 10 a1 70 or %g2, 0x170, %g2
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000df90: c8 30 60 e0 sth %g4, [ %g1 + 0xe0 ]
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
4000df94: 07 0b cb 99 sethi %hi(0x2f2e6400), %g3
4000df98: 03 00 00 19 sethi %hi(0x6400), %g1
4000df9c: 86 10 e2 69 or %g3, 0x269, %g3
4000dfa0: 82 10 62 6f or %g1, 0x26f, %g1
4000dfa4: c4 3f bf f0 std %g2, [ %fp + -16 ]
4000dfa8: c2 37 bf f8 sth %g1, [ %fp + -8 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000dfac: 95 2a a0 10 sll %o2, 0x10, %o2
4000dfb0: 90 07 bf fa add %fp, -6, %o0
4000dfb4: 95 32 a0 10 srl %o2, 0x10, %o2
4000dfb8: 13 10 00 7f sethi %hi(0x4001fc00), %o1
4000dfbc: 40 00 12 f8 call 40012b9c <sprintf>
4000dfc0: 92 12 62 c8 or %o1, 0x2c8, %o1 ! 4001fec8 <_CPU_Trap_slot_template+0x18>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
4000dfc4: 90 07 bf f0 add %fp, -16, %o0
4000dfc8: 40 00 04 c8 call 4000f2e8 <mkfifo>
4000dfcc: 92 10 21 80 mov 0x180, %o1
4000dfd0: 80 a2 20 00 cmp %o0, 0
4000dfd4: 12 80 00 39 bne 4000e0b8 <pipe_create+0x158> <== NEVER TAKEN
4000dfd8: 90 07 bf f0 add %fp, -16, %o0
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
4000dfdc: 7f ff dd c8 call 400056fc <open>
4000dfe0: 13 00 00 10 sethi %hi(0x4000), %o1
if (filsdes[0] < 0) {
4000dfe4: 80 a2 20 00 cmp %o0, 0
4000dfe8: 06 80 00 20 bl 4000e068 <pipe_create+0x108>
4000dfec: d0 26 00 00 st %o0, [ %i0 ]
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
4000dff0: 03 10 00 82 sethi %hi(0x40020800), %g1
4000dff4: c4 00 60 54 ld [ %g1 + 0x54 ], %g2 ! 40020854 <rtems_libio_number_iops>
4000dff8: 80 a2 00 02 cmp %o0, %g2
4000dffc: 0a 80 00 14 bcs 4000e04c <pipe_create+0xec> <== ALWAYS TAKEN
4000e000: 82 10 20 00 clr %g1
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
4000e004: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
filsdes[1] = open(fifopath, O_WRONLY);
4000e008: 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;
4000e00c: 84 08 bf fe and %g2, -2, %g2
filsdes[1] = open(fifopath, O_WRONLY);
4000e010: 92 10 20 01 mov 1, %o1
4000e014: 7f ff dd ba call 400056fc <open>
4000e018: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
4000e01c: d0 26 20 04 st %o0, [ %i0 + 4 ]
if (filsdes[1] < 0) {
4000e020: 80 a2 20 00 cmp %o0, 0
4000e024: 06 80 00 18 bl 4000e084 <pipe_create+0x124>
4000e028: ba 10 20 00 clr %i5
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
4000e02c: 7f ff e9 c4 call 4000873c <unlink>
4000e030: 90 07 bf f0 add %fp, -16, %o0
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
4000e034: b0 10 20 00 clr %i0
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
4000e038: 80 a7 60 00 cmp %i5, 0
4000e03c: 12 80 00 1a bne 4000e0a4 <pipe_create+0x144>
4000e040: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(err);
return 0;
}
4000e044: 81 c7 e0 08 ret
4000e048: 81 e8 00 00 restore
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
4000e04c: 03 10 00 84 sethi %hi(0x40021000), %g1
4000e050: c2 00 63 c8 ld [ %g1 + 0x3c8 ], %g1 ! 400213c8 <rtems_libio_iops>
4000e054: 85 2a 20 03 sll %o0, 3, %g2
4000e058: 91 2a 20 06 sll %o0, 6, %o0
4000e05c: 90 22 00 02 sub %o0, %g2, %o0
4000e060: 10 bf ff e9 b 4000e004 <pipe_create+0xa4>
4000e064: 82 00 40 08 add %g1, %o0, %g1
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
if (filsdes[0] < 0) {
err = errno;
4000e068: 40 00 0f fb call 40012054 <__errno>
4000e06c: b0 10 20 00 clr %i0
4000e070: fa 02 00 00 ld [ %o0 ], %i5
/* Delete file at errors, or else if pipe is successfully created
the file node will be deleted after it is closed by all. */
unlink(fifopath);
4000e074: 7f ff e9 b2 call 4000873c <unlink>
4000e078: 90 07 bf f0 add %fp, -16, %o0
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
4000e07c: 10 bf ff f0 b 4000e03c <pipe_create+0xdc>
4000e080: 80 a7 60 00 cmp %i5, 0
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
if (filsdes[1] < 0) {
err = errno;
4000e084: 40 00 0f f4 call 40012054 <__errno>
4000e088: 01 00 00 00 nop
4000e08c: fa 02 00 00 ld [ %o0 ], %i5
close(filsdes[0]);
4000e090: 7f ff da 39 call 40004974 <close>
4000e094: d0 06 00 00 ld [ %i0 ], %o0
4000e098: 30 bf ff e5 b,a 4000e02c <pipe_create+0xcc>
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
4000e09c: 81 c7 e0 08 ret
4000e0a0: 91 e8 3f ff restore %g0, -1, %o0
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
4000e0a4: 40 00 0f ec call 40012054 <__errno>
4000e0a8: b0 10 3f ff mov -1, %i0
4000e0ac: fa 22 00 00 st %i5, [ %o0 ]
4000e0b0: 81 c7 e0 08 ret
4000e0b4: 81 e8 00 00 restore
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
if (errno != EEXIST){
4000e0b8: 40 00 0f e7 call 40012054 <__errno> <== NOT EXECUTED
4000e0bc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000e0c0: 81 c7 e0 08 ret <== NOT EXECUTED
4000e0c4: 81 e8 00 00 restore <== NOT EXECUTED
4000f578 <pipe_ioctl>:
pipe_control_t *pipe,
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
4000f578: 9d e3 bf a0 save %sp, -96, %sp
if (cmd == FIONREAD) {
4000f57c: 03 10 01 19 sethi %hi(0x40046400), %g1
4000f580: 82 10 62 7f or %g1, 0x27f, %g1 ! 4004667f <__end+0x20bbf>
4000f584: 80 a6 40 01 cmp %i1, %g1
4000f588: 12 80 00 11 bne 4000f5cc <pipe_ioctl+0x54>
4000f58c: 80 a6 a0 00 cmp %i2, 0
if (buffer == NULL)
4000f590: 02 80 00 13 be 4000f5dc <pipe_ioctl+0x64>
4000f594: 92 10 20 00 clr %o1
return -EFAULT;
if (! PIPE_LOCK(pipe))
4000f598: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4000f59c: 7f ff e9 ba call 40009c84 <rtems_semaphore_obtain>
4000f5a0: 94 10 20 00 clr %o2
4000f5a4: 80 a2 20 00 cmp %o0, 0
4000f5a8: 12 80 00 0b bne 4000f5d4 <pipe_ioctl+0x5c> <== NEVER TAKEN
4000f5ac: 01 00 00 00 nop
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4000f5b0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
PIPE_UNLOCK(pipe);
4000f5b4: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4000f5b8: c2 26 80 00 st %g1, [ %i2 ]
PIPE_UNLOCK(pipe);
4000f5bc: 7f ff ea 01 call 40009dc0 <rtems_semaphore_release>
4000f5c0: b0 10 20 00 clr %i0
return 0;
4000f5c4: 81 c7 e0 08 ret
4000f5c8: 81 e8 00 00 restore
}
return -EINVAL;
4000f5cc: 81 c7 e0 08 ret
4000f5d0: 91 e8 3f ea restore %g0, -22, %o0
}
4000f5d4: 81 c7 e0 08 ret <== NOT EXECUTED
4000f5d8: 91 e8 3f fc restore %g0, -4, %o0 <== NOT EXECUTED
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
4000f5dc: 81 c7 e0 08 ret
4000f5e0: 91 e8 3f f2 restore %g0, -14, %o0
4000f1b4 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000f1b4: 9d e3 bf 98 save %sp, -104, %sp
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
4000f1b8: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
4000f1bc: 92 10 20 00 clr %o1
4000f1c0: 94 10 20 00 clr %o2
4000f1c4: 7f ff ea b0 call 40009c84 <rtems_semaphore_obtain>
4000f1c8: ba 10 00 18 mov %i0, %i5
4000f1cc: 80 a2 20 00 cmp %o0, 0
4000f1d0: 12 80 00 60 bne 4000f350 <pipe_read+0x19c> <== NEVER TAKEN
4000f1d4: a0 10 20 00 clr %l0
return -EINTR;
while (read < count) {
4000f1d8: 80 a6 a0 00 cmp %i2, 0
4000f1dc: 02 80 00 53 be 4000f328 <pipe_read+0x174> <== NEVER TAKEN
4000f1e0: b0 10 20 00 clr %i0
while (PIPE_EMPTY(pipe)) {
4000f1e4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000f1e8: 80 a0 60 00 cmp %g1, 0
4000f1ec: 12 80 00 29 bne 4000f290 <pipe_read+0xdc>
4000f1f0: 84 26 80 10 sub %i2, %l0, %g2
/* Not an error */
if (pipe->Writers == 0)
4000f1f4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000f1f8: 80 a0 60 00 cmp %g1, 0
4000f1fc: 02 80 00 1c be 4000f26c <pipe_read+0xb8>
4000f200: b8 10 20 00 clr %i4
goto out_locked;
if (LIBIO_NODELAY(iop)) {
4000f204: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
4000f208: 80 88 60 01 btst 1, %g1
4000f20c: 32 80 00 18 bne,a 4000f26c <pipe_read+0xb8>
4000f210: 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 ++;
4000f214: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
PIPE_UNLOCK(pipe);
4000f218: 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 ++;
4000f21c: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
4000f220: 7f ff ea e8 call 40009dc0 <rtems_semaphore_release>
4000f224: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_READWAIT(pipe))
4000f228: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000f22c: 40 00 05 c8 call 4001094c <rtems_barrier_wait>
4000f230: 92 10 20 00 clr %o1
4000f234: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000f238: 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))
4000f23c: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000f240: 92 10 20 00 clr %o1
4000f244: 94 10 20 00 clr %o2
4000f248: 7f ff ea 8f call 40009c84 <rtems_semaphore_obtain>
4000f24c: b8 0f 3f fc and %i4, -4, %i4
4000f250: 80 a2 20 00 cmp %o0, 0
4000f254: 12 80 00 37 bne 4000f330 <pipe_read+0x17c> <== NEVER TAKEN
4000f258: 80 a7 20 00 cmp %i4, 0
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
4000f25c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000f260: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
4000f264: 02 bf ff e0 be 4000f1e4 <pipe_read+0x30> <== ALWAYS TAKEN
4000f268: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
4000f26c: 7f ff ea d5 call 40009dc0 <rtems_semaphore_release>
4000f270: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
if (read > 0)
4000f274: 80 a6 20 00 cmp %i0, 0
4000f278: 04 80 00 04 ble 4000f288 <pipe_read+0xd4>
4000f27c: 01 00 00 00 nop
return read;
return ret;
}
4000f280: 81 c7 e0 08 ret
4000f284: 81 e8 00 00 restore
4000f288: 81 c7 e0 08 ret
4000f28c: 91 e8 00 1c restore %g0, %i4, %o0
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
4000f290: 80 a0 40 02 cmp %g1, %g2
4000f294: 08 80 00 03 bleu 4000f2a0 <pipe_read+0xec>
4000f298: b8 10 00 01 mov %g1, %i4
4000f29c: b8 10 00 02 mov %g2, %i4
chunk1 = pipe->Size - pipe->Start;
4000f2a0: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000f2a4: e2 07 60 04 ld [ %i5 + 4 ], %l1
4000f2a8: a2 24 40 01 sub %l1, %g1, %l1
if (chunk > chunk1) {
4000f2ac: 80 a7 00 11 cmp %i4, %l1
4000f2b0: 04 80 00 22 ble 4000f338 <pipe_read+0x184>
4000f2b4: d2 07 40 00 ld [ %i5 ], %o1
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4000f2b8: 94 10 00 11 mov %l1, %o2
4000f2bc: 92 02 40 01 add %o1, %g1, %o1
4000f2c0: 40 00 11 51 call 40013804 <memcpy>
4000f2c4: 90 06 40 10 add %i1, %l0, %o0
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
4000f2c8: d2 07 40 00 ld [ %i5 ], %o1
4000f2cc: 90 04 00 11 add %l0, %l1, %o0
4000f2d0: 94 27 00 11 sub %i4, %l1, %o2
4000f2d4: 40 00 11 4c call 40013804 <memcpy>
4000f2d8: 90 06 40 08 add %i1, %o0, %o0
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
4000f2dc: d0 07 60 08 ld [ %i5 + 8 ], %o0
pipe->Start %= pipe->Size;
4000f2e0: d2 07 60 04 ld [ %i5 + 4 ], %o1
4000f2e4: 40 00 40 4f call 4001f420 <.urem>
4000f2e8: 90 07 00 08 add %i4, %o0, %o0
pipe->Length -= chunk;
4000f2ec: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
4000f2f0: d0 27 60 08 st %o0, [ %i5 + 8 ]
pipe->Length -= chunk;
4000f2f4: 82 20 40 1c sub %g1, %i4, %g1
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
4000f2f8: 80 a0 60 00 cmp %g1, 0
4000f2fc: 12 80 00 03 bne 4000f308 <pipe_read+0x154>
4000f300: c2 27 60 0c st %g1, [ %i5 + 0xc ]
pipe->Start = 0;
4000f304: c0 27 60 08 clr [ %i5 + 8 ]
if (pipe->waitingWriters > 0)
4000f308: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000f30c: 80 a0 60 00 cmp %g1, 0
4000f310: 32 80 00 12 bne,a 4000f358 <pipe_read+0x1a4>
4000f314: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
4000f318: b0 06 00 1c add %i0, %i4, %i0
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
4000f31c: 80 a6 00 1a cmp %i0, %i2
4000f320: 0a bf ff b1 bcs 4000f1e4 <pipe_read+0x30> <== NEVER TAKEN
4000f324: a0 10 00 18 mov %i0, %l0
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
4000f328: 10 bf ff d1 b 4000f26c <pipe_read+0xb8>
4000f32c: b8 10 20 00 clr %i4
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
4000f330: 10 bf ff d1 b 4000f274 <pipe_read+0xc0> <== NOT EXECUTED
4000f334: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
4000f338: 90 06 40 10 add %i1, %l0, %o0
4000f33c: 92 02 40 01 add %o1, %g1, %o1
4000f340: 40 00 11 31 call 40013804 <memcpy>
4000f344: 94 10 00 1c mov %i4, %o2
pipe->Start += chunk;
4000f348: 10 bf ff e6 b 4000f2e0 <pipe_read+0x12c>
4000f34c: d0 07 60 08 ld [ %i5 + 8 ], %o0
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
4000f350: 81 c7 e0 08 ret <== NOT EXECUTED
4000f354: 91 e8 3f fc restore %g0, -4, %o0 <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
4000f358: 40 00 05 65 call 400108ec <rtems_barrier_release>
4000f35c: 92 07 bf fc add %fp, -4, %o1
read += chunk;
4000f360: 10 bf ff ef b 4000f31c <pipe_read+0x168>
4000f364: b0 06 00 1c add %i0, %i4, %i0
4000ec04 <pipe_release>:
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000ec04: 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);
4000ec08: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
4000ec0c: 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)
4000ec10: 80 88 60 02 btst 2, %g1
4000ec14: 02 80 00 05 be 4000ec28 <pipe_release+0x24>
4000ec18: b8 08 60 06 and %g1, 6, %i4
pipe->Readers --;
4000ec1c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4000ec20: 84 00 bf ff add %g2, -1, %g2
4000ec24: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
if (mode & LIBIO_FLAGS_WRITE)
4000ec28: 80 88 60 04 btst 4, %g1
4000ec2c: 02 80 00 05 be 4000ec40 <pipe_release+0x3c>
4000ec30: 01 00 00 00 nop
pipe->Writers --;
4000ec34: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000ec38: 82 00 7f ff add %g1, -1, %g1
4000ec3c: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
PIPE_UNLOCK(pipe);
4000ec40: 7f ff ec 60 call 40009dc0 <rtems_semaphore_release>
4000ec44: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (pipe->Readers == 0 && pipe->Writers == 0) {
4000ec48: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000ec4c: 80 a0 60 00 cmp %g1, 0
4000ec50: 02 80 00 0f be 4000ec8c <pipe_release+0x88>
4000ec54: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
4000ec58: 80 a0 60 00 cmp %g1, 0
4000ec5c: 12 80 00 07 bne 4000ec78 <pipe_release+0x74> <== NEVER TAKEN
4000ec60: 80 a7 20 02 cmp %i4, 2
4000ec64: 02 80 00 06 be 4000ec7c <pipe_release+0x78> <== NEVER TAKEN
4000ec68: 03 10 00 92 sethi %hi(0x40024800), %g1
PIPE_WAKEUPREADERS(pipe);
4000ec6c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000ec70: 40 00 07 1f call 400108ec <rtems_barrier_release>
4000ec74: 92 07 bf fc add %fp, -4, %o1
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
4000ec78: 03 10 00 92 sethi %hi(0x40024800), %g1
4000ec7c: 7f ff ec 51 call 40009dc0 <rtems_semaphore_release>
4000ec80: d0 00 63 20 ld [ %g1 + 0x320 ], %o0 ! 40024b20 <pipe_semaphore>
4000ec84: 81 c7 e0 08 ret
4000ec88: 81 e8 00 00 restore
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
4000ec8c: 80 a0 60 00 cmp %g1, 0
4000ec90: 02 80 00 0c be 4000ecc0 <pipe_release+0xbc>
4000ec94: 80 a7 20 04 cmp %i4, 4
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
4000ec98: 02 bf ff f9 be 4000ec7c <pipe_release+0x78> <== NEVER TAKEN
4000ec9c: 03 10 00 92 sethi %hi(0x40024800), %g1
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
4000eca0: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000eca4: 40 00 07 12 call 400108ec <rtems_barrier_release>
4000eca8: 92 07 bf fc add %fp, -4, %o1
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
4000ecac: 03 10 00 92 sethi %hi(0x40024800), %g1
4000ecb0: 7f ff ec 44 call 40009dc0 <rtems_semaphore_release>
4000ecb4: d0 00 63 20 ld [ %g1 + 0x320 ], %o0 ! 40024b20 <pipe_semaphore>
4000ecb8: 81 c7 e0 08 ret
4000ecbc: 81 e8 00 00 restore
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
4000ecc0: 40 00 06 e2 call 40010848 <rtems_barrier_delete>
4000ecc4: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
rtems_barrier_delete(pipe->writeBarrier);
4000ecc8: 40 00 06 e0 call 40010848 <rtems_barrier_delete>
4000eccc: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
rtems_semaphore_delete(pipe->Semaphore);
4000ecd0: 7f ff eb b6 call 40009ba8 <rtems_semaphore_delete>
4000ecd4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
free(pipe->Buffer);
4000ecd8: 7f ff d9 82 call 400052e0 <free>
4000ecdc: d0 07 40 00 ld [ %i5 ], %o0
free(pipe);
4000ece0: 7f ff d9 80 call 400052e0 <free>
4000ece4: 90 10 00 1d mov %i5, %o0
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
4000ece8: 03 10 00 92 sethi %hi(0x40024800), %g1
4000ecec: d0 00 63 20 ld [ %g1 + 0x320 ], %o0 ! 40024b20 <pipe_semaphore>
4000ecf0: 7f ff ec 34 call 40009dc0 <rtems_semaphore_release>
4000ecf4: c0 26 00 00 clr [ %i0 ]
4000ecf8: 81 c7 e0 08 ret
4000ecfc: 81 e8 00 00 restore
4000f368 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000f368: 9d e3 bf 98 save %sp, -104, %sp
4000f36c: ba 10 00 18 mov %i0, %i5
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
4000f370: 80 a6 a0 00 cmp %i2, 0
4000f374: 12 80 00 04 bne 4000f384 <pipe_write+0x1c> <== ALWAYS TAKEN
4000f378: b0 10 20 00 clr %i0
#endif
if (written > 0)
return written;
return ret;
}
4000f37c: 81 c7 e0 08 ret
4000f380: 81 e8 00 00 restore
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
4000f384: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
4000f388: 92 10 20 00 clr %o1
4000f38c: 7f ff ea 3e call 40009c84 <rtems_semaphore_obtain>
4000f390: 94 10 20 00 clr %o2
4000f394: 80 a2 20 00 cmp %o0, 0
4000f398: 12 80 00 6c bne 4000f548 <pipe_write+0x1e0> <== NEVER TAKEN
4000f39c: 01 00 00 00 nop
return -EINTR;
if (pipe->Readers == 0) {
4000f3a0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000f3a4: 80 a0 60 00 cmp %g1, 0
4000f3a8: 22 80 00 54 be,a 4000f4f8 <pipe_write+0x190>
4000f3ac: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
4000f3b0: f8 07 60 04 ld [ %i5 + 4 ], %i4
4000f3b4: 80 a6 80 1c cmp %i2, %i4
4000f3b8: 08 80 00 5b bleu 4000f524 <pipe_write+0x1bc> <== ALWAYS TAKEN
4000f3bc: a0 10 20 01 mov 1, %l0
4000f3c0: a2 10 20 00 clr %l1
4000f3c4: b0 10 20 00 clr %i0
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
4000f3c8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000f3cc: 84 27 00 01 sub %i4, %g1, %g2
4000f3d0: 80 a0 80 10 cmp %g2, %l0
4000f3d4: 1a 80 00 27 bcc 4000f470 <pipe_write+0x108>
4000f3d8: 86 26 80 11 sub %i2, %l1, %g3
if (LIBIO_NODELAY(iop)) {
4000f3dc: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
4000f3e0: 80 88 60 01 btst 1, %g1
4000f3e4: 32 80 00 53 bne,a 4000f530 <pipe_write+0x1c8>
4000f3e8: 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 ++;
4000f3ec: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
PIPE_UNLOCK(pipe);
4000f3f0: 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 ++;
4000f3f4: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
4000f3f8: 7f ff ea 72 call 40009dc0 <rtems_semaphore_release>
4000f3fc: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
if (! PIPE_WRITEWAIT(pipe))
4000f400: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
4000f404: 40 00 05 52 call 4001094c <rtems_barrier_wait>
4000f408: 92 10 20 00 clr %o1
4000f40c: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000f410: 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))
4000f414: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
4000f418: 92 10 20 00 clr %o1
4000f41c: 94 10 20 00 clr %o2
4000f420: 7f ff ea 19 call 40009c84 <rtems_semaphore_obtain>
4000f424: b8 0f 3f fc and %i4, -4, %i4
4000f428: 80 a2 20 00 cmp %o0, 0
4000f42c: 12 80 00 45 bne 4000f540 <pipe_write+0x1d8> <== NEVER TAKEN
4000f430: 80 a7 20 00 cmp %i4, 0
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
4000f434: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000f438: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
4000f43c: 12 80 00 3d bne 4000f530 <pipe_write+0x1c8> <== NEVER TAKEN
4000f440: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
goto out_locked;
if (pipe->Readers == 0) {
4000f444: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000f448: 80 a0 60 00 cmp %g1, 0
4000f44c: 22 80 00 2b be,a 4000f4f8 <pipe_write+0x190> <== NEVER TAKEN
4000f450: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
4000f454: f8 07 60 04 ld [ %i5 + 4 ], %i4
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
4000f458: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000f45c: 84 27 00 01 sub %i4, %g1, %g2
4000f460: 80 a0 80 10 cmp %g2, %l0
4000f464: 2a bf ff df bcs,a 4000f3e0 <pipe_write+0x78> <== NEVER TAKEN
4000f468: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1 <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
4000f46c: 86 26 80 11 sub %i2, %l1, %g3
4000f470: 80 a0 80 03 cmp %g2, %g3
4000f474: 08 80 00 03 bleu 4000f480 <pipe_write+0x118>
4000f478: a0 10 00 02 mov %g2, %l0
4000f47c: a0 10 00 03 mov %g3, %l0
chunk1 = pipe->Size - PIPE_WSTART(pipe);
4000f480: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000f484: 92 10 00 1c mov %i4, %o1
4000f488: 40 00 3f e6 call 4001f420 <.urem>
4000f48c: 90 00 40 08 add %g1, %o0, %o0
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000f490: c2 07 40 00 ld [ %i5 ], %g1
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
4000f494: b8 27 00 08 sub %i4, %o0, %i4
if (chunk > chunk1) {
4000f498: 80 a4 00 1c cmp %l0, %i4
4000f49c: 04 80 00 2d ble 4000f550 <pipe_write+0x1e8>
4000f4a0: 92 06 40 11 add %i1, %l1, %o1
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000f4a4: 94 10 00 1c mov %i4, %o2
4000f4a8: 40 00 10 d7 call 40013804 <memcpy>
4000f4ac: 90 00 40 08 add %g1, %o0, %o0
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
4000f4b0: d0 07 40 00 ld [ %i5 ], %o0
4000f4b4: 92 07 00 11 add %i4, %l1, %o1
4000f4b8: 94 24 00 1c sub %l0, %i4, %o2
4000f4bc: 40 00 10 d2 call 40013804 <memcpy>
4000f4c0: 92 06 40 09 add %i1, %o1, %o1
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
4000f4c4: c4 07 60 0c ld [ %i5 + 0xc ], %g2
if (pipe->waitingReaders > 0)
4000f4c8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
4000f4cc: 84 00 80 10 add %g2, %l0, %g2
if (pipe->waitingReaders > 0)
4000f4d0: 80 a0 60 00 cmp %g1, 0
4000f4d4: 12 80 00 24 bne 4000f564 <pipe_write+0x1fc>
4000f4d8: c4 27 60 0c st %g2, [ %i5 + 0xc ]
PIPE_WAKEUPREADERS(pipe);
written += chunk;
4000f4dc: b0 06 00 10 add %i0, %l0, %i0
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
4000f4e0: 80 a6 80 18 cmp %i2, %i0
4000f4e4: 08 80 00 12 bleu 4000f52c <pipe_write+0x1c4> <== ALWAYS TAKEN
4000f4e8: a2 10 00 18 mov %i0, %l1
4000f4ec: f8 07 60 04 ld [ %i5 + 4 ], %i4 <== NOT EXECUTED
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
written += chunk;
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
4000f4f0: 10 bf ff b6 b 4000f3c8 <pipe_write+0x60> <== NOT EXECUTED
4000f4f4: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
}
out_locked:
PIPE_UNLOCK(pipe);
4000f4f8: 7f ff ea 32 call 40009dc0 <rtems_semaphore_release>
4000f4fc: b8 10 3f e0 mov -32, %i4
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
4000f500: 40 00 01 49 call 4000fa24 <getpid>
4000f504: 01 00 00 00 nop
4000f508: 40 00 02 c8 call 40010028 <kill>
4000f50c: 92 10 20 0d mov 0xd, %o1 ! d <PROM_START+0xd>
#endif
if (written > 0)
4000f510: 80 a6 20 00 cmp %i0, 0
4000f514: 14 bf ff 9a bg 4000f37c <pipe_write+0x14>
4000f518: 01 00 00 00 nop
4000f51c: 81 c7 e0 08 ret
4000f520: 91 e8 00 1c restore %g0, %i4, %o0
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
4000f524: 10 bf ff a7 b 4000f3c0 <pipe_write+0x58>
4000f528: a0 10 00 1a mov %i2, %l0
while (written < count) {
4000f52c: b8 10 20 00 clr %i4
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
4000f530: 7f ff ea 24 call 40009dc0 <rtems_semaphore_release>
4000f534: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
4000f538: 10 bf ff f7 b 4000f514 <pipe_write+0x1ac>
4000f53c: 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;
4000f540: 10 bf ff f4 b 4000f510 <pipe_write+0x1a8> <== NOT EXECUTED
4000f544: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
4000f548: 81 c7 e0 08 ret <== NOT EXECUTED
4000f54c: 91 e8 3f fc restore %g0, -4, %o0 <== NOT EXECUTED
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4000f550: 90 00 40 08 add %g1, %o0, %o0
4000f554: 40 00 10 ac call 40013804 <memcpy>
4000f558: 94 10 00 10 mov %l0, %o2
pipe->Length += chunk;
4000f55c: 10 bf ff db b 4000f4c8 <pipe_write+0x160>
4000f560: c4 07 60 0c ld [ %i5 + 0xc ], %g2
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
4000f564: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000f568: 40 00 04 e1 call 400108ec <rtems_barrier_release>
4000f56c: 92 07 bf fc add %fp, -4, %o1
written += chunk;
4000f570: 10 bf ff dc b 4000f4e0 <pipe_write+0x178>
4000f574: b0 06 00 10 add %i0, %l0, %i0
400095cc <posix_memalign>:
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
400095cc: 05 10 00 9d sethi %hi(0x40027400), %g2
400095d0: 84 10 a0 68 or %g2, 0x68, %g2 ! 40027468 <rtems_malloc_statistics>
400095d4: c6 00 a0 08 ld [ %g2 + 8 ], %g3
400095d8: 86 00 e0 01 inc %g3
400095dc: c6 20 a0 08 st %g3, [ %g2 + 8 ]
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
400095e0: 84 02 7f ff add %o1, -1, %g2
400095e4: 80 88 80 09 btst %g2, %o1
400095e8: 02 80 00 04 be 400095f8 <posix_memalign+0x2c> <== ALWAYS TAKEN
400095ec: 80 a2 60 03 cmp %o1, 3
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
400095f0: 81 c3 e0 08 retl
400095f4: 90 10 20 16 mov 0x16, %o0
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
400095f8: 08 bf ff fe bleu 400095f0 <posix_memalign+0x24>
400095fc: 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 );
40009600: 82 13 c0 00 mov %o7, %g1
40009604: 40 00 00 89 call 40009828 <rtems_memalign>
40009608: 9e 10 40 00 mov %g1, %o7
4000d040 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
4000d040: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
4000d044: 80 a0 60 00 cmp %g1, 0
4000d048: 02 80 00 06 be 4000d060 <pthread_attr_setschedpolicy+0x20>
4000d04c: 90 10 20 16 mov 0x16, %o0
4000d050: c4 00 40 00 ld [ %g1 ], %g2
4000d054: 80 a0 a0 00 cmp %g2, 0
4000d058: 12 80 00 04 bne 4000d068 <pthread_attr_setschedpolicy+0x28>
4000d05c: 80 a2 60 04 cmp %o1, 4
return 0;
default:
return ENOTSUP;
}
}
4000d060: 81 c3 e0 08 retl
4000d064: 01 00 00 00 nop
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
4000d068: 18 80 00 09 bgu 4000d08c <pthread_attr_setschedpolicy+0x4c>
4000d06c: 84 10 20 01 mov 1, %g2 ! 1 <PROM_START+0x1>
4000d070: 85 28 80 09 sll %g2, %o1, %g2
4000d074: 80 88 a0 17 btst 0x17, %g2
4000d078: 02 80 00 05 be 4000d08c <pthread_attr_setschedpolicy+0x4c><== NEVER TAKEN
4000d07c: 01 00 00 00 nop
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
4000d080: d2 20 60 14 st %o1, [ %g1 + 0x14 ]
return 0;
4000d084: 81 c3 e0 08 retl
4000d088: 90 10 20 00 clr %o0
default:
return ENOTSUP;
}
}
4000d08c: 81 c3 e0 08 retl
4000d090: 90 10 20 86 mov 0x86, %o0
400084d4 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
400084d4: 9d e3 bf 90 save %sp, -112, %sp
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
400084d8: 80 a6 20 00 cmp %i0, 0
400084dc: 02 80 00 04 be 400084ec <pthread_barrier_init+0x18>
400084e0: 80 a6 a0 00 cmp %i2, 0
return EINVAL;
if ( count == 0 )
400084e4: 12 80 00 04 bne 400084f4 <pthread_barrier_init+0x20>
400084e8: 80 a6 60 00 cmp %i1, 0
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
_Thread_Enable_dispatch();
return 0;
}
400084ec: 81 c7 e0 08 ret
400084f0: 91 e8 20 16 restore %g0, 0x16, %o0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
400084f4: 02 80 00 23 be 40008580 <pthread_barrier_init+0xac>
400084f8: 90 07 bf f8 add %fp, -8, %o0
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
400084fc: c2 06 40 00 ld [ %i1 ], %g1
40008500: 80 a0 60 00 cmp %g1, 0
40008504: 02 bf ff fa be 400084ec <pthread_barrier_init+0x18>
40008508: 01 00 00 00 nop
return EINVAL;
switch ( the_attr->process_shared ) {
4000850c: c2 06 60 04 ld [ %i1 + 4 ], %g1
40008510: 80 a0 60 00 cmp %g1, 0
40008514: 12 bf ff f6 bne 400084ec <pthread_barrier_init+0x18> <== NEVER TAKEN
40008518: 03 10 00 65 sethi %hi(0x40019400), %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;
4000851c: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400194e0 <_Thread_Dispatch_disable_level>
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
40008520: c0 27 bf f0 clr [ %fp + -16 ]
++level;
40008524: 84 00 a0 01 inc %g2
the_attributes.maximum_count = count;
40008528: f4 27 bf f4 st %i2, [ %fp + -12 ]
_Thread_Dispatch_disable_level = level;
4000852c: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ]
* 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 *)
40008530: 39 10 00 66 sethi %hi(0x40019800), %i4
40008534: 40 00 08 ee call 4000a8ec <_Objects_Allocate>
40008538: 90 17 20 64 or %i4, 0x64, %o0 ! 40019864 <_POSIX_Barrier_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
4000853c: ba 92 20 00 orcc %o0, 0, %i5
40008540: 02 80 00 14 be 40008590 <pthread_barrier_init+0xbc>
40008544: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
40008548: 40 00 06 37 call 40009e24 <_CORE_barrier_Initialize>
4000854c: 92 07 bf f0 add %fp, -16, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40008550: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008554: b8 17 20 64 or %i4, 0x64, %i4
40008558: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
4000855c: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008560: 85 28 a0 02 sll %g2, 2, %g2
40008564: 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;
40008568: c0 27 60 0c clr [ %i5 + 0xc ]
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
4000856c: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
40008570: 40 00 0d f4 call 4000bd40 <_Thread_Enable_dispatch>
40008574: b0 10 20 00 clr %i0
40008578: 81 c7 e0 08 ret
4000857c: 81 e8 00 00 restore
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
40008580: 7f ff ff 9c call 400083f0 <pthread_barrierattr_init>
40008584: 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 )
40008588: 10 bf ff de b 40008500 <pthread_barrier_init+0x2c>
4000858c: c2 06 40 00 ld [ %i1 ], %g1
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
40008590: 40 00 0d ec call 4000bd40 <_Thread_Enable_dispatch>
40008594: b0 10 20 0b mov 0xb, %i0
40008598: 81 c7 e0 08 ret
4000859c: 81 e8 00 00 restore
40007d68 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
40007d68: 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 )
40007d6c: 80 a6 20 00 cmp %i0, 0
40007d70: 02 80 00 13 be 40007dbc <pthread_cleanup_push+0x54>
40007d74: 03 10 00 66 sethi %hi(0x40019800), %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;
40007d78: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 40019a00 <_Thread_Dispatch_disable_level>
++level;
40007d7c: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40007d80: c4 20 62 00 st %g2, [ %g1 + 0x200 ]
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
40007d84: 40 00 12 bc call 4000c874 <_Workspace_Allocate>
40007d88: 90 10 20 10 mov 0x10, %o0
if ( handler ) {
40007d8c: 80 a2 20 00 cmp %o0, 0
40007d90: 02 80 00 09 be 40007db4 <pthread_cleanup_push+0x4c> <== NEVER TAKEN
40007d94: 03 10 00 67 sethi %hi(0x40019c00), %g1
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
40007d98: c2 00 63 20 ld [ %g1 + 0x320 ], %g1 ! 40019f20 <_Per_CPU_Information+0x10>
handler_stack = &thread_support->Cancellation_Handlers;
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
40007d9c: 92 10 00 08 mov %o0, %o1
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
if ( handler ) {
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
40007da0: c2 00 61 50 ld [ %g1 + 0x150 ], %g1
handler->routine = routine;
40007da4: f0 22 20 08 st %i0, [ %o0 + 8 ]
handler->arg = arg;
40007da8: f2 22 20 0c st %i1, [ %o0 + 0xc ]
_Chain_Append( handler_stack, &handler->Node );
40007dac: 40 00 06 67 call 40009748 <_Chain_Append>
40007db0: 90 00 60 e4 add %g1, 0xe4, %o0
}
_Thread_Enable_dispatch();
40007db4: 40 00 0e 33 call 4000b680 <_Thread_Enable_dispatch>
40007db8: 81 e8 00 00 restore
40007dbc: 81 c7 e0 08 ret
40007dc0: 81 e8 00 00 restore
40008d08 <pthread_cond_init>:
*/
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
40008d08: 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;
40008d0c: 80 a6 60 00 cmp %i1, 0
40008d10: 22 80 00 27 be,a 40008dac <pthread_cond_init+0xa4>
40008d14: 33 10 00 63 sethi %hi(0x40018c00), %i1
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
40008d18: c4 06 60 04 ld [ %i1 + 4 ], %g2 ! 40018c04 <IMFS_node_control_default+0x64>
40008d1c: 80 a0 a0 01 cmp %g2, 1
40008d20: 02 80 00 06 be 40008d38 <pthread_cond_init+0x30> <== NEVER TAKEN
40008d24: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ( !the_attr->is_initialized )
40008d28: c4 06 40 00 ld [ %i1 ], %g2
40008d2c: 80 a0 a0 00 cmp %g2, 0
40008d30: 32 80 00 04 bne,a 40008d40 <pthread_cond_init+0x38>
40008d34: 03 10 00 69 sethi %hi(0x4001a400), %g1
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
40008d38: 81 c7 e0 08 ret
40008d3c: 91 e8 00 01 restore %g0, %g1, %o0
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
40008d40: c4 00 63 20 ld [ %g1 + 0x320 ], %g2
++level;
40008d44: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40008d48: c4 20 63 20 st %g2, [ %g1 + 0x320 ]
*/
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
40008d4c: 39 10 00 6a sethi %hi(0x4001a800), %i4
40008d50: 40 00 0a 9e call 4000b7c8 <_Objects_Allocate>
40008d54: 90 17 23 3c or %i4, 0x33c, %o0 ! 4001ab3c <_POSIX_Condition_variables_Information>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
40008d58: ba 92 20 00 orcc %o0, 0, %i5
40008d5c: 02 80 00 16 be 40008db4 <pthread_cond_init+0xac>
40008d60: 90 07 60 18 add %i5, 0x18, %o0
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
40008d64: c2 06 60 04 ld [ %i1 + 4 ], %g1
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
40008d68: 92 10 20 00 clr %o1
40008d6c: 15 04 00 02 sethi %hi(0x10000800), %o2
40008d70: 96 10 20 74 mov 0x74, %o3
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
40008d74: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
40008d78: 40 00 11 c8 call 4000d498 <_Thread_queue_Initialize>
40008d7c: c0 27 60 14 clr [ %i5 + 0x14 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40008d80: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008d84: b8 17 23 3c or %i4, 0x33c, %i4
40008d88: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40008d8c: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008d90: 85 28 a0 02 sll %g2, 2, %g2
40008d94: 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;
40008d98: c0 27 60 0c clr [ %i5 + 0xc ]
0
);
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
40008d9c: 40 00 0f a0 call 4000cc1c <_Thread_Enable_dispatch>
40008da0: c2 26 00 00 st %g1, [ %i0 ]
return 0;
40008da4: 10 bf ff e5 b 40008d38 <pthread_cond_init+0x30>
40008da8: 82 10 20 00 clr %g1
{
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Condition_variables_Default_attributes;
40008dac: 10 bf ff db b 40008d18 <pthread_cond_init+0x10>
40008db0: b2 16 62 dc or %i1, 0x2dc, %i1
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
_Thread_Enable_dispatch();
40008db4: 40 00 0f 9a call 4000cc1c <_Thread_Enable_dispatch>
40008db8: 01 00 00 00 nop
return ENOMEM;
40008dbc: 10 bf ff df b 40008d38 <pthread_cond_init+0x30>
40008dc0: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
40008b6c <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
40008b6c: 82 10 00 08 mov %o0, %g1
if ( !attr || attr->is_initialized == false )
40008b70: 80 a0 60 00 cmp %g1, 0
40008b74: 02 80 00 06 be 40008b8c <pthread_condattr_destroy+0x20>
40008b78: 90 10 20 16 mov 0x16, %o0
40008b7c: c4 00 40 00 ld [ %g1 ], %g2
40008b80: 80 a0 a0 00 cmp %g2, 0
40008b84: 32 80 00 04 bne,a 40008b94 <pthread_condattr_destroy+0x28><== ALWAYS TAKEN
40008b88: c0 20 40 00 clr [ %g1 ]
return EINVAL;
attr->is_initialized = false;
return 0;
}
40008b8c: 81 c3 e0 08 retl
40008b90: 01 00 00 00 nop
40008b94: 81 c3 e0 08 retl
40008b98: 90 10 20 00 clr %o0 ! 0 <PROM_START>
40008214 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
40008214: 9d e3 bf 58 save %sp, -168, %sp
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
40008218: 80 a6 a0 00 cmp %i2, 0
4000821c: 02 80 00 0a be 40008244 <pthread_create+0x30>
40008220: ba 10 20 0e mov 0xe, %i5
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
40008224: 80 a6 60 00 cmp %i1, 0
40008228: 22 80 00 63 be,a 400083b4 <pthread_create+0x1a0>
4000822c: 33 10 00 7c sethi %hi(0x4001f000), %i1
if ( !the_attr->is_initialized )
40008230: c2 06 40 00 ld [ %i1 ], %g1
40008234: 80 a0 60 00 cmp %g1, 0
40008238: 32 80 00 05 bne,a 4000824c <pthread_create+0x38>
4000823c: c2 06 60 04 ld [ %i1 + 4 ], %g1
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
40008240: ba 10 20 16 mov 0x16, %i5
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
40008244: 81 c7 e0 08 ret
40008248: 91 e8 00 1d restore %g0, %i5, %o0
* stack space if it is allowed to allocate it itself.
*
* NOTE: If the user provides the stack we will let it drop below
* twice the minimum.
*/
if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
4000824c: 80 a0 60 00 cmp %g1, 0
40008250: 02 80 00 07 be 4000826c <pthread_create+0x58>
40008254: 03 10 00 80 sethi %hi(0x40020000), %g1
40008258: c4 06 60 08 ld [ %i1 + 8 ], %g2
4000825c: c2 00 60 00 ld [ %g1 ], %g1
40008260: 80 a0 80 01 cmp %g2, %g1
40008264: 0a bf ff f8 bcs 40008244 <pthread_create+0x30>
40008268: ba 10 20 16 mov 0x16, %i5
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
4000826c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40008270: 80 a0 60 01 cmp %g1, 1
40008274: 02 80 00 52 be 400083bc <pthread_create+0x1a8>
40008278: 80 a0 60 02 cmp %g1, 2
4000827c: 32 bf ff f2 bne,a 40008244 <pthread_create+0x30>
40008280: ba 10 20 16 mov 0x16, %i5
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
40008284: da 06 60 18 ld [ %i1 + 0x18 ], %o5
40008288: de 06 60 1c ld [ %i1 + 0x1c ], %o7
4000828c: fa 06 60 20 ld [ %i1 + 0x20 ], %i5
40008290: c8 06 60 24 ld [ %i1 + 0x24 ], %g4
40008294: c6 06 60 28 ld [ %i1 + 0x28 ], %g3
40008298: c4 06 60 2c ld [ %i1 + 0x2c ], %g2
4000829c: c2 06 60 30 ld [ %i1 + 0x30 ], %g1
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
400082a0: f8 06 60 14 ld [ %i1 + 0x14 ], %i4
schedparam = the_attr->schedparam;
400082a4: da 27 bf e4 st %o5, [ %fp + -28 ]
400082a8: de 27 bf e8 st %o7, [ %fp + -24 ]
400082ac: fa 27 bf ec st %i5, [ %fp + -20 ]
400082b0: c8 27 bf f0 st %g4, [ %fp + -16 ]
400082b4: c6 27 bf f4 st %g3, [ %fp + -12 ]
400082b8: c4 27 bf f8 st %g2, [ %fp + -8 ]
400082bc: c2 27 bf fc st %g1, [ %fp + -4 ]
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
400082c0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400082c4: 80 a0 60 00 cmp %g1, 0
400082c8: 12 bf ff df bne 40008244 <pthread_create+0x30>
400082cc: ba 10 20 86 mov 0x86, %i5
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
400082d0: 40 00 1a 17 call 4000eb2c <_POSIX_Priority_Is_valid>
400082d4: d0 07 bf e4 ld [ %fp + -28 ], %o0
400082d8: 80 8a 20 ff btst 0xff, %o0
400082dc: 02 bf ff da be 40008244 <pthread_create+0x30> <== NEVER TAKEN
400082e0: 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);
400082e4: 03 10 00 7f sethi %hi(0x4001fc00), %g1
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
400082e8: e0 07 bf e4 ld [ %fp + -28 ], %l0
400082ec: e8 08 63 fc ldub [ %g1 + 0x3fc ], %l4
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
400082f0: 90 10 00 1c mov %i4, %o0
400082f4: 92 07 bf e4 add %fp, -28, %o1
400082f8: 94 07 bf dc add %fp, -36, %o2
400082fc: 40 00 1a 19 call 4000eb60 <_POSIX_Thread_Translate_sched_param>
40008300: 96 07 bf e0 add %fp, -32, %o3
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
40008304: ba 92 20 00 orcc %o0, 0, %i5
40008308: 12 bf ff cf bne 40008244 <pthread_create+0x30>
4000830c: 25 10 00 83 sethi %hi(0x40020c00), %l2
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
40008310: d0 04 a2 20 ld [ %l2 + 0x220 ], %o0 ! 40020e20 <_RTEMS_Allocator_Mutex>
40008314: 40 00 06 99 call 40009d78 <_API_Mutex_Lock>
40008318: 27 10 00 83 sethi %hi(0x40020c00), %l3
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
4000831c: 40 00 09 70 call 4000a8dc <_Objects_Allocate>
40008320: 90 14 e3 a4 or %l3, 0x3a4, %o0 ! 40020fa4 <_POSIX_Threads_Information>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
40008324: a2 92 20 00 orcc %o0, 0, %l1
40008328: 02 80 00 1f be 400083a4 <pthread_create+0x190>
4000832c: 05 10 00 80 sethi %hi(0x40020000), %g2
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
40008330: c2 06 60 08 ld [ %i1 + 8 ], %g1
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
40008334: d6 00 a0 00 ld [ %g2 ], %o3
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
40008338: c0 27 bf d4 clr [ %fp + -44 ]
4000833c: 97 2a e0 01 sll %o3, 1, %o3
40008340: 80 a2 c0 01 cmp %o3, %g1
40008344: 1a 80 00 03 bcc 40008350 <pthread_create+0x13c>
40008348: d4 06 60 04 ld [ %i1 + 4 ], %o2
4000834c: 96 10 00 01 mov %g1, %o3
40008350: c2 07 bf dc ld [ %fp + -36 ], %g1
40008354: 9a 0d 20 ff and %l4, 0xff, %o5
40008358: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
4000835c: 82 10 20 01 mov 1, %g1
40008360: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40008364: c2 07 bf e0 ld [ %fp + -32 ], %g1
40008368: c0 23 a0 68 clr [ %sp + 0x68 ]
4000836c: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
40008370: 82 07 bf d4 add %fp, -44, %g1
40008374: 90 14 e3 a4 or %l3, 0x3a4, %o0
40008378: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
4000837c: 92 10 00 11 mov %l1, %o1
40008380: 98 10 20 00 clr %o4
40008384: 40 00 0e a2 call 4000be0c <_Thread_Initialize>
40008388: 9a 23 40 10 sub %o5, %l0, %o5
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
4000838c: 80 8a 20 ff btst 0xff, %o0
40008390: 12 80 00 1e bne 40008408 <pthread_create+0x1f4>
40008394: 11 10 00 83 sethi %hi(0x40020c00), %o0
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
40008398: 92 10 00 11 mov %l1, %o1
4000839c: 40 00 0a 48 call 4000acbc <_Objects_Free>
400083a0: 90 12 23 a4 or %o0, 0x3a4, %o0
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
400083a4: d0 04 a2 20 ld [ %l2 + 0x220 ], %o0
400083a8: 40 00 06 89 call 40009dcc <_API_Mutex_Unlock>
400083ac: ba 10 20 0b mov 0xb, %i5
400083b0: 30 bf ff a5 b,a 40008244 <pthread_create+0x30>
int rc;
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
400083b4: 10 bf ff 9f b 40008230 <pthread_create+0x1c>
400083b8: b2 16 63 dc or %i1, 0x3dc, %i1
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
400083bc: 03 10 00 84 sethi %hi(0x40021000), %g1
400083c0: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 400212c0 <_Per_CPU_Information+0x10>
400083c4: c2 00 61 50 ld [ %g1 + 0x150 ], %g1
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
400083c8: d8 00 60 88 ld [ %g1 + 0x88 ], %o4
400083cc: da 00 60 8c ld [ %g1 + 0x8c ], %o5
400083d0: de 00 60 90 ld [ %g1 + 0x90 ], %o7
400083d4: fa 00 60 94 ld [ %g1 + 0x94 ], %i5
400083d8: c8 00 60 98 ld [ %g1 + 0x98 ], %g4
400083dc: c6 00 60 9c ld [ %g1 + 0x9c ], %g3
400083e0: c4 00 60 a0 ld [ %g1 + 0xa0 ], %g2
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
schedpolicy = api->schedpolicy;
400083e4: f8 00 60 84 ld [ %g1 + 0x84 ], %i4
schedparam = api->schedparam;
400083e8: d8 27 bf e4 st %o4, [ %fp + -28 ]
400083ec: da 27 bf e8 st %o5, [ %fp + -24 ]
400083f0: de 27 bf ec st %o7, [ %fp + -20 ]
400083f4: fa 27 bf f0 st %i5, [ %fp + -16 ]
400083f8: c8 27 bf f4 st %g4, [ %fp + -12 ]
400083fc: c6 27 bf f8 st %g3, [ %fp + -8 ]
break;
40008400: 10 bf ff b0 b 400082c0 <pthread_create+0xac>
40008404: c4 27 bf fc st %g2, [ %fp + -4 ]
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40008408: e0 04 61 50 ld [ %l1 + 0x150 ], %l0
api->Attributes = *the_attr;
4000840c: 92 10 00 19 mov %i1, %o1
40008410: 94 10 20 40 mov 0x40, %o2
40008414: 40 00 25 ed call 40011bc8 <memcpy>
40008418: 90 10 00 10 mov %l0, %o0
api->detachstate = the_attr->detachstate;
4000841c: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
40008420: 92 07 bf e4 add %fp, -28, %o1
40008424: 94 10 20 1c mov 0x1c, %o2
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
40008428: c2 24 20 40 st %g1, [ %l0 + 0x40 ]
api->schedpolicy = schedpolicy;
4000842c: f8 24 20 84 st %i4, [ %l0 + 0x84 ]
api->schedparam = schedparam;
40008430: 40 00 25 e6 call 40011bc8 <memcpy>
40008434: 90 04 20 88 add %l0, 0x88, %o0
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
40008438: 90 10 00 11 mov %l1, %o0
4000843c: 92 10 20 01 mov 1, %o1
40008440: 94 10 00 1a mov %i2, %o2
40008444: 96 10 00 1b mov %i3, %o3
40008448: 40 00 10 d3 call 4000c794 <_Thread_Start>
4000844c: 98 10 20 00 clr %o4
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
40008450: 80 a7 20 04 cmp %i4, 4
40008454: 02 80 00 07 be 40008470 <pthread_create+0x25c>
40008458: 01 00 00 00 nop
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
4000845c: c2 04 60 08 ld [ %l1 + 8 ], %g1
_RTEMS_Unlock_allocator();
40008460: d0 04 a2 20 ld [ %l2 + 0x220 ], %o0
40008464: 40 00 06 5a call 40009dcc <_API_Mutex_Unlock>
40008468: c2 26 00 00 st %g1, [ %i0 ]
4000846c: 30 bf ff 76 b,a 40008244 <pthread_create+0x30>
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
40008470: 40 00 10 f3 call 4000c83c <_Timespec_To_ticks>
40008474: 90 04 20 90 add %l0, 0x90, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40008478: 92 04 20 a8 add %l0, 0xa8, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4000847c: d0 24 20 b4 st %o0, [ %l0 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40008480: 11 10 00 83 sethi %hi(0x40020c00), %o0
40008484: 40 00 11 a8 call 4000cb24 <_Watchdog_Insert>
40008488: 90 12 22 38 or %o0, 0x238, %o0 ! 40020e38 <_Watchdog_Ticks_chain>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
4000848c: 10 bf ff f5 b 40008460 <pthread_create+0x24c>
40008490: c2 04 60 08 ld [ %l1 + 8 ], %g1
4001d05c <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
4001d05c: 9d e3 bf 98 save %sp, -104, %sp
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
4001d060: 80 a6 60 00 cmp %i1, 0
4001d064: 02 80 00 31 be 4001d128 <pthread_kill+0xcc>
4001d068: b8 06 7f ff add %i1, -1, %i4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
4001d06c: 80 a7 20 1f cmp %i4, 0x1f
4001d070: 18 80 00 2e bgu 4001d128 <pthread_kill+0xcc>
4001d074: 90 10 00 18 mov %i0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
4001d078: 7f ff b8 20 call 4000b0f8 <_Thread_Get>
4001d07c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4001d080: c2 07 bf fc ld [ %fp + -4 ], %g1
4001d084: 80 a0 60 00 cmp %g1, 0
4001d088: 12 80 00 2e bne 4001d140 <pthread_kill+0xe4> <== NEVER TAKEN
4001d08c: ba 10 00 08 mov %o0, %i5
4001d090: 11 10 00 7d sethi %hi(0x4001f400), %o0
4001d094: 7f ff af b9 call 40008f78 <_API_extensions_Add_post_switch>
4001d098: 90 12 22 ac or %o0, 0x2ac, %o0 ! 4001f6ac <_POSIX_signals_Post_switch>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
4001d09c: 83 2e 60 02 sll %i1, 2, %g1
4001d0a0: 85 2e 60 04 sll %i1, 4, %g2
4001d0a4: 84 20 80 01 sub %g2, %g1, %g2
4001d0a8: 03 10 00 82 sethi %hi(0x40020800), %g1
4001d0ac: 82 10 60 20 or %g1, 0x20, %g1 ! 40020820 <_POSIX_signals_Vectors>
4001d0b0: 82 00 40 02 add %g1, %g2, %g1
4001d0b4: c4 00 60 08 ld [ %g1 + 8 ], %g2
4001d0b8: 80 a0 a0 01 cmp %g2, 1
4001d0bc: 02 80 00 15 be 4001d110 <pthread_kill+0xb4>
4001d0c0: c2 07 61 50 ld [ %i5 + 0x150 ], %g1
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
4001d0c4: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2
4001d0c8: b6 10 20 01 mov 1, %i3
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4001d0cc: 90 10 00 1d mov %i5, %o0
4001d0d0: b9 2e c0 1c sll %i3, %i4, %i4
4001d0d4: 92 10 00 19 mov %i1, %o1
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
4001d0d8: b8 10 80 1c or %g2, %i4, %i4
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4001d0dc: 94 10 20 00 clr %o2
4001d0e0: 7f ff ff 86 call 4001cef8 <_POSIX_signals_Unblock_thread>
4001d0e4: f8 20 60 d4 st %i4, [ %g1 + 0xd4 ]
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001d0e8: 03 10 00 81 sethi %hi(0x40020400), %g1
4001d0ec: 82 10 63 c0 or %g1, 0x3c0, %g1 ! 400207c0 <_Per_CPU_Information>
4001d0f0: c4 00 60 08 ld [ %g1 + 8 ], %g2
4001d0f4: 80 a0 a0 00 cmp %g2, 0
4001d0f8: 02 80 00 06 be 4001d110 <pthread_kill+0xb4>
4001d0fc: 01 00 00 00 nop
4001d100: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4001d104: 80 a7 40 02 cmp %i5, %g2
4001d108: 02 80 00 06 be 4001d120 <pthread_kill+0xc4>
4001d10c: 01 00 00 00 nop
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
_Thread_Enable_dispatch();
4001d110: 7f ff b7 ee call 4000b0c8 <_Thread_Enable_dispatch>
4001d114: b0 10 20 00 clr %i0 ! 0 <PROM_START>
4001d118: 81 c7 e0 08 ret
4001d11c: 81 e8 00 00 restore
api->signals_pending |= signo_to_mask( sig );
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
4001d120: f6 28 60 0c stb %i3, [ %g1 + 0xc ]
4001d124: 30 bf ff fb b,a 4001d110 <pthread_kill+0xb4>
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
4001d128: 7f ff ce 06 call 40010940 <__errno>
4001d12c: b0 10 3f ff mov -1, %i0
4001d130: 82 10 20 16 mov 0x16, %g1
4001d134: c2 22 00 00 st %g1, [ %o0 ]
4001d138: 81 c7 e0 08 ret
4001d13c: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
4001d140: 7f ff ce 00 call 40010940 <__errno> <== NOT EXECUTED
4001d144: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001d148: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED
4001d14c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
4001d150: 81 c7 e0 08 ret <== NOT EXECUTED
4001d154: 81 e8 00 00 restore <== NOT EXECUTED
4000a254 <pthread_mutex_timedlock>:
*/
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
4000a254: 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 );
4000a258: 90 10 00 19 mov %i1, %o0
4000a25c: 40 00 00 38 call 4000a33c <_POSIX_Absolute_timeout_to_ticks>
4000a260: 92 07 bf fc add %fp, -4, %o1
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
4000a264: 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 );
4000a268: ba 10 00 08 mov %o0, %i5
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
4000a26c: 80 a7 60 03 cmp %i5, 3
4000a270: 02 80 00 0c be 4000a2a0 <pthread_mutex_timedlock+0x4c>
4000a274: 90 10 00 18 mov %i0, %o0
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
4000a278: 7f ff ff bd call 4000a16c <_POSIX_Mutex_Lock_support>
4000a27c: 92 10 20 00 clr %o1
* This service only gives us the option to block. We used a polling
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
4000a280: 80 a2 20 10 cmp %o0, 0x10
4000a284: 12 80 00 0a bne 4000a2ac <pthread_mutex_timedlock+0x58>
4000a288: b0 10 00 08 mov %o0, %i0
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
4000a28c: 80 a7 60 00 cmp %i5, 0
4000a290: 12 80 00 09 bne 4000a2b4 <pthread_mutex_timedlock+0x60> <== ALWAYS TAKEN
4000a294: ba 07 7f ff add %i5, -1, %i5
return EINVAL;
4000a298: 81 c7 e0 08 ret <== NOT EXECUTED
4000a29c: 91 e8 20 16 restore %g0, 0x16, %o0 <== NOT EXECUTED
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
4000a2a0: 7f ff ff b3 call 4000a16c <_POSIX_Mutex_Lock_support>
4000a2a4: 92 10 20 01 mov 1, %o1
4000a2a8: b0 10 00 08 mov %o0, %i0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
4000a2ac: 81 c7 e0 08 ret
4000a2b0: 81 e8 00 00 restore
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
4000a2b4: 80 a7 60 01 cmp %i5, 1
4000a2b8: 18 bf ff fd bgu 4000a2ac <pthread_mutex_timedlock+0x58> <== NEVER TAKEN
4000a2bc: 01 00 00 00 nop
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
4000a2c0: 81 c7 e0 08 ret
4000a2c4: 91 e8 20 74 restore %g0, 0x74, %o0
40007c34 <pthread_mutexattr_gettype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
40007c34: 82 10 00 08 mov %o0, %g1
if ( !attr )
40007c38: 80 a0 60 00 cmp %g1, 0
40007c3c: 02 80 00 06 be 40007c54 <pthread_mutexattr_gettype+0x20>
40007c40: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
40007c44: c4 00 40 00 ld [ %g1 ], %g2
40007c48: 80 a0 a0 00 cmp %g2, 0
40007c4c: 12 80 00 04 bne 40007c5c <pthread_mutexattr_gettype+0x28>
40007c50: 80 a2 60 00 cmp %o1, 0
if ( !type )
return EINVAL;
*type = attr->type;
return 0;
}
40007c54: 81 c3 e0 08 retl
40007c58: 01 00 00 00 nop
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
if ( !type )
40007c5c: 02 bf ff fe be 40007c54 <pthread_mutexattr_gettype+0x20> <== NEVER TAKEN
40007c60: 01 00 00 00 nop
return EINVAL;
*type = attr->type;
40007c64: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
return 0;
40007c68: 90 10 20 00 clr %o0
}
40007c6c: 81 c3 e0 08 retl
40007c70: c2 22 40 00 st %g1, [ %o1 ]
40009e20 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
40009e20: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
40009e24: 80 a0 60 00 cmp %g1, 0
40009e28: 02 80 00 06 be 40009e40 <pthread_mutexattr_setpshared+0x20>
40009e2c: 90 10 20 16 mov 0x16, %o0
40009e30: c4 00 40 00 ld [ %g1 ], %g2
40009e34: 80 a0 a0 00 cmp %g2, 0
40009e38: 12 80 00 04 bne 40009e48 <pthread_mutexattr_setpshared+0x28>
40009e3c: 80 a2 60 01 cmp %o1, 1
return 0;
default:
return EINVAL;
}
}
40009e40: 81 c3 e0 08 retl
40009e44: 01 00 00 00 nop
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
40009e48: 18 bf ff fe bgu 40009e40 <pthread_mutexattr_setpshared+0x20><== NEVER TAKEN
40009e4c: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
40009e50: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
default:
return EINVAL;
}
}
40009e54: 81 c3 e0 08 retl
40009e58: 90 10 20 00 clr %o0
40007cc8 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
40007cc8: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
40007ccc: 80 a0 60 00 cmp %g1, 0
40007cd0: 02 80 00 06 be 40007ce8 <pthread_mutexattr_settype+0x20>
40007cd4: 90 10 20 16 mov 0x16, %o0
40007cd8: c4 00 40 00 ld [ %g1 ], %g2
40007cdc: 80 a0 a0 00 cmp %g2, 0
40007ce0: 12 80 00 04 bne 40007cf0 <pthread_mutexattr_settype+0x28> <== ALWAYS TAKEN
40007ce4: 80 a2 60 03 cmp %o1, 3
return 0;
default:
return EINVAL;
}
}
40007ce8: 81 c3 e0 08 retl
40007cec: 01 00 00 00 nop
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( type ) {
40007cf0: 18 bf ff fe bgu 40007ce8 <pthread_mutexattr_settype+0x20>
40007cf4: 01 00 00 00 nop
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
40007cf8: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
default:
return EINVAL;
}
}
40007cfc: 81 c3 e0 08 retl
40007d00: 90 10 20 00 clr %o0
40008948 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
40008948: 9d e3 bf 98 save %sp, -104, %sp
if ( !once_control || !init_routine )
4000894c: 80 a6 60 00 cmp %i1, 0
40008950: 12 80 00 05 bne 40008964 <pthread_once+0x1c>
40008954: 80 a6 20 00 cmp %i0, 0
return EINVAL;
40008958: 82 10 20 16 mov 0x16, %g1
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
4000895c: 81 c7 e0 08 ret
40008960: 91 e8 00 01 restore %g0, %g1, %o0
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
40008964: 22 bf ff fe be,a 4000895c <pthread_once+0x14>
40008968: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ( !once_control->init_executed ) {
4000896c: c4 06 20 04 ld [ %i0 + 4 ], %g2
40008970: 80 a0 a0 00 cmp %g2, 0
40008974: 12 bf ff fa bne 4000895c <pthread_once+0x14>
40008978: 82 10 20 00 clr %g1
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
4000897c: 90 10 21 00 mov 0x100, %o0
40008980: 92 10 21 00 mov 0x100, %o1
40008984: 40 00 03 21 call 40009608 <rtems_task_mode>
40008988: 94 07 bf fc add %fp, -4, %o2
if ( !once_control->init_executed ) {
4000898c: c2 06 20 04 ld [ %i0 + 4 ], %g1
40008990: 80 a0 60 00 cmp %g1, 0
40008994: 02 80 00 09 be 400089b8 <pthread_once+0x70> <== ALWAYS TAKEN
40008998: 82 10 20 01 mov 1, %g1
once_control->is_initialized = true;
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
4000899c: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
400089a0: 92 10 21 00 mov 0x100, %o1
400089a4: 40 00 03 19 call 40009608 <rtems_task_mode>
400089a8: 94 07 bf fc add %fp, -4, %o2
}
return 0;
400089ac: 82 10 20 00 clr %g1
}
400089b0: 81 c7 e0 08 ret
400089b4: 91 e8 00 01 restore %g0, %g1, %o0
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( !once_control->init_executed ) {
once_control->is_initialized = true;
400089b8: c2 26 00 00 st %g1, [ %i0 ]
once_control->init_executed = true;
(*init_routine)();
400089bc: 9f c6 40 00 call %i1
400089c0: c2 26 20 04 st %g1, [ %i0 + 4 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
400089c4: 10 bf ff f7 b 400089a0 <pthread_once+0x58>
400089c8: d0 07 bf fc ld [ %fp + -4 ], %o0
40008b90 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
40008b90: 9d e3 bf 90 save %sp, -112, %sp
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
40008b94: 80 a6 20 00 cmp %i0, 0
40008b98: 02 80 00 08 be 40008bb8 <pthread_rwlock_init+0x28>
40008b9c: 80 a6 60 00 cmp %i1, 0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
40008ba0: 02 80 00 23 be 40008c2c <pthread_rwlock_init+0x9c>
40008ba4: 90 07 bf f8 add %fp, -8, %o0
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
40008ba8: c2 06 40 00 ld [ %i1 ], %g1
40008bac: 80 a0 60 00 cmp %g1, 0
40008bb0: 32 80 00 04 bne,a 40008bc0 <pthread_rwlock_init+0x30> <== ALWAYS TAKEN
40008bb4: c2 06 60 04 ld [ %i1 + 4 ], %g1
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
40008bb8: 81 c7 e0 08 ret
40008bbc: 91 e8 20 16 restore %g0, 0x16, %o0
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
return EINVAL;
switch ( the_attr->process_shared ) {
40008bc0: 80 a0 60 00 cmp %g1, 0
40008bc4: 12 bf ff fd bne 40008bb8 <pthread_rwlock_init+0x28> <== NEVER TAKEN
40008bc8: 03 10 00 93 sethi %hi(0x40024c00), %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;
40008bcc: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 40024cb0 <_Thread_Dispatch_disable_level>
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
40008bd0: c0 27 bf f4 clr [ %fp + -12 ]
++level;
40008bd4: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40008bd8: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ]
* 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 *)
40008bdc: 39 10 00 93 sethi %hi(0x40024c00), %i4
40008be0: 40 00 0b 14 call 4000b830 <_Objects_Allocate>
40008be4: 90 17 22 b4 or %i4, 0x2b4, %o0 ! 40024eb4 <_POSIX_RWLock_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
40008be8: ba 92 20 00 orcc %o0, 0, %i5
40008bec: 02 80 00 14 be 40008c3c <pthread_rwlock_init+0xac>
40008bf0: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
40008bf4: 40 00 09 5f call 4000b170 <_CORE_RWLock_Initialize>
40008bf8: 92 07 bf f4 add %fp, -12, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40008bfc: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008c00: b8 17 22 b4 or %i4, 0x2b4, %i4
40008c04: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40008c08: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40008c0c: 85 28 a0 02 sll %g2, 2, %g2
40008c10: 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;
40008c14: c0 27 60 0c clr [ %i5 + 0xc ]
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
40008c18: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
40008c1c: 40 00 10 51 call 4000cd60 <_Thread_Enable_dispatch>
40008c20: b0 10 20 00 clr %i0
40008c24: 81 c7 e0 08 ret
40008c28: 81 e8 00 00 restore
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
40008c2c: 40 00 01 b6 call 40009304 <pthread_rwlockattr_init>
40008c30: 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 )
40008c34: 10 bf ff de b 40008bac <pthread_rwlock_init+0x1c>
40008c38: c2 06 40 00 ld [ %i1 ], %g1
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
_Thread_Enable_dispatch();
40008c3c: 40 00 10 49 call 4000cd60 <_Thread_Enable_dispatch>
40008c40: b0 10 20 0b mov 0xb, %i0
40008c44: 81 c7 e0 08 ret
40008c48: 81 e8 00 00 restore
400091a0 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
400091a0: 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 )
400091a4: 80 a6 20 00 cmp %i0, 0
400091a8: 02 80 00 25 be 4000923c <pthread_rwlock_timedrdlock+0x9c>
400091ac: 92 07 bf fc add %fp, -4, %o1
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
400091b0: 40 00 1a b0 call 4000fc70 <_POSIX_Absolute_timeout_to_ticks>
400091b4: 90 10 00 19 mov %i1, %o0
400091b8: d2 06 00 00 ld [ %i0 ], %o1
400091bc: ba 10 00 08 mov %o0, %i5
400091c0: 94 07 bf f8 add %fp, -8, %o2
400091c4: 11 10 00 6f sethi %hi(0x4001bc00), %o0
400091c8: 40 00 0b b8 call 4000c0a8 <_Objects_Get>
400091cc: 90 12 21 94 or %o0, 0x194, %o0 ! 4001bd94 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
400091d0: c2 07 bf f8 ld [ %fp + -8 ], %g1
400091d4: 80 a0 60 00 cmp %g1, 0
400091d8: 32 80 00 1a bne,a 40009240 <pthread_rwlock_timedrdlock+0xa0>
400091dc: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
400091e0: d2 06 00 00 ld [ %i0 ], %o1
400091e4: 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 )
400091e8: 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(
400091ec: 90 02 20 10 add %o0, 0x10, %o0
400091f0: 80 a0 00 01 cmp %g0, %g1
400091f4: 98 10 20 00 clr %o4
400091f8: b8 60 3f ff subx %g0, -1, %i4
400091fc: 40 00 07 f6 call 4000b1d4 <_CORE_RWLock_Obtain_for_reading>
40009200: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
40009204: 40 00 0f 60 call 4000cf84 <_Thread_Enable_dispatch>
40009208: 01 00 00 00 nop
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
4000920c: 03 10 00 70 sethi %hi(0x4001c000), %g1
40009210: c2 00 60 f0 ld [ %g1 + 0xf0 ], %g1 ! 4001c0f0 <_Per_CPU_Information+0x10>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
40009214: 80 a7 20 00 cmp %i4, 0
40009218: 12 80 00 05 bne 4000922c <pthread_rwlock_timedrdlock+0x8c>
4000921c: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
40009220: 80 a2 20 02 cmp %o0, 2
40009224: 02 80 00 09 be 40009248 <pthread_rwlock_timedrdlock+0xa8>
40009228: 80 a7 60 00 cmp %i5, 0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
4000922c: 40 00 00 3f call 40009328 <_POSIX_RWLock_Translate_core_RWLock_return_code>
40009230: 01 00 00 00 nop
40009234: 81 c7 e0 08 ret
40009238: 91 e8 00 08 restore %g0, %o0, %o0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
4000923c: b0 10 20 16 mov 0x16, %i0
}
40009240: 81 c7 e0 08 ret
40009244: 81 e8 00 00 restore
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
40009248: 22 bf ff fe be,a 40009240 <pthread_rwlock_timedrdlock+0xa0><== NEVER TAKEN
4000924c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
40009250: ba 07 7f ff add %i5, -1, %i5
40009254: 80 a7 60 01 cmp %i5, 1
40009258: 18 bf ff f5 bgu 4000922c <pthread_rwlock_timedrdlock+0x8c><== NEVER TAKEN
4000925c: b0 10 20 74 mov 0x74, %i0
40009260: 30 bf ff f8 b,a 40009240 <pthread_rwlock_timedrdlock+0xa0>
40009264 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
40009264: 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 )
40009268: 80 a6 20 00 cmp %i0, 0
4000926c: 02 80 00 25 be 40009300 <pthread_rwlock_timedwrlock+0x9c>
40009270: 92 07 bf fc add %fp, -4, %o1
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
40009274: 40 00 1a 7f call 4000fc70 <_POSIX_Absolute_timeout_to_ticks>
40009278: 90 10 00 19 mov %i1, %o0
4000927c: d2 06 00 00 ld [ %i0 ], %o1
40009280: ba 10 00 08 mov %o0, %i5
40009284: 94 07 bf f8 add %fp, -8, %o2
40009288: 11 10 00 6f sethi %hi(0x4001bc00), %o0
4000928c: 40 00 0b 87 call 4000c0a8 <_Objects_Get>
40009290: 90 12 21 94 or %o0, 0x194, %o0 ! 4001bd94 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
40009294: c2 07 bf f8 ld [ %fp + -8 ], %g1
40009298: 80 a0 60 00 cmp %g1, 0
4000929c: 32 80 00 1a bne,a 40009304 <pthread_rwlock_timedwrlock+0xa0>
400092a0: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
400092a4: d2 06 00 00 ld [ %i0 ], %o1
400092a8: 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 )
400092ac: 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(
400092b0: 90 02 20 10 add %o0, 0x10, %o0
400092b4: 80 a0 00 01 cmp %g0, %g1
400092b8: 98 10 20 00 clr %o4
400092bc: b8 60 3f ff subx %g0, -1, %i4
400092c0: 40 00 07 fa call 4000b2a8 <_CORE_RWLock_Obtain_for_writing>
400092c4: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
400092c8: 40 00 0f 2f call 4000cf84 <_Thread_Enable_dispatch>
400092cc: 01 00 00 00 nop
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
400092d0: 03 10 00 70 sethi %hi(0x4001c000), %g1
400092d4: c2 00 60 f0 ld [ %g1 + 0xf0 ], %g1 ! 4001c0f0 <_Per_CPU_Information+0x10>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
400092d8: 80 a7 20 00 cmp %i4, 0
400092dc: 12 80 00 05 bne 400092f0 <pthread_rwlock_timedwrlock+0x8c>
400092e0: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
400092e4: 80 a2 20 02 cmp %o0, 2
400092e8: 02 80 00 09 be 4000930c <pthread_rwlock_timedwrlock+0xa8>
400092ec: 80 a7 60 00 cmp %i5, 0
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
400092f0: 40 00 00 0e call 40009328 <_POSIX_RWLock_Translate_core_RWLock_return_code>
400092f4: 01 00 00 00 nop
400092f8: 81 c7 e0 08 ret
400092fc: 91 e8 00 08 restore %g0, %o0, %o0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
40009300: b0 10 20 16 mov 0x16, %i0
}
40009304: 81 c7 e0 08 ret
40009308: 81 e8 00 00 restore
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
4000930c: 22 bf ff fe be,a 40009304 <pthread_rwlock_timedwrlock+0xa0><== NEVER TAKEN
40009310: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
40009314: ba 07 7f ff add %i5, -1, %i5
40009318: 80 a7 60 01 cmp %i5, 1
4000931c: 18 bf ff f5 bgu 400092f0 <pthread_rwlock_timedwrlock+0x8c><== NEVER TAKEN
40009320: b0 10 20 74 mov 0x74, %i0
40009324: 30 bf ff f8 b,a 40009304 <pthread_rwlock_timedwrlock+0xa0>
40009b40 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
40009b40: 82 10 00 08 mov %o0, %g1
if ( !attr )
40009b44: 80 a0 60 00 cmp %g1, 0
40009b48: 02 80 00 06 be 40009b60 <pthread_rwlockattr_setpshared+0x20>
40009b4c: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
40009b50: c4 00 40 00 ld [ %g1 ], %g2
40009b54: 80 a0 a0 00 cmp %g2, 0
40009b58: 12 80 00 04 bne 40009b68 <pthread_rwlockattr_setpshared+0x28>
40009b5c: 80 a2 60 01 cmp %o1, 1
return 0;
default:
return EINVAL;
}
}
40009b60: 81 c3 e0 08 retl
40009b64: 01 00 00 00 nop
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
40009b68: 18 bf ff fe bgu 40009b60 <pthread_rwlockattr_setpshared+0x20><== NEVER TAKEN
40009b6c: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
40009b70: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
default:
return EINVAL;
}
}
40009b74: 81 c3 e0 08 retl
40009b78: 90 10 20 00 clr %o0
4000ac00 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
4000ac00: 9d e3 bf 90 save %sp, -112, %sp
int rc;
/*
* Check all the parameters
*/
if ( !param )
4000ac04: 80 a6 a0 00 cmp %i2, 0
4000ac08: 02 80 00 0a be 4000ac30 <pthread_setschedparam+0x30>
4000ac0c: ba 10 20 16 mov 0x16, %i5
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
4000ac10: 90 10 00 19 mov %i1, %o0
4000ac14: 92 10 00 1a mov %i2, %o1
4000ac18: 94 07 bf f4 add %fp, -12, %o2
4000ac1c: 40 00 18 82 call 40010e24 <_POSIX_Thread_Translate_sched_param>
4000ac20: 96 07 bf f8 add %fp, -8, %o3
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
4000ac24: ba 92 20 00 orcc %o0, 0, %i5
4000ac28: 02 80 00 05 be 4000ac3c <pthread_setschedparam+0x3c>
4000ac2c: 90 10 00 18 mov %i0, %o0
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
4000ac30: b0 10 00 1d mov %i5, %i0
4000ac34: 81 c7 e0 08 ret
4000ac38: 81 e8 00 00 restore
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
4000ac3c: 40 00 0c b3 call 4000df08 <_Thread_Get>
4000ac40: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000ac44: c2 07 bf fc ld [ %fp + -4 ], %g1
4000ac48: 80 a0 60 00 cmp %g1, 0
4000ac4c: 12 80 00 2b bne 4000acf8 <pthread_setschedparam+0xf8>
4000ac50: b6 10 00 08 mov %o0, %i3
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000ac54: f8 02 21 50 ld [ %o0 + 0x150 ], %i4
if ( api->schedpolicy == SCHED_SPORADIC )
4000ac58: c2 07 20 84 ld [ %i4 + 0x84 ], %g1
4000ac5c: 80 a0 60 04 cmp %g1, 4
4000ac60: 02 80 00 35 be 4000ad34 <pthread_setschedparam+0x134>
4000ac64: 01 00 00 00 nop
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
4000ac68: c2 06 80 00 ld [ %i2 ], %g1
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
4000ac6c: 80 a6 60 00 cmp %i1, 0
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
4000ac70: c2 27 20 88 st %g1, [ %i4 + 0x88 ]
4000ac74: c4 06 a0 04 ld [ %i2 + 4 ], %g2
4000ac78: c4 27 20 8c st %g2, [ %i4 + 0x8c ]
4000ac7c: c4 06 a0 08 ld [ %i2 + 8 ], %g2
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
4000ac80: f2 27 20 84 st %i1, [ %i4 + 0x84 ]
api->schedparam = *param;
4000ac84: c4 27 20 90 st %g2, [ %i4 + 0x90 ]
4000ac88: c4 06 a0 0c ld [ %i2 + 0xc ], %g2
4000ac8c: c4 27 20 94 st %g2, [ %i4 + 0x94 ]
4000ac90: c4 06 a0 10 ld [ %i2 + 0x10 ], %g2
4000ac94: c4 27 20 98 st %g2, [ %i4 + 0x98 ]
4000ac98: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2
4000ac9c: c4 27 20 9c st %g2, [ %i4 + 0x9c ]
4000aca0: c4 06 a0 18 ld [ %i2 + 0x18 ], %g2
4000aca4: c4 27 20 a0 st %g2, [ %i4 + 0xa0 ]
the_thread->budget_algorithm = budget_algorithm;
4000aca8: c4 07 bf f4 ld [ %fp + -12 ], %g2
4000acac: c4 26 e0 78 st %g2, [ %i3 + 0x78 ]
the_thread->budget_callout = budget_callout;
4000acb0: c4 07 bf f8 ld [ %fp + -8 ], %g2
switch ( api->schedpolicy ) {
4000acb4: 06 80 00 0e bl 4000acec <pthread_setschedparam+0xec> <== NEVER TAKEN
4000acb8: c4 26 e0 7c st %g2, [ %i3 + 0x7c ]
4000acbc: 80 a6 60 02 cmp %i1, 2
4000acc0: 04 80 00 11 ble 4000ad04 <pthread_setschedparam+0x104>
4000acc4: 07 10 00 71 sethi %hi(0x4001c400), %g3
4000acc8: 80 a6 60 04 cmp %i1, 4
4000accc: 12 80 00 08 bne 4000acec <pthread_setschedparam+0xec> <== NEVER TAKEN
4000acd0: 01 00 00 00 nop
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
4000acd4: c2 27 20 a4 st %g1, [ %i4 + 0xa4 ]
_Watchdog_Remove( &api->Sporadic_timer );
4000acd8: 40 00 10 b0 call 4000ef98 <_Watchdog_Remove>
4000acdc: 90 07 20 a8 add %i4, 0xa8, %o0
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
4000ace0: 90 10 20 00 clr %o0
4000ace4: 7f ff ff 7b call 4000aad0 <_POSIX_Threads_Sporadic_budget_TSR>
4000ace8: 92 10 00 1b mov %i3, %o1
break;
}
_Thread_Enable_dispatch();
4000acec: 40 00 0c 7b call 4000ded8 <_Thread_Enable_dispatch>
4000acf0: b0 10 00 1d mov %i5, %i0
4000acf4: 30 bf ff d0 b,a 4000ac34 <pthread_setschedparam+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
4000acf8: ba 10 20 03 mov 3, %i5
}
4000acfc: 81 c7 e0 08 ret
4000ad00: 91 e8 00 1d restore %g0, %i5, %o0
4000ad04: d2 08 e2 6c ldub [ %g3 + 0x26c ], %o1
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
4000ad08: 05 10 00 74 sethi %hi(0x4001d000), %g2
4000ad0c: c4 00 a3 d0 ld [ %g2 + 0x3d0 ], %g2 ! 4001d3d0 <_Thread_Ticks_per_timeslice>
4000ad10: 92 22 40 01 sub %o1, %g1, %o1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
4000ad14: 90 10 00 1b mov %i3, %o0
4000ad18: 94 10 20 01 mov 1, %o2
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
4000ad1c: c4 26 e0 74 st %g2, [ %i3 + 0x74 ]
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
4000ad20: 40 00 0b 34 call 4000d9f0 <_Thread_Change_priority>
4000ad24: d2 26 e0 18 st %o1, [ %i3 + 0x18 ]
_Watchdog_Remove( &api->Sporadic_timer );
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
break;
}
_Thread_Enable_dispatch();
4000ad28: 40 00 0c 6c call 4000ded8 <_Thread_Enable_dispatch>
4000ad2c: b0 10 00 1d mov %i5, %i0
4000ad30: 30 bf ff c1 b,a 4000ac34 <pthread_setschedparam+0x34>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
4000ad34: 40 00 10 99 call 4000ef98 <_Watchdog_Remove>
4000ad38: 90 07 20 a8 add %i4, 0xa8, %o0
api->schedpolicy = policy;
api->schedparam = *param;
4000ad3c: 10 bf ff cc b 4000ac6c <pthread_setschedparam+0x6c>
4000ad40: c2 06 80 00 ld [ %i2 ], %g1
40008598 <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
40008598: 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() )
4000859c: 3b 10 00 67 sethi %hi(0x40019c00), %i5
400085a0: ba 17 63 10 or %i5, 0x310, %i5 ! 40019f10 <_Per_CPU_Information>
400085a4: c2 07 60 08 ld [ %i5 + 8 ], %g1
400085a8: 80 a0 60 00 cmp %g1, 0
400085ac: 12 80 00 16 bne 40008604 <pthread_testcancel+0x6c> <== NEVER TAKEN
400085b0: 03 10 00 66 sethi %hi(0x40019800), %g1
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
400085b4: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
400085b8: c6 00 62 00 ld [ %g1 + 0x200 ], %g3
400085bc: c4 00 a1 50 ld [ %g2 + 0x150 ], %g2
++level;
400085c0: 86 00 e0 01 inc %g3
_Thread_Dispatch_disable_level = level;
400085c4: c6 20 62 00 st %g3, [ %g1 + 0x200 ]
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
400085c8: c2 00 a0 d8 ld [ %g2 + 0xd8 ], %g1
400085cc: 80 a0 60 00 cmp %g1, 0
400085d0: 12 80 00 0b bne 400085fc <pthread_testcancel+0x64> <== NEVER TAKEN
400085d4: 01 00 00 00 nop
400085d8: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1
400085dc: 80 a0 60 00 cmp %g1, 0
400085e0: 02 80 00 07 be 400085fc <pthread_testcancel+0x64>
400085e4: 01 00 00 00 nop
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
400085e8: 40 00 0c 26 call 4000b680 <_Thread_Enable_dispatch>
400085ec: b2 10 3f ff mov -1, %i1 ! ffffffff <LEON_REG+0x7fffffff>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
400085f0: f0 07 60 10 ld [ %i5 + 0x10 ], %i0
400085f4: 40 00 18 1f call 4000e670 <_POSIX_Thread_Exit>
400085f8: 81 e8 00 00 restore
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
400085fc: 40 00 0c 21 call 4000b680 <_Thread_Enable_dispatch>
40008600: 81 e8 00 00 restore
40008604: 81 c7 e0 08 ret <== NOT EXECUTED
40008608: 81 e8 00 00 restore <== NOT EXECUTED
4000dbfc <ramdisk_allocate>:
void *area_begin,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace
)
{
4000dbfc: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
4000dc00: 7f ff df 1b call 4000586c <malloc>
4000dc04: 90 10 20 10 mov 0x10, %o0
if (rd == NULL) {
4000dc08: ba 92 20 00 orcc %o0, 0, %i5
4000dc0c: 02 80 00 0b be 4000dc38 <ramdisk_allocate+0x3c> <== NEVER TAKEN
4000dc10: 80 a6 20 00 cmp %i0, 0
return NULL;
}
if (area_begin == NULL) {
4000dc14: 02 80 00 0b be 4000dc40 <ramdisk_allocate+0x44>
4000dc18: 90 10 00 1a mov %i2, %o0
return NULL;
}
rd->malloced = true;
} else {
rd->malloced = false;
4000dc1c: c0 2f 60 0d clrb [ %i5 + 0xd ]
}
rd->block_size = media_block_size;
rd->block_num = media_block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
4000dc20: 82 10 20 01 mov 1, %g1
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = media_block_size;
4000dc24: f2 27 40 00 st %i1, [ %i5 ]
rd->block_num = media_block_count;
4000dc28: f4 27 60 04 st %i2, [ %i5 + 4 ]
rd->area = area_begin;
4000dc2c: f0 27 60 08 st %i0, [ %i5 + 8 ]
rd->trace = trace;
4000dc30: f6 2f 60 0e stb %i3, [ %i5 + 0xe ]
rd->initialized = true;
4000dc34: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
return rd;
}
4000dc38: 81 c7 e0 08 ret
4000dc3c: 91 e8 00 1d restore %g0, %i5, %o0
if (rd == NULL) {
return NULL;
}
if (area_begin == NULL) {
area_begin = calloc(media_block_count, media_block_size);
4000dc40: 7f ff dd 8c call 40005270 <calloc>
4000dc44: 92 10 00 19 mov %i1, %o1
if (area_begin == NULL) {
4000dc48: b0 92 20 00 orcc %o0, 0, %i0
4000dc4c: 02 80 00 04 be 4000dc5c <ramdisk_allocate+0x60> <== NEVER TAKEN
4000dc50: 82 10 20 01 mov 1, %g1
free(rd);
return NULL;
}
rd->malloced = true;
4000dc54: 10 bf ff f4 b 4000dc24 <ramdisk_allocate+0x28>
4000dc58: c2 2f 60 0d stb %g1, [ %i5 + 0xd ]
}
if (area_begin == NULL) {
area_begin = calloc(media_block_count, media_block_size);
if (area_begin == NULL) {
free(rd);
4000dc5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000dc60: 7f ff dd bb call 4000534c <free> <== NOT EXECUTED
4000dc64: ba 10 20 00 clr %i5 <== NOT EXECUTED
return NULL;
4000dc68: 30 bf ff f4 b,a 4000dc38 <ramdisk_allocate+0x3c> <== NOT EXECUTED
4000dc6c <ramdisk_free>:
return rd;
}
void ramdisk_free(ramdisk *rd)
{
4000dc6c: 9d e3 bf a0 save %sp, -96, %sp
if (rd != NULL) {
4000dc70: 80 a6 20 00 cmp %i0, 0
4000dc74: 02 80 00 0c be 4000dca4 <ramdisk_free+0x38> <== NEVER TAKEN
4000dc78: 01 00 00 00 nop
if (rd->malloced) {
4000dc7c: c2 0e 20 0d ldub [ %i0 + 0xd ], %g1
4000dc80: 80 a0 60 00 cmp %g1, 0
4000dc84: 12 80 00 04 bne 4000dc94 <ramdisk_free+0x28>
4000dc88: 01 00 00 00 nop
free(rd->area);
}
free(rd);
4000dc8c: 7f ff dd b0 call 4000534c <free>
4000dc90: 81 e8 00 00 restore
void ramdisk_free(ramdisk *rd)
{
if (rd != NULL) {
if (rd->malloced) {
free(rd->area);
4000dc94: 7f ff dd ae call 4000534c <free>
4000dc98: d0 06 20 08 ld [ %i0 + 8 ], %o0
}
free(rd);
4000dc9c: 7f ff dd ac call 4000534c <free>
4000dca0: 81 e8 00 00 restore
4000dca4: 81 c7 e0 08 ret <== NOT EXECUTED
4000dca8: 81 e8 00 00 restore <== NOT EXECUTED
4000ecc0 <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
4000ecc0: 9d e3 bf 80 save %sp, -128, %sp
rtems_device_minor_number i;
rtems_ramdisk_config *c = rtems_ramdisk_configuration;
struct ramdisk *r;
rtems_status_code rc;
rc = rtems_disk_io_initialize();
4000ecc4: 7f ff da 06 call 400054dc <rtems_disk_io_initialize>
4000ecc8: a0 10 00 18 mov %i0, %l0
if (rc != RTEMS_SUCCESSFUL)
4000eccc: b0 92 20 00 orcc %o0, 0, %i0
4000ecd0: 02 80 00 04 be 4000ece0 <ramdisk_initialize+0x20> <== ALWAYS TAKEN
4000ecd4: 23 10 00 9e sethi %hi(0x40027800), %l1
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
}
4000ecd8: 81 c7 e0 08 ret <== NOT EXECUTED
4000ecdc: 81 e8 00 00 restore <== NOT EXECUTED
* This is allocating memory for a RAM disk which will persist for
* the life of the system. RTEMS has no "de-initialize" driver call
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
4000ece0: fa 04 60 2c ld [ %l1 + 0x2c ], %i5
4000ece4: 92 10 20 10 mov 0x10, %o1
4000ece8: 7f ff dd e5 call 4000647c <calloc>
4000ecec: 90 10 00 1d mov %i5, %o0
r->trace = false;
4000ecf0: c0 2a 20 0e clrb [ %o0 + 0xe ]
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
4000ecf4: 80 a7 60 00 cmp %i5, 0
4000ecf8: 02 80 00 2e be 4000edb0 <ramdisk_initialize+0xf0> <== NEVER TAKEN
4000ecfc: b6 10 00 08 mov %o0, %i3
4000ed00: 35 10 00 9e sethi %hi(0x40027800), %i2
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
4000ed04: 39 0b d9 19 sethi %hi(0x2f646400), %i4
4000ed08: 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,
4000ed0c: 25 10 00 3b sethi %hi(0x4000ec00), %l2
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
4000ed10: b4 16 a0 30 or %i2, 0x30, %i2
4000ed14: b2 10 20 00 clr %i1
4000ed18: a2 14 60 2c or %l1, 0x2c, %l1
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
4000ed1c: b8 17 21 76 or %i4, 0x176, %i4
4000ed20: 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);
4000ed24: a6 07 bf f0 add %fp, -16, %l3
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
4000ed28: a4 14 a1 fc or %l2, 0x1fc, %l2
}
}
else
{
r->malloced = false;
r->initialized = true;
4000ed2c: b0 10 20 01 mov 1, %i0
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
4000ed30: d4 06 80 00 ld [ %i2 ], %o2
r->block_num = c->block_num;
4000ed34: d6 06 a0 04 ld [ %i2 + 4 ], %o3
if (c->location == NULL)
4000ed38: c2 06 a0 08 ld [ %i2 + 8 ], %g1
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
4000ed3c: f2 2f bf f8 stb %i1, [ %fp + -8 ]
r->block_size = c->block_size;
4000ed40: d4 26 c0 00 st %o2, [ %i3 ]
r->block_num = c->block_num;
4000ed44: d6 26 e0 04 st %o3, [ %i3 + 4 ]
if (c->location == NULL)
4000ed48: 80 a0 60 00 cmp %g1, 0
4000ed4c: 02 80 00 1f be 4000edc8 <ramdisk_initialize+0x108> <== ALWAYS TAKEN
4000ed50: f8 3f bf f0 std %i4, [ %fp + -16 ]
r->initialized = true;
}
}
else
{
r->malloced = false;
4000ed54: c0 2e e0 0d clrb [ %i3 + 0xd ] <== NOT EXECUTED
r->initialized = true;
4000ed58: f0 2e e0 0c stb %i0, [ %i3 + 0xc ] <== NOT EXECUTED
r->area = c->location;
4000ed5c: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
4000ed60: 92 10 00 19 mov %i1, %o1
4000ed64: 9a 10 00 1b mov %i3, %o5
4000ed68: 98 10 00 12 mov %l2, %o4
4000ed6c: e6 23 a0 5c st %l3, [ %sp + 0x5c ]
4000ed70: 7f ff d9 3b call 4000525c <rtems_disk_create_phys>
4000ed74: 90 10 00 10 mov %l0, %o0
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
4000ed78: 80 a2 20 00 cmp %o0, 0
4000ed7c: 22 80 00 08 be,a 4000ed9c <ramdisk_initialize+0xdc> <== ALWAYS TAKEN
4000ed80: c2 04 40 00 ld [ %l1 ], %g1
{
if (r->malloced)
4000ed84: c2 0e e0 0d ldub [ %i3 + 0xd ], %g1 <== NOT EXECUTED
4000ed88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000ed8c: 12 80 00 0b bne 4000edb8 <ramdisk_initialize+0xf8> <== NOT EXECUTED
4000ed90: 01 00 00 00 nop <== NOT EXECUTED
{
free(r->area);
}
r->initialized = false;
4000ed94: 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++)
4000ed98: c2 04 40 00 ld [ %l1 ], %g1 <== NOT EXECUTED
4000ed9c: b2 06 60 01 inc %i1
4000eda0: b4 06 a0 0c add %i2, 0xc, %i2
4000eda4: 80 a0 40 19 cmp %g1, %i1
4000eda8: 18 bf ff e2 bgu 4000ed30 <ramdisk_initialize+0x70> <== NEVER TAKEN
4000edac: b6 06 e0 10 add %i3, 0x10, %i3
free(r->area);
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
4000edb0: 81 c7 e0 08 ret
4000edb4: 91 e8 20 00 restore %g0, 0, %o0
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
{
if (r->malloced)
{
free(r->area);
4000edb8: 7f ff dd e8 call 40006558 <free> <== NOT EXECUTED
4000edbc: d0 06 e0 08 ld [ %i3 + 8 ], %o0 <== NOT EXECUTED
}
r->initialized = false;
4000edc0: 10 bf ff f6 b 4000ed98 <ramdisk_initialize+0xd8> <== NOT EXECUTED
4000edc4: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
{
r->malloced = true;
r->area = malloc(r->block_size * r->block_num);
4000edc8: 92 10 00 0a mov %o2, %o1
4000edcc: 90 10 00 0b mov %o3, %o0
4000edd0: d4 3f bf e8 std %o2, [ %fp + -24 ]
4000edd4: 40 00 4f e5 call 40022d68 <.umul>
4000edd8: f0 2e e0 0d stb %i0, [ %i3 + 0xd ]
4000eddc: 7f ff df 7c call 40006bcc <malloc>
4000ede0: 01 00 00 00 nop
4000ede4: d0 26 e0 08 st %o0, [ %i3 + 8 ]
if (r->area == NULL) /* No enough memory for this disk */
4000ede8: 80 a2 20 00 cmp %o0, 0
4000edec: 02 bf ff ea be 4000ed94 <ramdisk_initialize+0xd4> <== NEVER TAKEN
4000edf0: d4 1f bf e8 ldd [ %fp + -24 ], %o2
r->initialized = false;
continue;
}
else
{
r->initialized = true;
4000edf4: 10 bf ff db b 4000ed60 <ramdisk_initialize+0xa0>
4000edf8: f0 2e e0 0c stb %i0, [ %i3 + 0xc ]
4000dab4 <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4000dab4: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
4000dab8: 05 08 00 10 sethi %hi(0x20004000), %g2
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
4000dabc: b8 10 00 1a mov %i2, %i4
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
4000dac0: 84 10 a2 07 or %g2, 0x207, %g2
4000dac4: 80 a6 40 02 cmp %i1, %g2
4000dac8: 02 80 00 09 be 4000daec <ramdisk_ioctl+0x38>
4000dacc: f6 06 20 3c ld [ %i0 + 0x3c ], %i3
4000dad0: 05 30 06 10 sethi %hi(0xc0184000), %g2
4000dad4: 84 10 a2 01 or %g2, 0x201, %g2 ! c0184201 <LEON_REG+0x40184201>
4000dad8: 80 a6 40 02 cmp %i1, %g2
4000dadc: 22 80 00 0e be,a 4000db14 <ramdisk_ioctl+0x60>
4000dae0: c2 06 80 00 ld [ %i2 ], %g1
ramdisk_free(rd);
}
break;
default:
return rtems_blkdev_ioctl (dd, req, argp);
4000dae4: 40 00 0b 08 call 40010704 <rtems_blkdev_ioctl>
4000dae8: 81 e8 00 00 restore
}
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
4000daec: c2 0e e0 0f ldub [ %i3 + 0xf ], %g1
4000daf0: 80 a0 60 00 cmp %g1, 0
4000daf4: 12 80 00 3f bne 4000dbf0 <ramdisk_ioctl+0x13c>
4000daf8: 01 00 00 00 nop
default:
return rtems_blkdev_ioctl (dd, req, argp);
break;
}
errno = EINVAL;
4000dafc: 40 00 1d ff call 400152f8 <__errno>
4000db00: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff>
4000db04: 82 10 20 16 mov 0x16, %g1
4000db08: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
4000db0c: 81 c7 e0 08 ret
4000db10: 81 e8 00 00 restore
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
4000db14: 80 a0 60 00 cmp %g1, 0
4000db18: 12 80 00 1c bne 4000db88 <ramdisk_ioctl+0xd4>
4000db1c: 80 a0 60 01 cmp %g1, 1
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4000db20: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
4000db24: ba 06 a0 18 add %i2, 0x18, %i5
#endif
static int
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *from = rd->area;
4000db28: f0 06 e0 08 ld [ %i3 + 8 ], %i0
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4000db2c: 80 a0 60 00 cmp %g1, 0
4000db30: 02 80 00 0f be 4000db6c <ramdisk_ioctl+0xb8> <== NEVER TAKEN
4000db34: 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);
4000db38: d0 07 40 00 ld [ %i5 ], %o0
4000db3c: d2 06 c0 00 ld [ %i3 ], %o1
4000db40: 40 00 2b 77 call 4001891c <.umul>
4000db44: f2 07 60 08 ld [ %i5 + 8 ], %i1
4000db48: d4 07 60 04 ld [ %i5 + 4 ], %o2
4000db4c: 92 06 00 08 add %i0, %o0, %o1
4000db50: 40 00 20 21 call 40015bd4 <memcpy>
4000db54: 90 10 00 19 mov %i1, %o0
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4000db58: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
4000db5c: b4 06 a0 01 inc %i2
4000db60: 80 a6 80 01 cmp %i2, %g1
4000db64: 0a bf ff f5 bcs 4000db38 <ramdisk_ioctl+0x84> <== NEVER TAKEN
4000db68: ba 07 60 10 add %i5, 0x10, %i5
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
4000db6c: c2 07 20 04 ld [ %i4 + 4 ], %g1
4000db70: 90 10 00 1c mov %i4, %o0
4000db74: 92 10 20 00 clr %o1
4000db78: 9f c0 40 00 call %g1
4000db7c: 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);
4000db80: 81 c7 e0 08 ret
4000db84: 81 e8 00 00 restore
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
4000db88: 12 bf ff dd bne 4000dafc <ramdisk_ioctl+0x48> <== NEVER TAKEN
4000db8c: ba 06 a0 18 add %i2, 0x18, %i5
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4000db90: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
4000db94: f2 06 e0 08 ld [ %i3 + 8 ], %i1
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4000db98: 80 a0 60 00 cmp %g1, 0
4000db9c: 02 bf ff f4 be 4000db6c <ramdisk_ioctl+0xb8> <== NEVER TAKEN
4000dba0: 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);
4000dba4: d0 07 40 00 ld [ %i5 ], %o0
4000dba8: d2 06 c0 00 ld [ %i3 ], %o1
4000dbac: 40 00 2b 5c call 4001891c <.umul>
4000dbb0: b4 06 a0 01 inc %i2
4000dbb4: d2 07 60 08 ld [ %i5 + 8 ], %o1
4000dbb8: d4 07 60 04 ld [ %i5 + 4 ], %o2
4000dbbc: 40 00 20 06 call 40015bd4 <memcpy>
4000dbc0: 90 06 40 08 add %i1, %o0, %o0
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
4000dbc4: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
4000dbc8: 80 a6 80 01 cmp %i2, %g1
4000dbcc: 0a bf ff f6 bcs 4000dba4 <ramdisk_ioctl+0xf0>
4000dbd0: ba 07 60 10 add %i5, 0x10, %i5
4000dbd4: c2 07 20 04 ld [ %i4 + 4 ], %g1
4000dbd8: 90 10 00 1c mov %i4, %o0
4000dbdc: 92 10 20 00 clr %o1
4000dbe0: 9f c0 40 00 call %g1
4000dbe4: 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);
4000dbe8: 81 c7 e0 08 ret
4000dbec: 81 e8 00 00 restore
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
ramdisk_free(rd);
4000dbf0: 40 00 00 1f call 4000dc6c <ramdisk_free>
4000dbf4: 90 10 00 1b mov %i3, %o0
4000dbf8: 30 bf ff c1 b,a 4000dafc <ramdisk_ioctl+0x48>
4000dcac <ramdisk_register>:
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
4000dcac: 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);
4000dcb0: 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;
4000dcb4: c0 27 bf fc clr [ %fp + -4 ]
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
4000dcb8: 94 07 bf fc add %fp, -4, %o2
4000dcbc: 13 10 00 6d sethi %hi(0x4001b400), %o1
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
4000dcc0: ba 10 20 0d mov 0xd, %i5
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
4000dcc4: 7f ff f1 50 call 4000a204 <rtems_io_register_driver>
4000dcc8: 92 12 60 08 or %o1, 8, %o1
if (sc != RTEMS_SUCCESSFUL) {
4000dccc: 80 a2 20 00 cmp %o0, 0
4000dcd0: 02 80 00 04 be 4000dce0 <ramdisk_register+0x34> <== ALWAYS TAKEN
4000dcd4: 96 10 00 1a mov %i2, %o3
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
4000dcd8: 81 c7 e0 08 ret
4000dcdc: 91 e8 00 1d restore %g0, %i5, %o0
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);
4000dce0: 92 10 00 18 mov %i0, %o1
4000dce4: 7f ff ff c6 call 4000dbfc <ramdisk_allocate>
4000dce8: 94 10 00 19 mov %i1, %o2
if (rd == NULL) {
4000dcec: b4 92 20 00 orcc %o0, 0, %i2
4000dcf0: 02 80 00 14 be 4000dd40 <ramdisk_register+0x94> <== NEVER TAKEN
4000dcf4: e0 07 bf fc ld [ %fp + -4 ], %l0
return RTEMS_UNSATISFIED;
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
4000dcf8: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
4000dcfc: 90 10 00 10 mov %l0, %o0
4000dd00: 92 10 20 00 clr %o1
4000dd04: 94 10 00 18 mov %i0, %o2
4000dd08: 96 10 00 19 mov %i1, %o3
4000dd0c: 9a 10 00 1a mov %i2, %o5
4000dd10: 19 10 00 36 sethi %hi(0x4000d800), %o4
4000dd14: 7f ff da 75 call 400046e8 <rtems_disk_create_phys>
4000dd18: 98 13 22 b4 or %o4, 0x2b4, %o4 ! 4000dab4 <ramdisk_ioctl>
media_block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
4000dd1c: 80 a2 20 00 cmp %o0, 0
4000dd20: 12 80 00 06 bne 4000dd38 <ramdisk_register+0x8c> <== NEVER TAKEN
4000dd24: 01 00 00 00 nop
rtems_io_unregister_driver(major);
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
4000dd28: e0 27 00 00 st %l0, [ %i4 ]
4000dd2c: c0 27 20 04 clr [ %i4 + 4 ]
return RTEMS_SUCCESSFUL;
4000dd30: 10 bf ff ea b 4000dcd8 <ramdisk_register+0x2c>
4000dd34: ba 10 20 00 clr %i5
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
ramdisk_free(rd);
4000dd38: 7f ff ff cd call 4000dc6c <ramdisk_free> <== NOT EXECUTED
4000dd3c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_io_unregister_driver(major);
4000dd40: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
4000dd44: 7f ff f1 95 call 4000a398 <rtems_io_unregister_driver> <== NOT EXECUTED
4000dd48: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
4000dd4c: 81 c7 e0 08 ret <== NOT EXECUTED
4000dd50: 81 e8 00 00 restore <== NOT EXECUTED
4000dd54: 40 00 ed d0 call 40049494 <__end+0x2bec4> <== NOT EXECUTED
4000dd58: 40 00 ef 6c call 40049b08 <__end+0x2c538> <== NOT EXECUTED
4000dd5c: 40 00 ef 64 call 40049aec <__end+0x2c51c> <== NOT EXECUTED
4000dd60: 40 00 ef 50 call 40049aa0 <__end+0x2c4d0> <== NOT EXECUTED
4000dd64: 40 00 ef 50 call 40049aa4 <__end+0x2c4d4> <== NOT EXECUTED
4000dd68: 40 00 ef 50 call 40049aa8 <__end+0x2c4d8> <== NOT EXECUTED
4000dd6c: 40 00 ef 50 call 40049aac <__end+0x2c4dc> <== NOT EXECUTED
4000dd70: 40 00 ef 1c call 400499e0 <__end+0x2c410> <== NOT EXECUTED
4000dd74: 40 00 ef 08 call 40049994 <__end+0x2c3c4> <== NOT EXECUTED
4000dd78: 40 00 ef 08 call 40049998 <__end+0x2c3c8> <== NOT EXECUTED
4000dd7c: 40 00 ef 08 call 4004999c <__end+0x2c3cc> <== NOT EXECUTED
4000dd80: 40 00 ee 18 call 400495e0 <__end+0x2c010> <== NOT EXECUTED
4000dd84: 40 00 ee 08 call 400495a4 <__end+0x2bfd4> <== NOT EXECUTED
4000dd88: 40 00 ee 08 call 400495a8 <__end+0x2bfd8> <== NOT EXECUTED
4000dd8c: 40 00 ee e4 call 4004991c <__end+0x2c34c> <== NOT EXECUTED
4000dd90: 40 00 ee e4 call 40049920 <__end+0x2c350> <== NOT EXECUTED
4000dd94: 40 00 ee e4 call 40049924 <__end+0x2c354> <== NOT EXECUTED
4000dd98: 40 00 ee e4 call 40049928 <__end+0x2c358> <== NOT EXECUTED
4000dd9c: 40 00 ee b0 call 4004985c <__end+0x2c28c> <== NOT EXECUTED
4000dda0: 40 00 ee 9c call 40049810 <__end+0x2c240> <== NOT EXECUTED
4000dda4: 40 00 ee 9c call 40049814 <__end+0x2c244> <== NOT EXECUTED
4000dda8: 40 00 ee 9c call 40049818 <__end+0x2c248> <== NOT EXECUTED
4000ddac: 40 01 04 1c call 4004ee1c <__end+0x3184c> <== NOT EXECUTED
4000ddb0: 40 01 04 1c call 4004ee20 <__end+0x31850> <== NOT EXECUTED
4000ddb4: 40 01 05 44 call 4004f2c4 <__end+0x31cf4> <== NOT EXECUTED
4000ddb8: 40 01 05 6c call 4004f368 <__end+0x31d98> <== NOT EXECUTED
4000ddbc: 40 01 05 6c call 4004f36c <__end+0x31d9c> <== NOT EXECUTED
4000ddc0: 40 01 05 6c call 4004f370 <__end+0x31da0> <== NOT EXECUTED
4000ddc4: 40 01 04 1c call 4004ee34 <__end+0x31864> <== NOT EXECUTED
4000ddc8: 40 01 05 34 call 4004f298 <__end+0x31cc8> <== NOT EXECUTED
4000ddcc: 40 01 05 2c call 4004f27c <__end+0x31cac> <== NOT EXECUTED
4000ddd0: 40 01 05 74 call 4004f3a0 <__end+0x31dd0> <== NOT EXECUTED
4000ddd4: 40 01 04 1c call 4004ee44 <__end+0x31874> <== NOT EXECUTED
4001c8d0 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
4001c8d0: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
4001c8d4: 03 10 00 7d sethi %hi(0x4001f400), %g1
4001c8d8: c2 00 61 a4 ld [ %g1 + 0x1a4 ], %g1 ! 4001f5a4 <rtems_libio_number_iops>
4001c8dc: 80 a6 00 01 cmp %i0, %g1
4001c8e0: 1a 80 00 18 bcc 4001c940 <read+0x70>
4001c8e4: 03 10 00 80 sethi %hi(0x40020000), %g1
iop = rtems_libio_iop( fd );
4001c8e8: d0 00 61 24 ld [ %g1 + 0x124 ], %o0 ! 40020124 <rtems_libio_iops>
4001c8ec: 83 2e 20 03 sll %i0, 3, %g1
4001c8f0: b1 2e 20 06 sll %i0, 6, %i0
4001c8f4: b0 26 00 01 sub %i0, %g1, %i0
4001c8f8: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
4001c8fc: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4001c900: 80 88 61 00 btst 0x100, %g1
4001c904: 02 80 00 0f be 4001c940 <read+0x70>
4001c908: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
4001c90c: 02 80 00 13 be 4001c958 <read+0x88> <== NEVER TAKEN
4001c910: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
4001c914: 02 80 00 0f be 4001c950 <read+0x80>
4001c918: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4001c91c: 80 88 60 02 btst 2, %g1
4001c920: 02 80 00 08 be 4001c940 <read+0x70>
4001c924: 92 10 00 19 mov %i1, %o1
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
4001c928: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4001c92c: c2 00 60 08 ld [ %g1 + 8 ], %g1
4001c930: 9f c0 40 00 call %g1
4001c934: 94 10 00 1a mov %i2, %o2
}
4001c938: 81 c7 e0 08 ret
4001c93c: 91 e8 00 08 restore %g0, %o0, %o0
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4001c940: 7f ff d0 00 call 40010940 <__errno>
4001c944: b0 10 3f ff mov -1, %i0
4001c948: 82 10 20 09 mov 9, %g1
4001c94c: c2 22 00 00 st %g1, [ %o0 ]
4001c950: 81 c7 e0 08 ret
4001c954: 81 e8 00 00 restore
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
4001c958: 7f ff cf fa call 40010940 <__errno> <== NOT EXECUTED
4001c95c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001c960: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4001c964: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001c968: 81 c7 e0 08 ret <== NOT EXECUTED
4001c96c: 81 e8 00 00 restore <== NOT EXECUTED
40005854 <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)
{
40005854: 9d e3 bf 98 save %sp, -104, %sp
int i;
rtems_sector_data_t *sector = NULL;
40005858: c0 27 bf f8 clr [ %fp + -8 ]
* RTEMS_NO_MEMOTY if cannot allocate memory for part_desc_t strucure,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
static rtems_status_code
read_extended_partition(int fd, uint32_t start, rtems_part_desc_t *ext_part)
{
4000585c: ba 10 00 18 mov %i0, %i5
uint32_t here;
uint8_t *data;
rtems_part_desc_t *new_part_desc;
rtems_status_code rc;
if ((ext_part == NULL) || (ext_part->disk_desc == NULL))
40005860: 80 a6 a0 00 cmp %i2, 0
40005864: 02 80 00 16 be 400058bc <read_extended_partition+0x68> <== NEVER TAKEN
40005868: b0 10 20 19 mov 0x19, %i0
4000586c: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
40005870: 80 a0 60 00 cmp %g1, 0
40005874: 02 80 00 12 be 400058bc <read_extended_partition+0x68> <== NEVER TAKEN
40005878: 90 10 00 1d mov %i5, %o0
{
return RTEMS_INTERNAL_ERROR;
}
/* get start sector of current extended partition */
here = ext_part->start;
4000587c: e0 06 a0 04 ld [ %i2 + 4 ], %l0
if (sector == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
40005880: b9 2c 20 09 sll %l0, 9, %i4
new_off = lseek(fd, off, SEEK_SET);
40005884: 92 10 20 00 clr %o1
40005888: 94 10 00 1c mov %i4, %o2
4000588c: 40 00 04 57 call 400069e8 <lseek>
40005890: 96 10 20 00 clr %o3
if (new_off != off) {
40005894: 80 a2 20 00 cmp %o0, 0
40005898: 02 80 00 0b be 400058c4 <read_extended_partition+0x70> <== ALWAYS TAKEN
4000589c: 80 a7 00 09 cmp %i4, %o1
return RTEMS_IO_ERROR;
400058a0: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
/* get first extended partition sector */
rc = get_sector(fd, here, §or);
if (rc != RTEMS_SUCCESSFUL)
{
if (sector)
400058a4: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
400058a8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400058ac: 02 80 00 41 be 400059b0 <read_extended_partition+0x15c> <== NOT EXECUTED
400058b0: 01 00 00 00 nop <== NOT EXECUTED
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
400058b4: 40 00 03 29 call 40006558 <free> <== NOT EXECUTED
400058b8: 01 00 00 00 nop <== NOT EXECUTED
400058bc: 81 c7 e0 08 ret <== NOT EXECUTED
400058c0: 81 e8 00 00 restore <== NOT EXECUTED
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
new_off = lseek(fd, off, SEEK_SET);
if (new_off != off) {
400058c4: 12 bf ff f8 bne 400058a4 <read_extended_partition+0x50> <== NEVER TAKEN
400058c8: b0 10 20 1b mov 0x1b, %i0
400058cc: 90 10 00 1d mov %i5, %o0
400058d0: 92 10 00 10 mov %l0, %o1
400058d4: 7f ff ff 7c call 400056c4 <get_sector.part.0>
400058d8: 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)
400058dc: b0 92 20 00 orcc %o0, 0, %i0
400058e0: 12 bf ff f1 bne 400058a4 <read_extended_partition+0x50> <== NEVER TAKEN
400058e4: d0 07 bf f8 ld [ %fp + -8 ], %o0
static bool
msdos_signature_check (rtems_sector_data_t *sector)
{
uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&
400058e8: c2 0a 22 02 ldub [ %o0 + 0x202 ], %g1
400058ec: 80 a0 60 55 cmp %g1, 0x55
400058f0: 22 80 00 06 be,a 40005908 <read_extended_partition+0xb4> <== ALWAYS TAKEN
400058f4: c2 0a 22 03 ldub [ %o0 + 0x203 ], %g1
return rc;
}
if (!msdos_signature_check(sector))
{
free(sector);
400058f8: 40 00 03 18 call 40006558 <free> <== NOT EXECUTED
400058fc: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED
40005900: 81 c7 e0 08 ret <== NOT EXECUTED
40005904: 81 e8 00 00 restore <== NOT EXECUTED
static bool
msdos_signature_check (rtems_sector_data_t *sector)
{
uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&
40005908: 80 a0 60 aa cmp %g1, 0xaa
4000590c: 12 bf ff fb bne 400058f8 <read_extended_partition+0xa4> <== NEVER TAKEN
40005910: b6 02 21 d2 add %o0, 0x1d2, %i3
40005914: 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)
40005918: a2 06 a0 10 add %i2, 0x10, %l1
4000591c: 90 06 ff f0 add %i3, -16, %o0
40005920: 7f ff ff 80 call 40005720 <data_to_part_desc.part.1>
40005924: 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)
40005928: b0 92 20 00 orcc %o0, 0, %i0
4000592c: 12 80 00 1f bne 400059a8 <read_extended_partition+0x154> <== NEVER TAKEN
40005930: d4 07 bf fc ld [ %fp + -4 ], %o2
{
free(sector);
return rc;
}
if (new_part_desc == NULL)
40005934: 80 a2 a0 00 cmp %o2, 0
40005938: 22 80 00 19 be,a 4000599c <read_extended_partition+0x148>
4000593c: b8 07 20 04 add %i4, 4, %i4
{
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
40005940: d4 27 20 18 st %o2, [ %i4 + 0x18 ]
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
40005944: 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));
40005948: 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;
4000594c: 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))
40005950: 84 08 a0 7f and %g2, 0x7f, %g2
40005954: 80 a0 a0 05 cmp %g2, 5
40005958: 02 80 00 18 be 400059b8 <read_extended_partition+0x164>
4000595c: c2 22 a0 10 st %g1, [ %o2 + 0x10 ]
read_extended_partition(fd, start, new_part_desc);
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
40005960: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
40005964: de 02 a0 04 ld [ %o2 + 4 ], %o7
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
40005968: c8 02 a0 08 ld [ %o2 + 8 ], %g4
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
new_part_desc->log_id = ++disk_desc->last_log_id;
4000596c: 84 00 e0 01 add %g3, 1, %g2
read_extended_partition(fd, start, new_part_desc);
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
40005970: 86 00 e0 0a add %g3, 0xa, %g3
new_part_desc->log_id = ++disk_desc->last_log_id;
40005974: c4 20 60 24 st %g2, [ %g1 + 0x24 ]
read_extended_partition(fd, start, new_part_desc);
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
40005978: 87 28 e0 02 sll %g3, 2, %g3
4000597c: d4 20 40 03 st %o2, [ %g1 + %g3 ]
new_part_desc->log_id = ++disk_desc->last_log_id;
40005980: c4 2a a0 02 stb %g2, [ %o2 + 2 ]
new_part_desc->start += here;
40005984: 82 04 00 0f add %l0, %o7, %g1
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
40005988: 84 01 3f ff add %g4, -1, %g2
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
4000598c: c2 22 a0 04 st %g1, [ %o2 + 4 ]
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
40005990: 82 00 80 01 add %g2, %g1, %g1
40005994: c2 22 a0 0c st %g1, [ %o2 + 0xc ]
40005998: 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++)
4000599c: 80 a7 00 11 cmp %i4, %l1
400059a0: 12 bf ff df bne 4000591c <read_extended_partition+0xc8>
400059a4: b6 06 e0 10 add %i3, 0x10, %i3
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
400059a8: 40 00 02 ec call 40006558 <free>
400059ac: d0 07 bf f8 ld [ %fp + -8 ], %o0
400059b0: 81 c7 e0 08 ret
400059b4: 81 e8 00 00 restore
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
{
new_part_desc->log_id = EMPTY_PARTITION;
new_part_desc->start += start;
400059b8: c2 02 a0 04 ld [ %o2 + 4 ], %g1
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
{
new_part_desc->log_id = EMPTY_PARTITION;
400059bc: c0 2a a0 02 clrb [ %o2 + 2 ]
new_part_desc->start += start;
400059c0: 82 00 40 19 add %g1, %i1, %g1
read_extended_partition(fd, start, new_part_desc);
400059c4: 90 10 00 1d mov %i5, %o0
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
{
new_part_desc->log_id = EMPTY_PARTITION;
new_part_desc->start += start;
400059c8: c2 22 a0 04 st %g1, [ %o2 + 4 ]
read_extended_partition(fd, start, new_part_desc);
400059cc: 7f ff ff a2 call 40005854 <read_extended_partition>
400059d0: 92 10 00 19 mov %i1, %o1
400059d4: 10 bf ff f2 b 4000599c <read_extended_partition+0x148>
400059d8: b8 07 20 04 add %i4, 4, %i4
40005acc <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
40005acc: 9d e3 bf a0 save %sp, -96, %sp
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
40005ad0: 03 10 00 62 sethi %hi(0x40018800), %g1
40005ad4: c2 00 61 d4 ld [ %g1 + 0x1d4 ], %g1 ! 400189d4 <rtems_libio_number_iops>
40005ad8: 80 a6 00 01 cmp %i0, %g1
40005adc: 1a 80 00 45 bcc 40005bf0 <readv+0x124>
40005ae0: 03 10 00 65 sethi %hi(0x40019400), %g1
iop = rtems_libio_iop( fd );
40005ae4: f6 00 61 30 ld [ %g1 + 0x130 ], %i3 ! 40019530 <rtems_libio_iops>
40005ae8: 83 2e 20 03 sll %i0, 3, %g1
40005aec: b1 2e 20 06 sll %i0, 6, %i0
40005af0: b0 26 00 01 sub %i0, %g1, %i0
40005af4: b6 06 c0 18 add %i3, %i0, %i3
rtems_libio_check_is_open( iop );
40005af8: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
40005afc: 80 88 61 00 btst 0x100, %g1
40005b00: 02 80 00 3c be 40005bf0 <readv+0x124>
40005b04: 80 88 60 02 btst 2, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
40005b08: 02 80 00 3a be 40005bf0 <readv+0x124> <== NEVER TAKEN
40005b0c: 80 a6 60 00 cmp %i1, 0
/*
* Argument validation on IO vector
*/
if ( !iov )
40005b10: 02 80 00 32 be 40005bd8 <readv+0x10c>
40005b14: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
40005b18: 04 80 00 30 ble 40005bd8 <readv+0x10c>
40005b1c: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
40005b20: 14 80 00 2e bg 40005bd8 <readv+0x10c> <== NEVER TAKEN
40005b24: b5 2e a0 03 sll %i2, 3, %i2
*
* OpenGroup URL:
*
* http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
*/
ssize_t readv(
40005b28: 82 10 20 00 clr %g1
40005b2c: ba 10 20 01 mov 1, %i5
40005b30: 10 80 00 03 b 40005b3c <readv+0x70>
40005b34: 84 10 20 00 clr %g2
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
40005b38: 84 10 00 04 mov %g4, %g2
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
40005b3c: c6 06 40 01 ld [ %i1 + %g1 ], %g3
40005b40: 80 a0 e0 00 cmp %g3, 0
40005b44: 02 80 00 25 be 40005bd8 <readv+0x10c>
40005b48: 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;
40005b4c: c6 01 20 04 ld [ %g4 + 4 ], %g3
40005b50: 88 00 c0 02 add %g3, %g2, %g4
if ( total < old )
40005b54: 80 a1 00 02 cmp %g4, %g2
40005b58: 06 80 00 20 bl 40005bd8 <readv+0x10c>
40005b5c: 82 00 60 08 add %g1, 8, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
40005b60: 80 a0 00 03 cmp %g0, %g3
40005b64: 84 40 3f ff addx %g0, -1, %g2
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
40005b68: 80 a0 40 1a cmp %g1, %i2
40005b6c: 12 bf ff f3 bne 40005b38 <readv+0x6c>
40005b70: ba 0f 40 02 and %i5, %g2, %i5
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
40005b74: 80 8f 60 ff btst 0xff, %i5
40005b78: 12 80 00 16 bne 40005bd0 <readv+0x104>
40005b7c: b0 10 20 00 clr %i0
40005b80: ba 10 20 00 clr %i5
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
40005b84: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
*
* OpenGroup URL:
*
* http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
*/
ssize_t readv(
40005b88: b8 06 40 1d add %i1, %i5, %i4
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
40005b8c: d2 06 40 1d ld [ %i1 + %i5 ], %o1
40005b90: c2 00 60 08 ld [ %g1 + 8 ], %g1
40005b94: d4 07 20 04 ld [ %i4 + 4 ], %o2
40005b98: 9f c0 40 00 call %g1
40005b9c: 90 10 00 1b mov %i3, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
40005ba0: 80 a2 20 00 cmp %o0, 0
40005ba4: 26 80 00 0b bl,a 40005bd0 <readv+0x104> <== NEVER TAKEN
40005ba8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
40005bac: 32 80 00 02 bne,a 40005bb4 <readv+0xe8> <== ALWAYS TAKEN
40005bb0: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
40005bb4: c2 07 20 04 ld [ %i4 + 4 ], %g1
40005bb8: 80 a2 00 01 cmp %o0, %g1
40005bbc: 12 80 00 05 bne 40005bd0 <readv+0x104> <== NEVER TAKEN
40005bc0: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
40005bc4: 80 a6 80 1d cmp %i2, %i5
40005bc8: 32 bf ff f0 bne,a 40005b88 <readv+0xbc>
40005bcc: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
40005bd0: 81 c7 e0 08 ret
40005bd4: 81 e8 00 00 restore
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
40005bd8: 40 00 2d ab call 40011284 <__errno>
40005bdc: b0 10 3f ff mov -1, %i0
40005be0: 82 10 20 16 mov 0x16, %g1
40005be4: c2 22 00 00 st %g1, [ %o0 ]
40005be8: 81 c7 e0 08 ret
40005bec: 81 e8 00 00 restore
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
40005bf0: 40 00 2d a5 call 40011284 <__errno>
40005bf4: b0 10 3f ff mov -1, %i0
40005bf8: 82 10 20 09 mov 9, %g1
40005bfc: c2 22 00 00 st %g1, [ %o0 ]
40005c00: 81 c7 e0 08 ret
40005c04: 81 e8 00 00 restore
4001c9cc <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
4001c9cc: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
4001c9d0: 3b 10 00 80 sethi %hi(0x40020000), %i5
4001c9d4: ba 17 61 30 or %i5, 0x130, %i5 ! 40020130 <rtems_malloc_statistics>
4001c9d8: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
4001c9dc: 03 10 00 81 sethi %hi(0x40020400), %g1
4001c9e0: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 400207b8 <_System_state_Current>
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
4001c9e4: 84 00 a0 01 inc %g2
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
4001c9e8: 80 a0 60 03 cmp %g1, 3
4001c9ec: 02 80 00 2a be 4001ca94 <realloc+0xc8>
4001c9f0: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
}
/*
* Continue with realloc().
*/
if ( !ptr )
4001c9f4: 80 a6 20 00 cmp %i0, 0
4001c9f8: 02 80 00 46 be 4001cb10 <realloc+0x144>
4001c9fc: 80 a6 60 00 cmp %i1, 0
return malloc( size );
if ( !size ) {
4001ca00: 02 80 00 39 be 4001cae4 <realloc+0x118> <== NEVER TAKEN
4001ca04: 39 10 00 7d sethi %hi(0x4001f400), %i4
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
4001ca08: d0 07 21 60 ld [ %i4 + 0x160 ], %o0 ! 4001f560 <RTEMS_Malloc_Heap>
4001ca0c: 92 10 00 18 mov %i0, %o1
4001ca10: 40 00 01 d6 call 4001d168 <_Protected_heap_Get_block_size>
4001ca14: 94 07 bf fc add %fp, -4, %o2
4001ca18: 80 8a 20 ff btst 0xff, %o0
4001ca1c: 02 80 00 37 be 4001caf8 <realloc+0x12c>
4001ca20: d0 07 21 60 ld [ %i4 + 0x160 ], %o0
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
4001ca24: 92 10 00 18 mov %i0, %o1
4001ca28: 40 00 01 de call 4001d1a0 <_Protected_heap_Resize_block>
4001ca2c: 94 10 00 19 mov %i1, %o2
4001ca30: 80 8a 20 ff btst 0xff, %o0
4001ca34: 02 80 00 04 be 4001ca44 <realloc+0x78>
4001ca38: 01 00 00 00 nop
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
4001ca3c: 81 c7 e0 08 ret
4001ca40: 81 e8 00 00 restore
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
4001ca44: 7f ff 9e cb call 40004570 <malloc>
4001ca48: 90 10 00 19 mov %i1, %o0
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
4001ca4c: c2 07 60 04 ld [ %i5 + 4 ], %g1
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
4001ca50: b8 10 00 08 mov %o0, %i4
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
4001ca54: 82 00 7f ff add %g1, -1, %g1
if ( !new_area ) {
4001ca58: 80 a2 20 00 cmp %o0, 0
4001ca5c: 02 80 00 17 be 4001cab8 <realloc+0xec>
4001ca60: c2 27 60 04 st %g1, [ %i5 + 4 ]
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
4001ca64: c2 07 bf fc ld [ %fp + -4 ], %g1
4001ca68: 80 a6 40 01 cmp %i1, %g1
4001ca6c: 18 80 00 15 bgu 4001cac0 <realloc+0xf4> <== ALWAYS TAKEN
4001ca70: 94 10 00 19 mov %i1, %o2
4001ca74: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001ca78: 7f ff d2 03 call 40011284 <memcpy> <== NOT EXECUTED
4001ca7c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
free( ptr );
4001ca80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ca84: 7f ff 9d e1 call 40004208 <free> <== NOT EXECUTED
4001ca88: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
4001ca8c: 81 c7 e0 08 ret <== NOT EXECUTED
4001ca90: 81 e8 00 00 restore <== NOT EXECUTED
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
4001ca94: 03 10 00 80 sethi %hi(0x40020000), %g1
4001ca98: c2 00 62 b0 ld [ %g1 + 0x2b0 ], %g1 ! 400202b0 <_Thread_Dispatch_disable_level>
4001ca9c: 80 a0 60 00 cmp %g1, 0
4001caa0: 12 80 00 06 bne 4001cab8 <realloc+0xec> <== NEVER TAKEN
4001caa4: 03 10 00 81 sethi %hi(0x40020400), %g1
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
4001caa8: c2 00 63 c8 ld [ %g1 + 0x3c8 ], %g1 ! 400207c8 <_Per_CPU_Information+0x8>
4001caac: 80 a0 60 00 cmp %g1, 0
4001cab0: 02 bf ff d2 be 4001c9f8 <realloc+0x2c> <== ALWAYS TAKEN
4001cab4: 80 a6 20 00 cmp %i0, 0
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
4001cab8: 81 c7 e0 08 ret
4001cabc: 91 e8 20 00 restore %g0, 0, %o0
if ( !new_area ) {
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
4001cac0: 92 10 00 18 mov %i0, %o1
4001cac4: 94 10 00 01 mov %g1, %o2
4001cac8: 7f ff d1 ef call 40011284 <memcpy>
4001cacc: 90 10 00 1c mov %i4, %o0
free( ptr );
4001cad0: 90 10 00 18 mov %i0, %o0
4001cad4: 7f ff 9d cd call 40004208 <free>
4001cad8: b0 10 00 1c mov %i4, %i0
4001cadc: 81 c7 e0 08 ret
4001cae0: 81 e8 00 00 restore
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
4001cae4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001cae8: 7f ff 9d c8 call 40004208 <free> <== NOT EXECUTED
4001caec: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001caf0: 81 c7 e0 08 ret <== NOT EXECUTED
4001caf4: 81 e8 00 00 restore <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
4001caf8: 7f ff cf 92 call 40010940 <__errno>
4001cafc: b0 10 20 00 clr %i0
4001cb00: 82 10 20 16 mov 0x16, %g1
4001cb04: c2 22 00 00 st %g1, [ %o0 ]
4001cb08: 81 c7 e0 08 ret
4001cb0c: 81 e8 00 00 restore
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
4001cb10: 7f ff 9e 98 call 40004570 <malloc>
4001cb14: 91 e8 00 19 restore %g0, %i1, %o0
40008af4 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
40008af4: 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);
40008af8: 39 10 00 68 sethi %hi(0x4001a000), %i4
40008afc: 40 00 02 7b call 400094e8 <pthread_mutex_lock>
40008b00: 90 17 23 cc or %i4, 0x3cc, %o0 ! 4001a3cc <aio_request_queue>
if (result != 0) {
40008b04: b6 92 20 00 orcc %o0, 0, %i3
40008b08: 12 80 00 31 bne 40008bcc <rtems_aio_enqueue+0xd8> <== NEVER TAKEN
40008b0c: 90 10 00 18 mov %i0, %o0
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
40008b10: 40 00 04 b6 call 40009de8 <pthread_self>
40008b14: b2 17 23 cc or %i4, 0x3cc, %i1
40008b18: 92 07 bf e0 add %fp, -32, %o1
40008b1c: 40 00 03 a8 call 400099bc <pthread_getschedparam>
40008b20: 94 07 bf e4 add %fp, -28, %o2
req->caller_thread = pthread_self ();
40008b24: 40 00 04 b1 call 40009de8 <pthread_self>
40008b28: 01 00 00 00 nop
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
40008b2c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
req->policy = policy;
40008b30: c6 07 bf e0 ld [ %fp + -32 ], %g3
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
40008b34: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
req->policy = policy;
40008b38: c6 26 20 08 st %g3, [ %i0 + 8 ]
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
40008b3c: c6 07 bf e4 ld [ %fp + -28 ], %g3
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
40008b40: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
40008b44: 84 20 c0 02 sub %g3, %g2, %g2
40008b48: c4 26 20 0c st %g2, [ %i0 + 0xc ]
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
40008b4c: c4 06 60 68 ld [ %i1 + 0x68 ], %g2
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
40008b50: 86 10 20 77 mov 0x77, %g3
req->aiocbp->return_value = 0;
40008b54: c0 20 60 38 clr [ %g1 + 0x38 ]
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
40008b58: c6 20 60 34 st %g3, [ %g1 + 0x34 ]
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
40008b5c: 80 a0 a0 00 cmp %g2, 0
40008b60: 12 80 00 06 bne 40008b78 <rtems_aio_enqueue+0x84> <== NEVER TAKEN
40008b64: d2 00 40 00 ld [ %g1 ], %o1
40008b68: c4 06 60 64 ld [ %i1 + 0x64 ], %g2
40008b6c: 80 a0 a0 04 cmp %g2, 4
40008b70: 24 80 00 1b ble,a 40008bdc <rtems_aio_enqueue+0xe8>
40008b74: 90 06 60 48 add %i1, 0x48, %o0
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
40008b78: 94 10 20 00 clr %o2
40008b7c: 11 10 00 69 sethi %hi(0x4001a400), %o0
40008b80: 7f ff ff 78 call 40008960 <rtems_aio_search_fd>
40008b84: 90 12 20 14 or %o0, 0x14, %o0 ! 4001a414 <aio_request_queue+0x48>
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
40008b88: b4 92 20 00 orcc %o0, 0, %i2
40008b8c: 22 80 00 31 be,a 40008c50 <rtems_aio_enqueue+0x15c>
40008b90: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
{
pthread_mutex_lock (&r_chain->mutex);
40008b94: b2 06 a0 1c add %i2, 0x1c, %i1
40008b98: 40 00 02 54 call 400094e8 <pthread_mutex_lock>
40008b9c: 90 10 00 19 mov %i1, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
40008ba0: 90 06 a0 08 add %i2, 8, %o0
40008ba4: 7f ff ff 12 call 400087ec <rtems_aio_insert_prio>
40008ba8: 92 10 00 18 mov %i0, %o1
pthread_cond_signal (&r_chain->cond);
40008bac: 40 00 01 2c call 4000905c <pthread_cond_signal>
40008bb0: 90 06 a0 20 add %i2, 0x20, %o0
pthread_mutex_unlock (&r_chain->mutex);
40008bb4: 40 00 02 6d call 40009568 <pthread_mutex_unlock>
40008bb8: 90 10 00 19 mov %i1, %o0
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
40008bbc: 40 00 02 6b call 40009568 <pthread_mutex_unlock>
40008bc0: 90 17 23 cc or %i4, 0x3cc, %o0
return 0;
}
40008bc4: 81 c7 e0 08 ret
40008bc8: 91 e8 00 1b restore %g0, %i3, %o0
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
if (result != 0) {
free (req);
40008bcc: 7f ff ee 44 call 400044dc <free> <== NOT EXECUTED
40008bd0: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
return 0;
}
40008bd4: 81 c7 e0 08 ret <== NOT EXECUTED
40008bd8: 81 e8 00 00 restore <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
40008bdc: 7f ff ff 61 call 40008960 <rtems_aio_search_fd>
40008be0: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
40008be4: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
40008be8: 80 a0 60 01 cmp %g1, 1
40008bec: 12 bf ff ea bne 40008b94 <rtems_aio_enqueue+0xa0>
40008bf0: b4 10 00 08 mov %o0, %i2
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
40008bf4: 90 02 20 08 add %o0, 8, %o0
40008bf8: 40 00 09 44 call 4000b108 <_Chain_Insert>
40008bfc: 92 10 00 18 mov %i0, %o1
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
40008c00: 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;
40008c04: c0 26 a0 18 clr [ %i2 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
40008c08: 40 00 01 df call 40009384 <pthread_mutex_init>
40008c0c: 90 06 a0 1c add %i2, 0x1c, %o0
pthread_cond_init (&r_chain->cond, NULL);
40008c10: 92 10 20 00 clr %o1
40008c14: 40 00 00 e3 call 40008fa0 <pthread_cond_init>
40008c18: 90 06 a0 20 add %i2, 0x20, %o0
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
40008c1c: 90 07 bf dc add %fp, -36, %o0
40008c20: 92 06 60 08 add %i1, 8, %o1
40008c24: 96 10 00 1a mov %i2, %o3
40008c28: 15 10 00 21 sethi %hi(0x40008400), %o2
40008c2c: 40 00 02 c4 call 4000973c <pthread_create>
40008c30: 94 12 a1 40 or %o2, 0x140, %o2 ! 40008540 <rtems_aio_handle>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
40008c34: 82 92 20 00 orcc %o0, 0, %g1
40008c38: 12 80 00 25 bne 40008ccc <rtems_aio_enqueue+0x1d8> <== NEVER TAKEN
40008c3c: 90 10 00 19 mov %i1, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
++aio_request_queue.active_threads;
40008c40: c2 06 60 64 ld [ %i1 + 0x64 ], %g1
40008c44: 82 00 60 01 inc %g1
40008c48: 10 bf ff dd b 40008bbc <rtems_aio_enqueue+0xc8>
40008c4c: c2 26 60 64 st %g1, [ %i1 + 0x64 ]
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
40008c50: 11 10 00 69 sethi %hi(0x4001a400), %o0
40008c54: d2 00 40 00 ld [ %g1 ], %o1
40008c58: 90 12 20 20 or %o0, 0x20, %o0
40008c5c: 7f ff ff 41 call 40008960 <rtems_aio_search_fd>
40008c60: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
40008c64: 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);
40008c68: b4 10 00 08 mov %o0, %i2
40008c6c: 92 10 00 18 mov %i0, %o1
if (r_chain->new_fd == 1) {
40008c70: 80 a0 60 01 cmp %g1, 1
40008c74: 02 80 00 0b be 40008ca0 <rtems_aio_enqueue+0x1ac>
40008c78: 90 02 20 08 add %o0, 8, %o0
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
pthread_cond_init (&r_chain->cond, NULL);
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
40008c7c: 7f ff fe dc call 400087ec <rtems_aio_insert_prio>
40008c80: 01 00 00 00 nop
if (aio_request_queue.idle_threads > 0)
40008c84: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
40008c88: 80 a0 60 00 cmp %g1, 0
40008c8c: 04 bf ff cc ble 40008bbc <rtems_aio_enqueue+0xc8> <== ALWAYS TAKEN
40008c90: 01 00 00 00 nop
pthread_cond_signal (&aio_request_queue.new_req);
40008c94: 40 00 00 f2 call 4000905c <pthread_cond_signal> <== NOT EXECUTED
40008c98: 90 06 60 04 add %i1, 4, %o0 <== NOT EXECUTED
40008c9c: 30 bf ff c8 b,a 40008bbc <rtems_aio_enqueue+0xc8> <== NOT EXECUTED
40008ca0: 40 00 09 1a call 4000b108 <_Chain_Insert>
40008ca4: 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);
40008ca8: 90 06 a0 1c add %i2, 0x1c, %o0
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
40008cac: c0 26 a0 18 clr [ %i2 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
40008cb0: 40 00 01 b5 call 40009384 <pthread_mutex_init>
40008cb4: 92 10 20 00 clr %o1
pthread_cond_init (&r_chain->cond, NULL);
40008cb8: 90 06 a0 20 add %i2, 0x20, %o0
40008cbc: 40 00 00 b9 call 40008fa0 <pthread_cond_init>
40008cc0: 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)
40008cc4: 10 bf ff f1 b 40008c88 <rtems_aio_enqueue+0x194>
40008cc8: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
pthread_mutex_unlock (&aio_request_queue.mutex);
40008ccc: 40 00 02 27 call 40009568 <pthread_mutex_unlock> <== NOT EXECUTED
40008cd0: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED
40008cd4: 30 bf ff bc b,a 40008bc4 <rtems_aio_enqueue+0xd0> <== NOT EXECUTED
40008540 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
40008540: 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);
40008544: 35 10 00 68 sethi %hi(0x4001a000), %i2
40008548: b6 06 20 1c add %i0, 0x1c, %i3
4000854c: b4 16 a3 cc or %i2, 0x3cc, %i2
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
40008550: a0 10 00 1a mov %i2, %l0
40008554: a2 10 00 1a mov %i2, %l1
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
40008558: a4 06 a0 58 add %i2, 0x58, %l2
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
4000855c: b2 06 a0 4c add %i2, 0x4c, %i1
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
40008560: 40 00 03 e2 call 400094e8 <pthread_mutex_lock>
40008564: 90 10 00 1b mov %i3, %o0
if (result != 0)
40008568: 80 a2 20 00 cmp %o0, 0
4000856c: 12 80 00 2b bne 40008618 <rtems_aio_handle+0xd8> <== NEVER TAKEN
40008570: 01 00 00 00 nop
40008574: fa 06 20 08 ld [ %i0 + 8 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
40008578: 82 06 20 0c add %i0, 0xc, %g1
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
4000857c: 80 a7 40 01 cmp %i5, %g1
40008580: 02 80 00 41 be 40008684 <rtems_aio_handle+0x144>
40008584: 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);
40008588: 40 00 06 18 call 40009de8 <pthread_self>
4000858c: 01 00 00 00 nop
40008590: 92 07 bf d8 add %fp, -40, %o1
40008594: 40 00 05 0a call 400099bc <pthread_getschedparam>
40008598: 94 07 bf e4 add %fp, -28, %o2
param.sched_priority = req->priority;
4000859c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
pthread_setschedparam (pthread_self(), req->policy, ¶m);
400085a0: 40 00 06 12 call 40009de8 <pthread_self>
400085a4: c2 27 bf e4 st %g1, [ %fp + -28 ]
400085a8: d2 07 60 08 ld [ %i5 + 8 ], %o1
400085ac: 40 00 06 13 call 40009df8 <pthread_setschedparam>
400085b0: 94 07 bf e4 add %fp, -28, %o2
400085b4: 40 00 0a bc call 4000b0a4 <_Chain_Extract>
400085b8: 90 10 00 1d mov %i5, %o0
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
400085bc: 40 00 03 eb call 40009568 <pthread_mutex_unlock>
400085c0: 90 10 00 1b mov %i3, %o0
switch (req->aiocbp->aio_lio_opcode) {
400085c4: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
400085c8: c2 07 20 30 ld [ %i4 + 0x30 ], %g1
400085cc: 80 a0 60 02 cmp %g1, 2
400085d0: 22 80 00 25 be,a 40008664 <rtems_aio_handle+0x124>
400085d4: c4 1f 20 08 ldd [ %i4 + 8 ], %g2
400085d8: 80 a0 60 03 cmp %g1, 3
400085dc: 02 80 00 1e be 40008654 <rtems_aio_handle+0x114> <== NEVER TAKEN
400085e0: 01 00 00 00 nop
400085e4: 80 a0 60 01 cmp %g1, 1
400085e8: 22 80 00 0e be,a 40008620 <rtems_aio_handle+0xe0> <== ALWAYS TAKEN
400085ec: c4 1f 20 08 ldd [ %i4 + 8 ], %g2
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
400085f0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
req->aiocbp->error_code = errno;
400085f4: 40 00 29 13 call 40012a40 <__errno> <== NOT EXECUTED
400085f8: c2 27 20 38 st %g1, [ %i4 + 0x38 ] <== NOT EXECUTED
400085fc: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
40008600: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40008604: 40 00 03 b9 call 400094e8 <pthread_mutex_lock> <== NOT EXECUTED
40008608: c2 27 20 34 st %g1, [ %i4 + 0x34 ] <== NOT EXECUTED
if (result != 0)
4000860c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40008610: 22 bf ff da be,a 40008578 <rtems_aio_handle+0x38> <== NOT EXECUTED
40008614: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
40008618: 81 c7 e0 08 ret
4000861c: 91 e8 20 00 restore %g0, 0, %o0
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
40008620: d0 07 00 00 ld [ %i4 ], %o0
40008624: d2 07 20 10 ld [ %i4 + 0x10 ], %o1
40008628: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
4000862c: 96 10 00 02 mov %g2, %o3
40008630: 40 00 2b f0 call 400135f0 <pread>
40008634: 98 10 00 03 mov %g3, %o4
break;
default:
result = -1;
}
if (result == -1) {
40008638: 80 a2 3f ff cmp %o0, -1
4000863c: 22 bf ff ed be,a 400085f0 <rtems_aio_handle+0xb0> <== NEVER TAKEN
40008640: f8 07 60 14 ld [ %i5 + 0x14 ], %i4 <== NOT EXECUTED
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
40008644: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40008648: d0 20 60 38 st %o0, [ %g1 + 0x38 ]
req->aiocbp->error_code = 0;
4000864c: 10 bf ff c5 b 40008560 <rtems_aio_handle+0x20>
40008650: c0 20 60 34 clr [ %g1 + 0x34 ]
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
40008654: 40 00 1b 79 call 4000f438 <fsync> <== NOT EXECUTED
40008658: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
break;
4000865c: 10 bf ff f8 b 4000863c <rtems_aio_handle+0xfc> <== NOT EXECUTED
40008660: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
40008664: d0 07 00 00 ld [ %i4 ], %o0
40008668: d2 07 20 10 ld [ %i4 + 0x10 ], %o1
4000866c: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
40008670: 96 10 00 02 mov %g2, %o3
40008674: 40 00 2c 1d call 400136e8 <pwrite>
40008678: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
4000867c: 10 bf ff f0 b 4000863c <rtems_aio_handle+0xfc>
40008680: 80 a2 3f ff cmp %o0, -1
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
40008684: 40 00 03 b9 call 40009568 <pthread_mutex_unlock>
40008688: 90 10 00 1b mov %i3, %o0
pthread_mutex_lock (&aio_request_queue.mutex);
4000868c: 40 00 03 97 call 400094e8 <pthread_mutex_lock>
40008690: 90 10 00 1a mov %i2, %o0
if (rtems_chain_is_empty (chain))
40008694: c2 06 20 08 ld [ %i0 + 8 ], %g1
40008698: 80 a7 40 01 cmp %i5, %g1
4000869c: 02 80 00 05 be 400086b0 <rtems_aio_handle+0x170> <== ALWAYS TAKEN
400086a0: 92 07 bf dc add %fp, -36, %o1
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
400086a4: 40 00 03 b1 call 40009568 <pthread_mutex_unlock>
400086a8: 90 10 00 1a mov %i2, %o0
400086ac: 30 bf ff ad b,a 40008560 <rtems_aio_handle+0x20>
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
400086b0: 40 00 01 d3 call 40008dfc <clock_gettime>
400086b4: 90 10 20 01 mov 1, %o0
timeout.tv_sec += 3;
400086b8: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
400086bc: 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;
400086c0: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
400086c4: ba 06 20 20 add %i0, 0x20, %i5
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
400086c8: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
400086cc: 90 10 00 1d mov %i5, %o0
400086d0: 92 10 00 10 mov %l0, %o1
400086d4: 40 00 02 7e call 400090cc <pthread_cond_timedwait>
400086d8: 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) {
400086dc: 80 a2 20 74 cmp %o0, 0x74
400086e0: 12 bf ff f1 bne 400086a4 <rtems_aio_handle+0x164> <== NEVER TAKEN
400086e4: 01 00 00 00 nop
400086e8: 40 00 0a 6f call 4000b0a4 <_Chain_Extract>
400086ec: 90 10 00 18 mov %i0, %o0
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
400086f0: 40 00 02 d2 call 40009238 <pthread_mutex_destroy>
400086f4: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->cond);
400086f8: 40 00 01 f4 call 40008ec8 <pthread_cond_destroy>
400086fc: 90 10 00 1d mov %i5, %o0
free (r_chain);
40008700: 7f ff ef 77 call 400044dc <free>
40008704: 90 10 00 18 mov %i0, %o0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
40008708: f0 06 a0 54 ld [ %i2 + 0x54 ], %i0
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
4000870c: 80 a6 00 12 cmp %i0, %l2
40008710: 22 80 00 1d be,a 40008784 <rtems_aio_handle+0x244>
40008714: c4 06 a0 68 ld [ %i2 + 0x68 ], %g2
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
40008718: c4 04 60 68 ld [ %l1 + 0x68 ], %g2
++aio_request_queue.active_threads;
4000871c: c2 04 60 64 ld [ %l1 + 0x64 ], %g1
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
40008720: 84 00 bf ff add %g2, -1, %g2
++aio_request_queue.active_threads;
40008724: 82 00 60 01 inc %g1
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
40008728: c4 24 60 68 st %g2, [ %l1 + 0x68 ]
++aio_request_queue.active_threads;
4000872c: c2 24 60 64 st %g1, [ %l1 + 0x64 ]
40008730: 40 00 0a 5d call 4000b0a4 <_Chain_Extract>
40008734: 90 10 00 18 mov %i0, %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
40008738: c2 04 60 48 ld [ %l1 + 0x48 ], %g1
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
4000873c: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
40008740: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
40008744: 80 a0 c0 02 cmp %g3, %g2
40008748: 14 80 00 08 bg 40008768 <rtems_aio_handle+0x228> <== ALWAYS TAKEN
4000874c: 80 a0 40 19 cmp %g1, %i1
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
40008750: 10 80 00 09 b 40008774 <rtems_aio_handle+0x234> <== NOT EXECUTED
40008754: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
40008758: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000875c: 80 a0 80 03 cmp %g2, %g3
40008760: 16 80 00 04 bge 40008770 <rtems_aio_handle+0x230>
40008764: 80 a0 40 19 cmp %g1, %i1
40008768: 32 bf ff fc bne,a 40008758 <rtems_aio_handle+0x218> <== ALWAYS TAKEN
4000876c: c2 00 40 00 ld [ %g1 ], %g1
40008770: d0 00 60 04 ld [ %g1 + 4 ], %o0
40008774: 92 10 00 18 mov %i0, %o1
40008778: 40 00 0a 64 call 4000b108 <_Chain_Insert>
4000877c: b6 06 20 1c add %i0, 0x1c, %i3
40008780: 30 bf ff c9 b,a 400086a4 <rtems_aio_handle+0x164>
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
40008784: c2 06 a0 64 ld [ %i2 + 0x64 ], %g1
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
40008788: 84 00 a0 01 inc %g2
--aio_request_queue.active_threads;
4000878c: 82 00 7f ff add %g1, -1, %g1
clock_gettime (CLOCK_REALTIME, &timeout);
40008790: 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;
40008794: c4 26 a0 68 st %g2, [ %i2 + 0x68 ]
--aio_request_queue.active_threads;
40008798: c2 26 a0 64 st %g1, [ %i2 + 0x64 ]
clock_gettime (CLOCK_REALTIME, &timeout);
4000879c: 40 00 01 98 call 40008dfc <clock_gettime>
400087a0: 90 10 20 01 mov 1, %o0
timeout.tv_sec += 3;
400087a4: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
400087a8: 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;
400087ac: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
400087b0: 90 06 a0 04 add %i2, 4, %o0
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
400087b4: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
400087b8: 92 10 00 1a mov %i2, %o1
400087bc: 40 00 02 44 call 400090cc <pthread_cond_timedwait>
400087c0: 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) {
400087c4: 80 a2 20 74 cmp %o0, 0x74
400087c8: 22 80 00 04 be,a 400087d8 <rtems_aio_handle+0x298> <== ALWAYS TAKEN
400087cc: c2 06 a0 68 ld [ %i2 + 0x68 ], %g1
400087d0: 10 bf ff d2 b 40008718 <rtems_aio_handle+0x1d8> <== NOT EXECUTED
400087d4: f0 06 a0 54 ld [ %i2 + 0x54 ], %i0 <== NOT EXECUTED
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
pthread_mutex_unlock (&aio_request_queue.mutex);
400087d8: 90 10 00 1a mov %i2, %o0
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
400087dc: 82 00 7f ff add %g1, -1, %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
400087e0: 40 00 03 62 call 40009568 <pthread_mutex_unlock>
400087e4: c2 26 a0 68 st %g1, [ %i2 + 0x68 ]
400087e8: 30 bf ff 8c b,a 40008618 <rtems_aio_handle+0xd8>
40008858 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
40008858: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
4000885c: 3b 10 00 68 sethi %hi(0x4001a000), %i5
40008860: 40 00 03 9c call 400096d0 <pthread_attr_init>
40008864: 90 17 63 d4 or %i5, 0x3d4, %o0 ! 4001a3d4 <aio_request_queue+0x8>
if (result != 0)
40008868: b0 92 20 00 orcc %o0, 0, %i0
4000886c: 12 80 00 23 bne 400088f8 <rtems_aio_init+0xa0> <== NEVER TAKEN
40008870: 90 17 63 d4 or %i5, 0x3d4, %o0
return result;
result =
40008874: 40 00 03 a3 call 40009700 <pthread_attr_setdetachstate>
40008878: 92 10 20 00 clr %o1
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
4000887c: 80 a2 20 00 cmp %o0, 0
40008880: 12 80 00 20 bne 40008900 <rtems_aio_init+0xa8> <== NEVER TAKEN
40008884: 39 10 00 68 sethi %hi(0x4001a000), %i4
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
40008888: 92 10 20 00 clr %o1
4000888c: 40 00 02 be call 40009384 <pthread_mutex_init>
40008890: 90 17 23 cc or %i4, 0x3cc, %o0
if (result != 0)
40008894: 80 a2 20 00 cmp %o0, 0
40008898: 12 80 00 23 bne 40008924 <rtems_aio_init+0xcc> <== NEVER TAKEN
4000889c: 92 10 20 00 clr %o1
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
400088a0: 11 10 00 68 sethi %hi(0x4001a000), %o0
400088a4: 40 00 01 bf call 40008fa0 <pthread_cond_init>
400088a8: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 4001a3d0 <aio_request_queue+0x4>
if (result != 0) {
400088ac: b0 92 20 00 orcc %o0, 0, %i0
400088b0: 12 80 00 26 bne 40008948 <rtems_aio_init+0xf0> <== NEVER TAKEN
400088b4: 01 00 00 00 nop
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
400088b8: 82 17 23 cc or %i4, 0x3cc, %g1
head->previous = NULL;
tail->previous = head;
400088bc: 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;
400088c0: ba 00 60 4c add %g1, 0x4c, %i5
head->previous = NULL;
tail->previous = head;
400088c4: 88 00 60 48 add %g1, 0x48, %g4
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
400088c8: 86 00 60 58 add %g1, 0x58, %g3
head->previous = NULL;
tail->previous = head;
400088cc: 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;
400088d0: fa 20 60 48 st %i5, [ %g1 + 0x48 ]
head->previous = NULL;
400088d4: c0 20 60 4c clr [ %g1 + 0x4c ]
tail->previous = head;
400088d8: c8 20 60 50 st %g4, [ %g1 + 0x50 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
400088dc: c6 20 60 54 st %g3, [ %g1 + 0x54 ]
head->previous = NULL;
400088e0: 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;
400088e4: c0 20 60 64 clr [ %g1 + 0x64 ]
aio_request_queue.idle_threads = 0;
400088e8: c0 20 60 68 clr [ %g1 + 0x68 ]
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
400088ec: 05 00 00 2c sethi %hi(0xb000), %g2
400088f0: 84 10 a0 0b or %g2, 0xb, %g2 ! b00b <PROM_START+0xb00b>
400088f4: c4 20 60 60 st %g2, [ %g1 + 0x60 ]
return result;
}
400088f8: 81 c7 e0 08 ret
400088fc: 81 e8 00 00 restore
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
40008900: 40 00 03 68 call 400096a0 <pthread_attr_destroy> <== NOT EXECUTED
40008904: 90 17 63 d4 or %i5, 0x3d4, %o0 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
40008908: 39 10 00 68 sethi %hi(0x4001a000), %i4 <== NOT EXECUTED
4000890c: 92 10 20 00 clr %o1 <== NOT EXECUTED
40008910: 40 00 02 9d call 40009384 <pthread_mutex_init> <== NOT EXECUTED
40008914: 90 17 23 cc or %i4, 0x3cc, %o0 <== NOT EXECUTED
if (result != 0)
40008918: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000891c: 02 bf ff e1 be 400088a0 <rtems_aio_init+0x48> <== NOT EXECUTED
40008920: 92 10 20 00 clr %o1 <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
40008924: 40 00 03 5f call 400096a0 <pthread_attr_destroy> <== NOT EXECUTED
40008928: 90 17 63 d4 or %i5, 0x3d4, %o0 <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
4000892c: 92 10 20 00 clr %o1 <== NOT EXECUTED
40008930: 11 10 00 68 sethi %hi(0x4001a000), %o0 <== NOT EXECUTED
40008934: 40 00 01 9b call 40008fa0 <pthread_cond_init> <== NOT EXECUTED
40008938: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 4001a3d0 <aio_request_queue+0x4><== NOT EXECUTED
if (result != 0) {
4000893c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40008940: 22 bf ff df be,a 400088bc <rtems_aio_init+0x64> <== NOT EXECUTED
40008944: 82 17 23 cc or %i4, 0x3cc, %g1 <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
40008948: 40 00 02 3c call 40009238 <pthread_mutex_destroy> <== NOT EXECUTED
4000894c: 90 17 23 cc or %i4, 0x3cc, %o0 <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
40008950: 40 00 03 54 call 400096a0 <pthread_attr_destroy> <== NOT EXECUTED
40008954: 90 17 63 d4 or %i5, 0x3d4, %o0 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
40008958: 10 bf ff d9 b 400088bc <rtems_aio_init+0x64> <== NOT EXECUTED
4000895c: 82 17 23 cc or %i4, 0x3cc, %g1 <== NOT EXECUTED
400087ec <rtems_aio_insert_prio>:
400087ec: 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 );
400087f0: 88 02 20 04 add %o0, 4, %g4
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
400087f4: 80 a0 40 04 cmp %g1, %g4
400087f8: 02 80 00 15 be 4000884c <rtems_aio_insert_prio+0x60> <== NEVER TAKEN
400087fc: 9a 10 00 09 mov %o1, %o5
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
40008800: c6 02 60 14 ld [ %o1 + 0x14 ], %g3
if (rtems_chain_is_empty (chain)) {
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
40008804: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
while (req->aiocbp->aio_reqprio > prio &&
40008808: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3
4000880c: c4 00 a0 18 ld [ %g2 + 0x18 ], %g2
40008810: 80 a0 80 03 cmp %g2, %g3
40008814: 26 80 00 07 bl,a 40008830 <rtems_aio_insert_prio+0x44> <== NEVER TAKEN
40008818: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
4000881c: 10 80 00 0b b 40008848 <rtems_aio_insert_prio+0x5c>
40008820: d0 00 60 04 ld [ %g1 + 4 ], %o0
40008824: 22 80 00 09 be,a 40008848 <rtems_aio_insert_prio+0x5c> <== NOT EXECUTED
40008828: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000882c: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
40008830: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
40008834: c4 00 a0 18 ld [ %g2 + 0x18 ], %g2 <== NOT EXECUTED
40008838: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
4000883c: 06 bf ff fa bl 40008824 <rtems_aio_insert_prio+0x38> <== NOT EXECUTED
40008840: 80 a1 00 01 cmp %g4, %g1 <== NOT EXECUTED
40008844: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
40008848: 92 10 00 0d mov %o5, %o1
4000884c: 82 13 c0 00 mov %o7, %g1
40008850: 40 00 0a 2e call 4000b108 <_Chain_Insert>
40008854: 9e 10 40 00 mov %g1, %o7
40008a34 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
40008a34: 9d e3 bf a0 save %sp, -96, %sp
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
40008a38: fa 06 20 08 ld [ %i0 + 8 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
40008a3c: b0 06 20 0c add %i0, 0xc, %i0
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
40008a40: 80 a7 40 18 cmp %i5, %i0
40008a44: 02 80 00 0e be 40008a7c <rtems_aio_remove_fd+0x48> <== NEVER TAKEN
40008a48: b6 10 20 8c mov 0x8c, %i3
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
40008a4c: 40 00 09 96 call 4000b0a4 <_Chain_Extract>
40008a50: 90 10 00 1d mov %i5, %o0
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
40008a54: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
40008a58: f8 07 40 00 ld [ %i5 ], %i4
req->aiocbp->return_value = -1;
40008a5c: 84 10 3f ff mov -1, %g2
free (req);
40008a60: 90 10 00 1d mov %i5, %o0
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
40008a64: f6 20 60 34 st %i3, [ %g1 + 0x34 ]
req->aiocbp->return_value = -1;
free (req);
40008a68: 7f ff ee 9d call 400044dc <free>
40008a6c: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
40008a70: 80 a7 00 18 cmp %i4, %i0
40008a74: 12 bf ff f6 bne 40008a4c <rtems_aio_remove_fd+0x18>
40008a78: ba 10 00 1c mov %i4, %i5
40008a7c: 81 c7 e0 08 ret
40008a80: 81 e8 00 00 restore
40008a84 <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)
{
40008a84: 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;
40008a88: 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 );
40008a8c: 84 06 20 04 add %i0, 4, %g2
if (rtems_chain_is_empty (chain))
40008a90: 80 a7 40 02 cmp %i5, %g2
40008a94: 12 80 00 06 bne 40008aac <rtems_aio_remove_req+0x28>
40008a98: b0 10 20 02 mov 2, %i0
40008a9c: 30 80 00 12 b,a 40008ae4 <rtems_aio_remove_req+0x60>
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
40008aa0: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED
40008aa4: 02 80 00 12 be 40008aec <rtems_aio_remove_req+0x68> <== NOT EXECUTED
40008aa8: 01 00 00 00 nop <== NOT EXECUTED
40008aac: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40008ab0: 80 a0 40 19 cmp %g1, %i1
40008ab4: 32 bf ff fb bne,a 40008aa0 <rtems_aio_remove_req+0x1c> <== NEVER TAKEN
40008ab8: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
40008abc: 40 00 09 7a call 4000b0a4 <_Chain_Extract>
40008ac0: 90 10 00 1d mov %i5, %o0
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
40008ac4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
current->aiocbp->return_value = -1;
40008ac8: 84 10 3f ff mov -1, %g2
40008acc: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
40008ad0: 84 10 20 8c mov 0x8c, %g2
current->aiocbp->return_value = -1;
free (current);
40008ad4: 90 10 00 1d mov %i5, %o0
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
40008ad8: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
current->aiocbp->return_value = -1;
free (current);
40008adc: 7f ff ee 80 call 400044dc <free>
40008ae0: b0 10 20 00 clr %i0
}
return AIO_CANCELED;
}
40008ae4: 81 c7 e0 08 ret
40008ae8: 81 e8 00 00 restore
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
40008aec: 81 c7 e0 08 ret <== NOT EXECUTED
40008af0: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
4000fecc <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000fecc: 9d e3 bf a0 save %sp, -96, %sp
4000fed0: b8 10 20 20 mov 0x20, %i4
uint32_t b;
uint32_t local_value = 0;
4000fed4: b6 10 20 00 clr %i3
for (b = 1; b; b <<= 1) {
4000fed8: 10 80 00 04 b 4000fee8 <rtems_assoc_local_by_remote_bitfield+0x1c>
4000fedc: ba 10 20 01 mov 1, %i5
4000fee0: 02 80 00 0c be 4000ff10 <rtems_assoc_local_by_remote_bitfield+0x44>
4000fee4: bb 2f 60 01 sll %i5, 1, %i5
if (b & remote_value)
4000fee8: 80 8f 40 19 btst %i5, %i1
4000feec: 22 bf ff fd be,a 4000fee0 <rtems_assoc_local_by_remote_bitfield+0x14>
4000fef0: b8 87 3f ff addcc %i4, -1, %i4
local_value |= rtems_assoc_local_by_remote(ap, b);
4000fef4: 92 10 00 1d mov %i5, %o1
4000fef8: 7f ff f3 d4 call 4000ce48 <rtems_assoc_local_by_remote>
4000fefc: 90 10 00 18 mov %i0, %o0
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
4000ff00: bb 2f 60 01 sll %i5, 1, %i5
4000ff04: b8 87 3f ff addcc %i4, -1, %i4
4000ff08: 12 bf ff f8 bne 4000fee8 <rtems_assoc_local_by_remote_bitfield+0x1c><== ALWAYS TAKEN
4000ff0c: b6 16 c0 08 or %i3, %o0, %i3
if (b & remote_value)
local_value |= rtems_assoc_local_by_remote(ap, b);
}
return local_value;
}
4000ff10: 81 c7 e0 08 ret
4000ff14: 91 e8 00 1b restore %g0, %i3, %o0
4000cea8 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
4000cea8: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
4000ceac: d0 06 00 00 ld [ %i0 ], %o0
4000ceb0: 80 a2 20 00 cmp %o0, 0
4000ceb4: 02 80 00 1d be 4000cf28 <rtems_assoc_ptr_by_local+0x80>
4000ceb8: 13 10 00 79 sethi %hi(0x4001e400), %o1
4000cebc: 40 00 12 3b call 400117a8 <strcmp>
4000cec0: 92 12 61 18 or %o1, 0x118, %o1 ! 4001e518 <IMFS_memfile_handlers+0x30>
4000cec4: 80 a2 20 00 cmp %o0, 0
4000cec8: 22 80 00 12 be,a 4000cf10 <rtems_assoc_ptr_by_local+0x68>
4000cecc: c4 06 20 0c ld [ %i0 + 0xc ], %g2
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
const rtems_assoc_t *default_ap = 0;
4000ced0: 84 10 20 00 clr %g2
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
4000ced4: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000ced8: 80 a0 40 19 cmp %g1, %i1
4000cedc: 32 80 00 07 bne,a 4000cef8 <rtems_assoc_ptr_by_local+0x50>
4000cee0: b0 06 20 0c add %i0, 0xc, %i0
4000cee4: 30 80 00 13 b,a 4000cf30 <rtems_assoc_ptr_by_local+0x88>
4000cee8: 80 a0 40 19 cmp %g1, %i1
4000ceec: 02 80 00 11 be 4000cf30 <rtems_assoc_ptr_by_local+0x88>
4000cef0: 01 00 00 00 nop
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
4000cef4: b0 06 20 0c add %i0, 0xc, %i0
4000cef8: c2 06 00 00 ld [ %i0 ], %g1
4000cefc: 80 a0 60 00 cmp %g1, 0
4000cf00: 32 bf ff fa bne,a 4000cee8 <rtems_assoc_ptr_by_local+0x40>
4000cf04: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000cf08: 81 c7 e0 08 ret
4000cf0c: 91 e8 00 02 restore %g0, %g2, %o0
4000cf10: 80 a0 a0 00 cmp %g2, 0
4000cf14: 02 80 00 07 be 4000cf30 <rtems_assoc_ptr_by_local+0x88> <== NEVER TAKEN
4000cf18: 82 06 20 0c add %i0, 0xc, %g1
4000cf1c: 84 10 00 18 mov %i0, %g2
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
4000cf20: 10 bf ff ed b 4000ced4 <rtems_assoc_ptr_by_local+0x2c>
4000cf24: b0 10 00 01 mov %g1, %i0
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
return ap;
return default_ap;
}
4000cf28: 81 c7 e0 08 ret
4000cf2c: 91 e8 20 00 restore %g0, 0, %o0
4000cf30: 81 c7 e0 08 ret
4000cf34: 81 e8 00 00 restore
40004a68 <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
40004a68: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
40004a6c: fa 06 00 00 ld [ %i0 ], %i5
40004a70: 80 a7 60 00 cmp %i5, 0
40004a74: 02 80 00 1e be 40004aec <rtems_assoc_ptr_by_name+0x84>
40004a78: 90 10 00 1d mov %i5, %o0
40004a7c: 13 10 00 5c sethi %hi(0x40017000), %o1
40004a80: 40 00 34 9e call 40011cf8 <strcmp>
40004a84: 92 12 62 30 or %o1, 0x230, %o1 ! 40017230 <_rodata_start+0x780>
40004a88: 80 a2 20 00 cmp %o0, 0
40004a8c: 22 80 00 10 be,a 40004acc <rtems_assoc_ptr_by_name+0x64>
40004a90: fa 06 20 0c ld [ %i0 + 0xc ], %i5
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
40004a94: 10 80 00 06 b 40004aac <rtems_assoc_ptr_by_name+0x44>
40004a98: b8 10 20 00 clr %i4
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
40004a9c: fa 06 00 00 ld [ %i0 ], %i5
40004aa0: 80 a7 60 00 cmp %i5, 0
40004aa4: 02 80 00 10 be 40004ae4 <rtems_assoc_ptr_by_name+0x7c>
40004aa8: 01 00 00 00 nop
if (strcmp(ap->name, name) == 0)
40004aac: 90 10 00 1d mov %i5, %o0
40004ab0: 40 00 34 92 call 40011cf8 <strcmp>
40004ab4: 92 10 00 19 mov %i1, %o1
40004ab8: 80 a2 20 00 cmp %o0, 0
40004abc: 32 bf ff f8 bne,a 40004a9c <rtems_assoc_ptr_by_name+0x34>
40004ac0: b0 06 20 0c add %i0, 0xc, %i0
return ap;
return default_ap;
}
40004ac4: 81 c7 e0 08 ret
40004ac8: 81 e8 00 00 restore
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
40004acc: 80 a7 60 00 cmp %i5, 0
40004ad0: 02 bf ff fd be 40004ac4 <rtems_assoc_ptr_by_name+0x5c> <== NEVER TAKEN
40004ad4: 82 06 20 0c add %i0, 0xc, %g1
40004ad8: b8 10 00 18 mov %i0, %i4
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
40004adc: 10 bf ff f4 b 40004aac <rtems_assoc_ptr_by_name+0x44>
40004ae0: b0 10 00 01 mov %g1, %i0
for ( ; ap->name; ap++)
40004ae4: 81 c7 e0 08 ret
40004ae8: 91 e8 00 1c restore %g0, %i4, %o0
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
40004aec: 81 c7 e0 08 ret
40004af0: 91 e8 20 00 restore %g0, 0, %o0
4000cf38 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000cf38: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
4000cf3c: d0 06 00 00 ld [ %i0 ], %o0
4000cf40: 80 a2 20 00 cmp %o0, 0
4000cf44: 02 80 00 1d be 4000cfb8 <rtems_assoc_ptr_by_remote+0x80>
4000cf48: 13 10 00 79 sethi %hi(0x4001e400), %o1
4000cf4c: 40 00 12 17 call 400117a8 <strcmp>
4000cf50: 92 12 61 18 or %o1, 0x118, %o1 ! 4001e518 <IMFS_memfile_handlers+0x30>
4000cf54: 80 a2 20 00 cmp %o0, 0
4000cf58: 22 80 00 12 be,a 4000cfa0 <rtems_assoc_ptr_by_remote+0x68>
4000cf5c: c4 06 20 0c ld [ %i0 + 0xc ], %g2
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
4000cf60: 84 10 20 00 clr %g2
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
4000cf64: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000cf68: 80 a0 40 19 cmp %g1, %i1
4000cf6c: 32 80 00 07 bne,a 4000cf88 <rtems_assoc_ptr_by_remote+0x50>
4000cf70: b0 06 20 0c add %i0, 0xc, %i0
4000cf74: 30 80 00 13 b,a 4000cfc0 <rtems_assoc_ptr_by_remote+0x88>
4000cf78: 80 a0 40 19 cmp %g1, %i1
4000cf7c: 02 80 00 11 be 4000cfc0 <rtems_assoc_ptr_by_remote+0x88>
4000cf80: 01 00 00 00 nop
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
4000cf84: b0 06 20 0c add %i0, 0xc, %i0
4000cf88: c2 06 00 00 ld [ %i0 ], %g1
4000cf8c: 80 a0 60 00 cmp %g1, 0
4000cf90: 32 bf ff fa bne,a 4000cf78 <rtems_assoc_ptr_by_remote+0x40>
4000cf94: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000cf98: 81 c7 e0 08 ret
4000cf9c: 91 e8 00 02 restore %g0, %g2, %o0
4000cfa0: 80 a0 a0 00 cmp %g2, 0
4000cfa4: 02 80 00 07 be 4000cfc0 <rtems_assoc_ptr_by_remote+0x88> <== NEVER TAKEN
4000cfa8: 82 06 20 0c add %i0, 0xc, %g1
4000cfac: 84 10 00 18 mov %i0, %g2
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
4000cfb0: 10 bf ff ed b 4000cf64 <rtems_assoc_ptr_by_remote+0x2c>
4000cfb4: b0 10 00 01 mov %g1, %i0
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
4000cfb8: 81 c7 e0 08 ret
4000cfbc: 91 e8 20 00 restore %g0, 0, %o0
4000cfc0: 81 c7 e0 08 ret
4000cfc4: 81 e8 00 00 restore
40004b84 <rtems_assoc_remote_by_local_bitfield>:
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
40004b84: 9d e3 bf a0 save %sp, -96, %sp
40004b88: b8 10 20 20 mov 0x20, %i4
uint32_t b;
uint32_t remote_value = 0;
40004b8c: b6 10 20 00 clr %i3
for (b = 1; b; b <<= 1)
40004b90: 10 80 00 04 b 40004ba0 <rtems_assoc_remote_by_local_bitfield+0x1c>
40004b94: ba 10 20 01 mov 1, %i5
40004b98: 02 80 00 0c be 40004bc8 <rtems_assoc_remote_by_local_bitfield+0x44>
40004b9c: bb 2f 60 01 sll %i5, 1, %i5
if (b & local_value)
40004ba0: 80 8f 40 19 btst %i5, %i1
40004ba4: 22 bf ff fd be,a 40004b98 <rtems_assoc_remote_by_local_bitfield+0x14>
40004ba8: b8 87 3f ff addcc %i4, -1, %i4
remote_value |= rtems_assoc_remote_by_local(ap, b);
40004bac: 92 10 00 1d mov %i5, %o1
40004bb0: 40 00 00 08 call 40004bd0 <rtems_assoc_remote_by_local>
40004bb4: 90 10 00 18 mov %i0, %o0
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
40004bb8: bb 2f 60 01 sll %i5, 1, %i5
40004bbc: b8 87 3f ff addcc %i4, -1, %i4
40004bc0: 12 bf ff f8 bne 40004ba0 <rtems_assoc_remote_by_local_bitfield+0x1c><== ALWAYS TAKEN
40004bc4: b6 16 c0 08 or %i3, %o0, %i3
if (b & local_value)
remote_value |= rtems_assoc_remote_by_local(ap, b);
return remote_value;
}
40004bc8: 81 c7 e0 08 ret
40004bcc: 91 e8 00 1b restore %g0, %i3, %o0
4000e2bc <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
4000e2bc: 9d e3 bf a0 save %sp, -96, %sp
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
4000e2c0: 3b 10 00 71 sethi %hi(0x4001c400), %i5
4000e2c4: ba 17 61 8c or %i5, 0x18c, %i5 ! 4001c58c <bdbuf_cache>
4000e2c8: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
4000e2cc: 80 a0 60 00 cmp %g1, 0
4000e2d0: 22 80 00 08 be,a 4000e2f0 <rtems_bdbuf_add_to_modified_list_after_access+0x34><== ALWAYS TAKEN
4000e2d4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
4000e2d8: c4 07 60 38 ld [ %i5 + 0x38 ], %g2 <== NOT EXECUTED
4000e2dc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
4000e2e0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000e2e4: 02 80 00 2b be 4000e390 <rtems_bdbuf_add_to_modified_list_after_access+0xd4><== NOT EXECUTED
4000e2e8: 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
4000e2ec: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
4000e2f0: 80 a0 60 05 cmp %g1, 5
4000e2f4: 22 80 00 16 be,a 4000e34c <rtems_bdbuf_add_to_modified_list_after_access+0x90>
4000e2f8: 03 10 00 6a sethi %hi(0x4001a800), %g1
4000e2fc: 80 a0 60 03 cmp %g1, 3
4000e300: 02 80 00 13 be 4000e34c <rtems_bdbuf_add_to_modified_list_after_access+0x90>
4000e304: 03 10 00 6a sethi %hi(0x4001a800), %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000e308: 84 10 20 07 mov 7, %g2
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4000e30c: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
4000e310: c4 26 20 20 st %g2, [ %i0 + 0x20 ]
the_node->next = tail;
4000e314: 84 07 60 50 add %i5, 0x50, %g2
tail->previous = the_node;
4000e318: f0 27 60 54 st %i0, [ %i5 + 0x54 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
4000e31c: c4 26 00 00 st %g2, [ %i0 ]
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
4000e320: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
tail->previous = the_node;
old_last->next = the_node;
the_node->previous = old_last;
4000e324: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000e328: 80 a0 a0 00 cmp %g2, 0
4000e32c: 12 80 00 15 bne 4000e380 <rtems_bdbuf_add_to_modified_list_after_access+0xc4>
4000e330: f0 20 40 00 st %i0, [ %g1 ]
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
4000e334: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
4000e338: 80 a0 60 00 cmp %g1, 0
4000e33c: 12 80 00 13 bne 4000e388 <rtems_bdbuf_add_to_modified_list_after_access+0xcc>
4000e340: 01 00 00 00 nop
4000e344: 81 c7 e0 08 ret
4000e348: 81 e8 00 00 restore
* only a specific period of time even if still changing and get onto disk
* and letting the file system try and recover this position if it can.
*/
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
4000e34c: c2 00 63 e8 ld [ %g1 + 0x3e8 ], %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000e350: 84 10 20 07 mov 7, %g2
* only a specific period of time even if still changing and get onto disk
* and letting the file system try and recover this position if it can.
*/
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
4000e354: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4000e358: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000e35c: c4 26 20 20 st %g2, [ %i0 + 0x20 ]
the_node->next = tail;
4000e360: 84 07 60 50 add %i5, 0x50, %g2
tail->previous = the_node;
4000e364: f0 27 60 54 st %i0, [ %i5 + 0x54 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
4000e368: c4 26 00 00 st %g2, [ %i0 ]
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
4000e36c: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
tail->previous = the_node;
old_last->next = the_node;
the_node->previous = old_last;
4000e370: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000e374: 80 a0 a0 00 cmp %g2, 0
4000e378: 02 bf ff ef be 4000e334 <rtems_bdbuf_add_to_modified_list_after_access+0x78>
4000e37c: f0 20 40 00 st %i0, [ %g1 ]
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4000e380: 7f ff ff c0 call 4000e280 <rtems_bdbuf_wake>
4000e384: 91 ef 60 64 restore %i5, 0x64, %o0
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
4000e388: 7f ff ff 23 call 4000e014 <rtems_bdbuf_wake_swapper>
4000e38c: 81 e8 00 00 restore
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
{
rtems_bdbuf_unlock_cache ();
4000e390: 7f ff ff 1b call 4000dffc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000e394: 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);
4000e398: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
4000e39c: 7f ff fe f5 call 4000df70 <rtems_bdbuf_lock> <== NOT EXECUTED
4000e3a0: 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,
4000e3a4: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
4000e3a8: 7f ff ff 0a call 4000dfd0 <rtems_bdbuf_unlock> <== NOT EXECUTED
4000e3ac: 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 ();
4000e3b0: 7f ff fe fd call 4000dfa4 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
4000e3b4: 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
4000e3b8: 10 bf ff ce b 4000e2f0 <rtems_bdbuf_add_to_modified_list_after_access+0x34><== NOT EXECUTED
4000e3bc: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
4000e0bc <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)
{
4000e0bc: 9d e3 bf a0 save %sp, -96, %sp
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
4000e0c0: c2 06 00 00 ld [ %i0 ], %g1
4000e0c4: 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 ();
4000e0c8: 7f ff ff e0 call 4000e048 <rtems_bdbuf_disable_preemption>
4000e0cc: c2 26 00 00 st %g1, [ %i0 ]
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
4000e0d0: 7f ff ff cb call 4000dffc <rtems_bdbuf_unlock_cache>
4000e0d4: ba 10 00 08 mov %o0, %i5
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
4000e0d8: d0 06 20 04 ld [ %i0 + 4 ], %o0
4000e0dc: 92 10 20 00 clr %o1
4000e0e0: 7f ff ee 40 call 400099e0 <rtems_semaphore_obtain>
4000e0e4: 94 10 20 00 clr %o2
if (sc == RTEMS_TIMEOUT)
4000e0e8: 80 a2 20 06 cmp %o0, 6
4000e0ec: 02 80 00 0d be 4000e120 <rtems_bdbuf_anonymous_wait+0x64> <== NEVER TAKEN
4000e0f0: 80 a2 20 0d cmp %o0, 0xd
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);
if (sc != RTEMS_UNSATISFIED)
4000e0f4: 12 80 00 0d bne 4000e128 <rtems_bdbuf_anonymous_wait+0x6c><== NEVER TAKEN
4000e0f8: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);
rtems_bdbuf_lock_cache ();
4000e0fc: 7f ff ff aa call 4000dfa4 <rtems_bdbuf_lock_cache>
4000e100: 01 00 00 00 nop
rtems_bdbuf_restore_preemption (prev_mode);
4000e104: 7f ff ff df call 4000e080 <rtems_bdbuf_restore_preemption>
4000e108: 90 10 00 1d mov %i5, %o0
--waiters->count;
4000e10c: c2 06 00 00 ld [ %i0 ], %g1
4000e110: 82 00 7f ff add %g1, -1, %g1
4000e114: c2 26 00 00 st %g1, [ %i0 ]
4000e118: 81 c7 e0 08 ret
4000e11c: 81 e8 00 00 restore
rtems_bdbuf_unlock_cache ();
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
if (sc == RTEMS_TIMEOUT)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);
4000e120: 7f ff ff 8f call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e124: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);
4000e128: 7f ff ff 8d call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e12c: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED
4000e3c0 <rtems_bdbuf_create_task.constprop.9>:
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
4000e3c0: 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 ?
4000e3c4: 03 10 00 6a sethi %hi(0x4001a800), %g1
4000e3c8: d4 00 63 f4 ld [ %g1 + 0x3f4 ], %o2 ! 4001abf4 <rtems_bdbuf_configuration+0x1c>
bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
4000e3cc: 80 a2 a0 00 cmp %o2, 0
4000e3d0: 12 80 00 03 bne 4000e3dc <rtems_bdbuf_create_task.constprop.9+0x1c><== ALWAYS TAKEN
4000e3d4: 92 10 00 19 mov %i1, %o1
4000e3d8: 15 00 00 04 sethi %hi(0x1000), %o2 <== NOT EXECUTED
priority = priority != 0 ? priority : default_priority;
4000e3dc: 80 a2 60 00 cmp %o1, 0
4000e3e0: 22 80 00 02 be,a 4000e3e8 <rtems_bdbuf_create_task.constprop.9+0x28><== NEVER TAKEN
4000e3e4: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
sc = rtems_task_create (name,
4000e3e8: 90 10 00 18 mov %i0, %o0
4000e3ec: 96 10 24 00 mov 0x400, %o3
4000e3f0: 98 10 20 00 clr %o4
4000e3f4: 7f ff ee 0a call 40009c1c <rtems_task_create>
4000e3f8: 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)
4000e3fc: 80 a2 20 00 cmp %o0, 0
4000e400: 02 80 00 04 be 4000e410 <rtems_bdbuf_create_task.constprop.9+0x50><== ALWAYS TAKEN
4000e404: b0 10 00 08 mov %o0, %i0
sc = rtems_task_start (*id, entry, arg);
return sc;
}
4000e408: 81 c7 e0 08 ret <== NOT EXECUTED
4000e40c: 81 e8 00 00 restore <== NOT EXECUTED
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
id);
if (sc == RTEMS_SUCCESSFUL)
sc = rtems_task_start (*id, entry, arg);
4000e410: f0 07 00 00 ld [ %i4 ], %i0
4000e414: b2 10 00 1a mov %i2, %i1
4000e418: 7f ff ee 8c call 40009e48 <rtems_task_start>
4000e41c: 95 e8 00 1b restore %g0, %i3, %o2
4000e048 <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
4000e048: 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);
4000e04c: 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;
4000e050: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
4000e054: 92 10 21 00 mov 0x100, %o1
4000e058: 40 00 12 4d call 4001298c <rtems_task_mode>
4000e05c: 94 07 bf fc add %fp, -4, %o2
if (sc != RTEMS_SUCCESSFUL)
4000e060: 80 a2 20 00 cmp %o0, 0
4000e064: 12 80 00 04 bne 4000e074 <rtems_bdbuf_disable_preemption+0x2c><== NEVER TAKEN
4000e068: f0 07 bf fc ld [ %fp + -4 ], %i0
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);
return prev_mode;
}
4000e06c: 81 c7 e0 08 ret
4000e070: 81 e8 00 00 restore
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);
4000e074: 7f ff ff ba call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e078: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
4000e840 <rtems_bdbuf_discard_buffer_after_access>:
return bdbuf_cache.max_bds_per_group / bds_per_size;
}
static void
rtems_bdbuf_discard_buffer_after_access (rtems_bdbuf_buffer *bd)
{
4000e840: 9d e3 bf a0 save %sp, -96, %sp
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000e844: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
4000e848: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000e84c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
4000e850: 80 a0 a0 00 cmp %g2, 0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000e854: 86 00 ff ff add %g3, -1, %g3
4000e858: c6 20 60 0c st %g3, [ %g1 + 0xc ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000e85c: 82 10 20 01 mov 1, %g1
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
4000e860: 02 80 00 05 be 4000e874 <rtems_bdbuf_discard_buffer_after_access+0x34>
4000e864: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_discard_buffer (bd);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
4000e868: 31 10 00 71 sethi %hi(0x4001c400), %i0
4000e86c: 7f ff fe 85 call 4000e280 <rtems_bdbuf_wake>
4000e870: 91 ee 21 f0 restore %i0, 0x1f0, %o0
4000e874: 7f ff ff e6 call 4000e80c <rtems_bdbuf_discard_buffer.part.4>
4000e878: 90 10 00 18 mov %i0, %o0
rtems_bdbuf_discard_buffer_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_discard_buffer (bd);
if (bd->waiters)
4000e87c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000e880: 80 a0 60 00 cmp %g1, 0
4000e884: 32 bf ff fa bne,a 4000e86c <rtems_bdbuf_discard_buffer_after_access+0x2c><== NEVER TAKEN
4000e888: 31 10 00 71 sethi %hi(0x4001c400), %i0 <== NOT EXECUTED
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000e88c: 31 10 00 71 sethi %hi(0x4001c400), %i0
4000e890: 7f ff fe 7c call 4000e280 <rtems_bdbuf_wake>
4000e894: 91 ee 22 00 restore %i0, 0x200, %o0
4000f71c <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)
{
4000f71c: 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) +
4000f720: 83 2e a0 04 sll %i2, 4, %g1
4000f724: 82 00 60 20 add %g1, 0x20, %g1
4000f728: 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;
4000f72c: 03 10 00 3d sethi %hi(0x4000f400), %g1
4000f730: 82 10 63 f0 or %g1, 0x3f0, %g1 ! 4000f7f0 <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) +
4000f734: a2 03 a0 60 add %sp, 0x60, %l1
rtems_bdbuf_execute_read_request (rtems_disk_device *dd,
rtems_bdbuf_buffer *bd,
uint32_t transfer_count)
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
4000f738: f8 06 60 18 ld [ %i1 + 0x18 ], %i4
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
uint32_t block_size = dd->block_size;
4000f73c: 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;
4000f740: e4 06 20 2c ld [ %i0 + 0x2c ], %l2
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
sizeof (rtems_blkdev_sg_buffer) * transfer_count);
req->req = RTEMS_BLKDEV_REQ_READ;
req->done = rtems_bdbuf_transfer_done;
4000f744: c2 24 60 04 st %g1, [ %l1 + 4 ]
req->io_task = rtems_task_self ();
4000f748: 40 00 0c fd call 40012b3c <rtems_task_self>
4000f74c: c0 24 40 00 clr [ %l1 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
req->bufs [0].buffer = bd->buffer;
4000f750: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
sizeof (rtems_blkdev_sg_buffer) * transfer_count);
req->req = RTEMS_BLKDEV_REQ_READ;
req->done = rtems_bdbuf_transfer_done;
req->io_task = rtems_task_self ();
4000f754: d0 24 60 14 st %o0, [ %l1 + 0x14 ]
req->bufnum = 0;
4000f758: c0 24 60 10 clr [ %l1 + 0x10 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000f75c: 84 10 20 09 mov 9, %g2
4000f760: c4 26 60 20 st %g2, [ %i1 + 0x20 ]
req->io_task = rtems_task_self ();
req->bufnum = 0;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [0].user = bd;
4000f764: f2 24 60 24 st %i1, [ %l1 + 0x24 ]
req->bufs [0].block = media_block;
4000f768: f8 24 60 18 st %i4, [ %l1 + 0x18 ]
req->bufs [0].length = block_size;
4000f76c: e0 24 60 1c st %l0, [ %l1 + 0x1c ]
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
while (transfer_index < transfer_count)
4000f770: 80 a6 a0 01 cmp %i2, 1
4000f774: 08 80 00 1d bleu 4000f7e8 <rtems_bdbuf_execute_read_request+0xcc>
4000f778: c2 24 60 20 st %g1, [ %l1 + 0x20 ]
4000f77c: ba 10 00 11 mov %l1, %i5
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
4000f780: b6 10 20 01 mov 1, %i3
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000f784: 10 80 00 0b b 4000f7b0 <rtems_bdbuf_execute_read_request+0x94>
4000f788: b2 10 20 09 mov 9, %i1
if (bd == NULL)
break;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
4000f78c: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
req->bufs [transfer_index].block = media_block;
4000f790: f8 27 60 28 st %i4, [ %i5 + 0x28 ]
req->bufs [transfer_index].length = block_size;
4000f794: e0 27 60 2c st %l0, [ %i5 + 0x2c ]
req->bufs [transfer_index].buffer = bd->buffer;
4000f798: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
4000f79c: b6 06 e0 01 inc %i3
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
req->bufs [transfer_index].block = media_block;
req->bufs [transfer_index].length = block_size;
req->bufs [transfer_index].buffer = bd->buffer;
4000f7a0: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
while (transfer_index < transfer_count)
4000f7a4: 80 a6 c0 1a cmp %i3, %i2
4000f7a8: 02 80 00 09 be 4000f7cc <rtems_bdbuf_execute_read_request+0xb0>
4000f7ac: ba 07 60 10 add %i5, 0x10, %i5
{
media_block += media_blocks_per_block;
4000f7b0: b8 07 00 12 add %i4, %l2, %i4
bd = rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
4000f7b4: 90 10 00 18 mov %i0, %o0
4000f7b8: 7f ff fd 50 call 4000ecf8 <rtems_bdbuf_get_buffer_for_read_ahead>
4000f7bc: 92 10 00 1c mov %i4, %o1
if (bd == NULL)
4000f7c0: 80 a2 20 00 cmp %o0, 0
4000f7c4: 32 bf ff f2 bne,a 4000f78c <rtems_bdbuf_execute_read_request+0x70><== ALWAYS TAKEN
4000f7c8: f2 22 20 20 st %i1, [ %o0 + 0x20 ]
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
4000f7cc: f6 24 60 10 st %i3, [ %l1 + 0x10 ]
return rtems_bdbuf_execute_transfer_request (dd, req, true);
4000f7d0: 90 10 00 18 mov %i0, %o0
4000f7d4: 92 10 00 11 mov %l1, %o1
4000f7d8: 7f ff fd f5 call 4000efac <rtems_bdbuf_execute_transfer_request>
4000f7dc: 94 10 20 01 mov 1, %o2
}
4000f7e0: 81 c7 e0 08 ret
4000f7e4: 91 e8 00 08 restore %g0, %o0, %o0
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
4000f7e8: 10 bf ff f9 b 4000f7cc <rtems_bdbuf_execute_read_request+0xb0>
4000f7ec: b6 10 20 01 mov 1, %i3
4000efac <rtems_bdbuf_execute_transfer_request>:
static rtems_status_code
rtems_bdbuf_execute_transfer_request (rtems_disk_device *dd,
rtems_blkdev_request *req,
bool cache_locked)
{
4000efac: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
bool wake_buffer_waiters = false;
if (cache_locked)
4000efb0: 80 a6 a0 00 cmp %i2, 0
4000efb4: 12 80 00 6e bne 4000f16c <rtems_bdbuf_execute_transfer_request+0x1c0>
4000efb8: ba 10 00 18 mov %i0, %i5
rtems_bdbuf_unlock_cache ();
/* The return value will be ignored for transfer requests */
dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);
4000efbc: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
4000efc0: d0 07 60 08 ld [ %i5 + 8 ], %o0
4000efc4: 94 10 00 19 mov %i1, %o2
4000efc8: 13 30 06 10 sethi %hi(0xc0184000), %o1
4000efcc: 9f c0 40 00 call %g1
4000efd0: 92 12 62 01 or %o1, 0x201, %o1 ! c0184201 <LEON_REG+0x40184201>
/* Wait for transfer request completion */
rtems_bdbuf_wait_for_transient_event ();
4000efd4: 7f ff ff e8 call 4000ef74 <rtems_bdbuf_wait_for_transient_event>
4000efd8: 01 00 00 00 nop
sc = req->status;
rtems_bdbuf_lock_cache ();
4000efdc: 7f ff fb f2 call 4000dfa4 <rtems_bdbuf_lock_cache>
4000efe0: f0 06 60 0c ld [ %i1 + 0xc ], %i0
/* Statistics */
if (req->req == RTEMS_BLKDEV_REQ_READ)
4000efe4: c2 06 40 00 ld [ %i1 ], %g1
4000efe8: 80 a0 60 00 cmp %g1, 0
4000efec: 12 80 00 47 bne 4000f108 <rtems_bdbuf_execute_transfer_request+0x15c>
4000eff0: c8 06 60 10 ld [ %i1 + 0x10 ], %g4
{
dd->stats.read_blocks += req->bufnum;
4000eff4: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
if (sc != RTEMS_SUCCESSFUL)
4000eff8: 80 a6 20 00 cmp %i0, 0
rtems_bdbuf_lock_cache ();
/* Statistics */
if (req->req == RTEMS_BLKDEV_REQ_READ)
{
dd->stats.read_blocks += req->bufnum;
4000effc: 82 00 40 04 add %g1, %g4, %g1
if (sc != RTEMS_SUCCESSFUL)
4000f000: 12 80 00 57 bne 4000f15c <rtems_bdbuf_execute_transfer_request+0x1b0>
4000f004: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
++dd->stats.write_transfers;
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.write_errors;
}
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
4000f008: 80 a1 20 00 cmp %g4, 0
4000f00c: 02 80 00 35 be 4000f0e0 <rtems_bdbuf_execute_transfer_request+0x134><== NEVER TAKEN
4000f010: b6 10 20 00 clr %i3
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4000f014: 21 10 00 71 sethi %hi(0x4001c400), %l0
4000f018: b8 10 00 19 mov %i1, %i4
4000f01c: a0 14 21 8c or %l0, 0x18c, %l0
4000f020: a8 10 20 00 clr %l4
4000f024: ba 10 20 00 clr %i5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000f028: a6 10 20 01 mov 1, %l3
4000f02c: a4 10 20 02 mov 2, %l2
the_node->next = tail;
4000f030: 10 80 00 16 b 4000f088 <rtems_bdbuf_execute_transfer_request+0xdc>
4000f034: a2 04 20 44 add %l0, 0x44, %l1
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000f038: c2 02 20 28 ld [ %o0 + 0x28 ], %g1
else
wake_buffer_waiters = true;
rtems_bdbuf_group_release (bd);
if (sc == RTEMS_SUCCESSFUL && bd->state == RTEMS_BDBUF_STATE_TRANSFER)
4000f03c: 80 a6 20 00 cmp %i0, 0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000f040: c6 00 60 0c ld [ %g1 + 0xc ], %g3
4000f044: 86 00 ff ff add %g3, -1, %g3
else
wake_buffer_waiters = true;
rtems_bdbuf_group_release (bd);
if (sc == RTEMS_SUCCESSFUL && bd->state == RTEMS_BDBUF_STATE_TRANSFER)
4000f048: 12 80 00 06 bne 4000f060 <rtems_bdbuf_execute_transfer_request+0xb4>
4000f04c: c6 20 60 0c st %g3, [ %g1 + 0xc ]
4000f050: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
4000f054: 80 a0 60 09 cmp %g1, 9
4000f058: 22 80 00 13 be,a 4000f0a4 <rtems_bdbuf_execute_transfer_request+0xf8>
4000f05c: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
4000f060: 80 a0 a0 00 cmp %g2, 0
4000f064: 12 80 00 05 bne 4000f078 <rtems_bdbuf_execute_transfer_request+0xcc>
4000f068: e6 22 20 20 st %l3, [ %o0 + 0x20 ]
4000f06c: 7f ff fd e8 call 4000e80c <rtems_bdbuf_discard_buffer.part.4>
4000f070: 01 00 00 00 nop
4000f074: c8 06 60 10 ld [ %i1 + 0x10 ], %g4
++dd->stats.write_transfers;
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.write_errors;
}
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
4000f078: ba 07 60 01 inc %i5
4000f07c: 80 a1 00 1d cmp %g4, %i5
4000f080: 08 80 00 12 bleu 4000f0c8 <rtems_bdbuf_execute_transfer_request+0x11c><== ALWAYS TAKEN
4000f084: b8 07 20 10 add %i4, 0x10, %i4
{
rtems_bdbuf_buffer *bd = req->bufs [transfer_index].user;
4000f088: d0 07 20 24 ld [ %i4 + 0x24 ], %o0
bool waiters = bd->waiters;
4000f08c: c4 02 20 24 ld [ %o0 + 0x24 ], %g2
if (waiters)
4000f090: 80 a0 a0 00 cmp %g2, 0
4000f094: 32 bf ff e9 bne,a 4000f038 <rtems_bdbuf_execute_transfer_request+0x8c>
4000f098: a8 10 20 01 mov 1, %l4
wake_transfer_waiters = true;
else
wake_buffer_waiters = true;
4000f09c: 10 bf ff e7 b 4000f038 <rtems_bdbuf_execute_transfer_request+0x8c>
4000f0a0: b6 10 20 01 mov 1, %i3
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000f0a4: e4 22 20 20 st %l2, [ %o0 + 0x20 ]
4000f0a8: e2 22 00 00 st %l1, [ %o0 ]
tail->previous = the_node;
4000f0ac: d0 24 20 48 st %o0, [ %l0 + 0x48 ]
old_last->next = the_node;
4000f0b0: d0 20 40 00 st %o0, [ %g1 ]
the_node->previous = old_last;
4000f0b4: c2 22 20 04 st %g1, [ %o0 + 4 ]
++dd->stats.write_transfers;
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.write_errors;
}
for (transfer_index = 0; transfer_index < req->bufnum; ++transfer_index)
4000f0b8: ba 07 60 01 inc %i5
4000f0bc: 80 a1 00 1d cmp %g4, %i5
4000f0c0: 18 bf ff f2 bgu 4000f088 <rtems_bdbuf_execute_transfer_request+0xdc>
4000f0c4: b8 07 20 10 add %i4, 0x10, %i4
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("transfer", bd);
}
if (wake_transfer_waiters)
4000f0c8: 80 8d 20 ff btst 0xff, %l4
4000f0cc: 12 80 00 2c bne 4000f17c <rtems_bdbuf_execute_transfer_request+0x1d0>
4000f0d0: 11 10 00 71 sethi %hi(0x4001c400), %o0
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
if (wake_buffer_waiters)
4000f0d4: 80 8e e0 ff btst 0xff, %i3
4000f0d8: 12 80 00 18 bne 4000f138 <rtems_bdbuf_execute_transfer_request+0x18c>
4000f0dc: 11 10 00 71 sethi %hi(0x4001c400), %o0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
if (!cache_locked)
4000f0e0: 80 a6 a0 00 cmp %i2, 0
4000f0e4: 02 80 00 1a be 4000f14c <rtems_bdbuf_execute_transfer_request+0x1a0>
4000f0e8: 01 00 00 00 nop
rtems_bdbuf_unlock_cache ();
if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)
4000f0ec: 80 a6 20 0d cmp %i0, 0xd
4000f0f0: 02 80 00 04 be 4000f100 <rtems_bdbuf_execute_transfer_request+0x154>
4000f0f4: 80 a6 20 00 cmp %i0, 0
4000f0f8: 32 80 00 02 bne,a 4000f100 <rtems_bdbuf_execute_transfer_request+0x154>
4000f0fc: b0 10 20 1b mov 0x1b, %i0
return sc;
else
return RTEMS_IO_ERROR;
}
4000f100: 81 c7 e0 08 ret
4000f104: 81 e8 00 00 restore
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.read_errors;
}
else
{
dd->stats.write_blocks += req->bufnum;
4000f108: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
++dd->stats.write_transfers;
4000f10c: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.read_errors;
}
else
{
dd->stats.write_blocks += req->bufnum;
4000f110: 84 00 80 04 add %g2, %g4, %g2
++dd->stats.write_transfers;
4000f114: 82 00 60 01 inc %g1
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.read_errors;
}
else
{
dd->stats.write_blocks += req->bufnum;
4000f118: c4 27 60 5c st %g2, [ %i5 + 0x5c ]
++dd->stats.write_transfers;
if (sc != RTEMS_SUCCESSFUL)
4000f11c: 80 a6 20 00 cmp %i0, 0
4000f120: 02 bf ff ba be 4000f008 <rtems_bdbuf_execute_transfer_request+0x5c>
4000f124: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
++dd->stats.write_errors;
4000f128: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4000f12c: 82 00 60 01 inc %g1
4000f130: 10 bf ff b6 b 4000f008 <rtems_bdbuf_execute_transfer_request+0x5c>
4000f134: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
if (wake_transfer_waiters)
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
if (wake_buffer_waiters)
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000f138: 7f ff fc 52 call 4000e280 <rtems_bdbuf_wake>
4000f13c: 90 12 22 00 or %o0, 0x200, %o0
if (!cache_locked)
4000f140: 80 a6 a0 00 cmp %i2, 0
4000f144: 32 bf ff eb bne,a 4000f0f0 <rtems_bdbuf_execute_transfer_request+0x144>
4000f148: 80 a6 20 0d cmp %i0, 0xd
rtems_bdbuf_unlock_cache ();
4000f14c: 7f ff fb ac call 4000dffc <rtems_bdbuf_unlock_cache>
4000f150: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)
4000f154: 10 bf ff e7 b 4000f0f0 <rtems_bdbuf_execute_transfer_request+0x144>
4000f158: 80 a6 20 0d cmp %i0, 0xd
/* Statistics */
if (req->req == RTEMS_BLKDEV_REQ_READ)
{
dd->stats.read_blocks += req->bufnum;
if (sc != RTEMS_SUCCESSFUL)
++dd->stats.read_errors;
4000f15c: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
4000f160: 82 00 60 01 inc %g1
4000f164: 10 bf ff a9 b 4000f008 <rtems_bdbuf_execute_transfer_request+0x5c>
4000f168: c2 27 60 54 st %g1, [ %i5 + 0x54 ]
uint32_t transfer_index = 0;
bool wake_transfer_waiters = false;
bool wake_buffer_waiters = false;
if (cache_locked)
rtems_bdbuf_unlock_cache ();
4000f16c: 7f ff fb a4 call 4000dffc <rtems_bdbuf_unlock_cache>
4000f170: 01 00 00 00 nop
/* The return value will be ignored for transfer requests */
dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);
4000f174: 10 bf ff 93 b 4000efc0 <rtems_bdbuf_execute_transfer_request+0x14>
4000f178: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("transfer", bd);
}
if (wake_transfer_waiters)
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
4000f17c: 7f ff fc 41 call 4000e280 <rtems_bdbuf_wake>
4000f180: 90 12 21 f8 or %o0, 0x1f8, %o0
if (wake_buffer_waiters)
4000f184: 10 bf ff d5 b 4000f0d8 <rtems_bdbuf_execute_transfer_request+0x12c>
4000f188: 80 8e e0 ff btst 0xff, %i3
4000df5c <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_fatal_code error)
{
4000df5c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_fatal (RTEMS_FATAL_SOURCE_BDBUF, error);
4000df60: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
4000df64: 7f ff f0 53 call 4000a0b0 <rtems_fatal> <== NOT EXECUTED
4000df68: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4000dfbc <rtems_bdbuf_fatal_with_state>:
}
static void
rtems_bdbuf_fatal_with_state (rtems_bdbuf_buf_state state,
rtems_bdbuf_fatal_code error)
{
4000dfbc: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_bdbuf_fatal ((((uint32_t) state) << 16) | error);
4000dfc0: b1 2e 20 10 sll %i0, 0x10, %i0 <== NOT EXECUTED
4000dfc4: 7f ff ff e6 call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000dfc8: 90 16 40 18 or %i1, %i0, %o0 <== NOT EXECUTED
4000fd8c <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
4000fd8c: 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 ();
4000fd90: 7f ff f8 85 call 4000dfa4 <rtems_bdbuf_lock_cache>
4000fd94: b8 10 20 04 mov 4, %i4
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
4000fd98: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
4000fd9c: 80 a6 40 01 cmp %i1, %g1
4000fda0: 0a 80 00 07 bcs 4000fdbc <rtems_bdbuf_get+0x30> <== ALWAYS TAKEN
4000fda4: ba 10 20 00 clr %i5
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
4000fda8: 7f ff f8 95 call 4000dffc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000fdac: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
*bd_ptr = bd;
4000fdb0: fa 26 80 00 st %i5, [ %i2 ] <== NOT EXECUTED
return sc;
}
4000fdb4: 81 c7 e0 08 ret <== NOT EXECUTED
4000fdb8: 81 e8 00 00 restore <== NOT EXECUTED
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
4000fdbc: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
4000fdc0: 80 a2 60 00 cmp %o1, 0
4000fdc4: 26 80 00 29 bl,a 4000fe68 <rtems_bdbuf_get+0xdc> <== NEVER TAKEN
4000fdc8: d6 06 20 24 ld [ %i0 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
4000fdcc: 93 2e 40 09 sll %i1, %o1, %o1
/*
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
4000fdd0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dd->dev);
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
4000fdd4: 90 10 00 18 mov %i0, %o0
4000fdd8: 7f ff fb df call 4000ed54 <rtems_bdbuf_get_buffer_for_access>
4000fddc: 92 02 40 01 add %o1, %g1, %o1
4000fde0: ba 10 00 08 mov %o0, %i5
switch (bd->state)
4000fde4: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
4000fde8: 80 a2 20 02 cmp %o0, 2
4000fdec: 02 80 00 17 be 4000fe48 <rtems_bdbuf_get+0xbc>
4000fdf0: 80 a2 20 07 cmp %o0, 7
4000fdf4: 02 80 00 06 be 4000fe0c <rtems_bdbuf_get+0x80>
4000fdf8: 80 a2 20 01 cmp %o0, 1
4000fdfc: 02 80 00 0c be 4000fe2c <rtems_bdbuf_get+0xa0> <== ALWAYS TAKEN
4000fe00: 82 10 20 05 mov 5, %g1
* record of this so just gets the block to fill.
*/
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_2);
4000fe04: 7f ff f8 6e call 4000dfbc <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000fe08: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000fe0c: 82 10 20 04 mov 4, %g1
4000fe10: b8 10 20 00 clr %i4
4000fe14: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
4000fe18: 7f ff f8 79 call 4000dffc <rtems_bdbuf_unlock_cache>
4000fe1c: b0 10 00 1c mov %i4, %i0
*bd_ptr = bd;
4000fe20: fa 26 80 00 st %i5, [ %i2 ]
return sc;
}
4000fe24: 81 c7 e0 08 ret
4000fe28: 81 e8 00 00 restore
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000fe2c: b8 10 20 00 clr %i4
4000fe30: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
4000fe34: 7f ff f8 72 call 4000dffc <rtems_bdbuf_unlock_cache>
4000fe38: b0 10 00 1c mov %i4, %i0
*bd_ptr = bd;
4000fe3c: fa 26 80 00 st %i5, [ %i2 ]
return sc;
}
4000fe40: 81 c7 e0 08 ret
4000fe44: 81 e8 00 00 restore
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000fe48: 82 10 20 03 mov 3, %g1
4000fe4c: b8 10 20 00 clr %i4
4000fe50: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
4000fe54: 7f ff f8 6a call 4000dffc <rtems_bdbuf_unlock_cache>
4000fe58: b0 10 00 1c mov %i4, %i0
*bd_ptr = bd;
4000fe5c: fa 26 80 00 st %i5, [ %i2 ]
return sc;
}
4000fe60: 81 c7 e0 08 ret
4000fe64: 81 e8 00 00 restore
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
4000fe68: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000fe6c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000fe70: 40 00 24 3d call 40018f64 <__muldi3> <== NOT EXECUTED
4000fe74: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000fe78: d6 06 20 20 ld [ %i0 + 0x20 ], %o3 <== NOT EXECUTED
4000fe7c: 40 00 26 4b call 400197a8 <__udivdi3> <== NOT EXECUTED
4000fe80: 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;
4000fe84: 10 bf ff d4 b 4000fdd4 <rtems_bdbuf_get+0x48> <== NOT EXECUTED
4000fe88: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED
4000ed54 <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
4000ed54: 9d e3 bf a0 save %sp, -96, %sp
4000ed58: 3b 10 00 71 sethi %hi(0x4001c400), %i5
4000ed5c: b8 10 00 18 mov %i0, %i4
4000ed60: ba 17 61 8c or %i5, 0x18c, %i5
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000ed64: a6 10 00 1d mov %i5, %l3
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4000ed68: a0 07 60 6c add %i5, 0x6c, %l0
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
4000ed6c: b4 07 60 64 add %i5, 0x64, %i2
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000ed70: b6 07 60 40 add %i5, 0x40, %i3
* It is essential that we wait here without a special wait count and
* without the group in use. Otherwise we could trigger a wait ping
* pong with another recycle waiter. The state of the buffer is
* arbitrary afterwards.
*/
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
4000ed74: a2 07 60 74 add %i5, 0x74, %l1
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
4000ed78: a4 07 60 50 add %i5, 0x50, %l2
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000ed7c: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000ed80: 92 10 00 1c mov %i4, %o1
4000ed84: 7f ff fd 26 call 4000e21c <rtems_bdbuf_avl_search.isra.0>
4000ed88: 94 10 00 19 mov %i1, %o2
if (bd != NULL)
4000ed8c: b0 92 20 00 orcc %o0, 0, %i0
4000ed90: 02 80 00 34 be 4000ee60 <rtems_bdbuf_get_buffer_for_access+0x10c>
4000ed94: 90 10 00 1c mov %i4, %o0
{
if (bd->group->bds_per_group != dd->bds_per_group)
4000ed98: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
4000ed9c: c2 07 20 34 ld [ %i4 + 0x34 ], %g1
4000eda0: c4 00 a0 08 ld [ %g2 + 8 ], %g2
4000eda4: 80 a0 80 01 cmp %g2, %g1
4000eda8: 12 80 00 0c bne 4000edd8 <rtems_bdbuf_get_buffer_for_access+0x84>
4000edac: 2d 10 00 37 sethi %hi(0x4000dc00), %l6
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4000edb0: 3b 10 00 71 sethi %hi(0x4001c400), %i5
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000edb4: 39 10 00 37 sethi %hi(0x4000dc00), %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);
4000edb8: ba 17 61 f8 or %i5, 0x1f8, %i5
return;
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
4000edbc: b6 07 7f f8 add %i5, -8, %i3
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000edc0: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000edc4: 80 a2 20 0a cmp %o0, 0xa
4000edc8: 08 80 00 4c bleu 4000eef8 <rtems_bdbuf_get_buffer_for_access+0x1a4><== ALWAYS TAKEN
4000edcc: 84 17 21 54 or %i4, 0x154, %g2
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_7);
4000edd0: 7f ff fc 7b call 4000dfbc <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000edd4: 92 10 20 13 mov 0x13, %o1 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000edd8: aa 10 20 08 mov 8, %l5
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
4000eddc: a8 07 60 5c add %i5, 0x5c, %l4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000ede0: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000ede4: 80 a2 20 0a cmp %o0, 0xa
4000ede8: 08 80 00 04 bleu 4000edf8 <rtems_bdbuf_get_buffer_for_access+0xa4><== ALWAYS TAKEN
4000edec: 82 15 a1 80 or %l6, 0x180, %g1
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_8);
4000edf0: 7f ff fc 73 call 4000dfbc <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000edf4: 92 10 20 14 mov 0x14, %o1 <== NOT EXECUTED
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000edf8: 91 2a 20 02 sll %o0, 2, %o0
4000edfc: c2 00 40 08 ld [ %g1 + %o0 ], %g1
4000ee00: 81 c0 40 00 jmp %g1
4000ee04: 01 00 00 00 nop
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_request_sync_for_modified_buffer (bd);
break;
case RTEMS_BDBUF_STATE_CACHED:
case RTEMS_BDBUF_STATE_EMPTY:
if (bd->waiters == 0)
4000ee08: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000ee0c: 80 a0 60 00 cmp %g1, 0
4000ee10: 12 80 00 1f bne 4000ee8c <rtems_bdbuf_get_buffer_for_access+0x138><== ALWAYS TAKEN
4000ee14: 01 00 00 00 nop
{
if (bd->group->bds_per_group != dd->bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4000ee18: 7f ff fe a0 call 4000e898 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
4000ee1c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000ee20: c2 07 60 40 ld [ %i5 + 0x40 ], %g1 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000ee24: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000ee28: f6 26 20 04 st %i3, [ %i0 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
after_node->next = the_node;
4000ee2c: f0 27 60 40 st %i0, [ %i5 + 0x40 ] <== NOT EXECUTED
the_node->next = before_node;
4000ee30: c2 26 00 00 st %g1, [ %i0 ] <== NOT EXECUTED
before_node->previous = the_node;
4000ee34: f0 20 60 04 st %i0, [ %g1 + 4 ] <== NOT EXECUTED
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000ee38: 7f ff fd 12 call 4000e280 <rtems_bdbuf_wake> <== NOT EXECUTED
4000ee3c: 90 07 60 74 add %i5, 0x74, %o0 <== NOT EXECUTED
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000ee40: d0 07 60 3c ld [ %i5 + 0x3c ], %o0 <== NOT EXECUTED
4000ee44: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4000ee48: 7f ff fc f5 call 4000e21c <rtems_bdbuf_avl_search.isra.0> <== NOT EXECUTED
4000ee4c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
if (bd != NULL)
4000ee50: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4000ee54: 32 bf ff d2 bne,a 4000ed9c <rtems_bdbuf_get_buffer_for_access+0x48><== NOT EXECUTED
4000ee58: c4 06 20 28 ld [ %i0 + 0x28 ], %g2 <== NOT EXECUTED
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
4000ee5c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000ee60: 7f ff fe a0 call 4000e8e0 <rtems_bdbuf_get_buffer_from_lru_list>
4000ee64: 92 10 00 19 mov %i1, %o1
if (bd == NULL)
4000ee68: b0 92 20 00 orcc %o0, 0, %i0
4000ee6c: 32 bf ff d2 bne,a 4000edb4 <rtems_bdbuf_get_buffer_for_access+0x60>
4000ee70: 3b 10 00 71 sethi %hi(0x4001c400), %i5
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
4000ee74: c2 04 e0 4c ld [ %l3 + 0x4c ], %g1
4000ee78: 80 a0 40 12 cmp %g1, %l2
4000ee7c: 02 80 00 04 be 4000ee8c <rtems_bdbuf_get_buffer_for_access+0x138>
4000ee80: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
4000ee84: 7f ff fc 64 call 4000e014 <rtems_bdbuf_wake_swapper>
4000ee88: 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);
4000ee8c: 7f ff fc 8c call 4000e0bc <rtems_bdbuf_anonymous_wait>
4000ee90: 90 10 00 11 mov %l1, %o0
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000ee94: 10 bf ff bb b 4000ed80 <rtems_bdbuf_get_buffer_for_access+0x2c>
4000ee98: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4000ee9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000eea0: 7f ff fc a5 call 4000e134 <rtems_bdbuf_wait> <== NOT EXECUTED
4000eea4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000eea8: 10 bf ff cf b 4000ede4 <rtems_bdbuf_get_buffer_for_access+0x90><== NOT EXECUTED
4000eeac: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000eeb0: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000eeb4: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000eeb8: ea 26 20 20 st %l5, [ %i0 + 0x20 ] <== NOT EXECUTED
previous = the_node->previous;
next->previous = previous;
4000eebc: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
previous->next = next;
4000eec0: 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;
4000eec4: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 <== NOT EXECUTED
the_node->next = tail;
4000eec8: e8 26 00 00 st %l4, [ %i0 ] <== NOT EXECUTED
tail->previous = the_node;
4000eecc: f0 27 60 60 st %i0, [ %i5 + 0x60 ] <== NOT EXECUTED
old_last->next = the_node;
4000eed0: f0 20 40 00 st %i0, [ %g1 ] <== NOT EXECUTED
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_extract_unprotected (&bd->link);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
4000eed4: 7f ff fc 50 call 4000e014 <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
4000eed8: c2 26 20 04 st %g1, [ %i0 + 4 ] <== NOT EXECUTED
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000eedc: 10 bf ff c2 b 4000ede4 <rtems_bdbuf_get_buffer_for_access+0x90><== NOT EXECUTED
4000eee0: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
4000eee4: 90 10 00 18 mov %i0, %o0
4000eee8: 7f ff fc 93 call 4000e134 <rtems_bdbuf_wait>
4000eeec: 92 10 00 1a mov %i2, %o1
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000eef0: 10 bf ff bd b 4000ede4 <rtems_bdbuf_get_buffer_for_access+0x90>
4000eef4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000eef8: 83 2a 20 02 sll %o0, 2, %g1
4000eefc: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000ef00: 81 c0 40 00 jmp %g1
4000ef04: 01 00 00 00 nop
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
4000ef08: 90 10 00 18 mov %i0, %o0
4000ef0c: 7f ff fc 8a call 4000e134 <rtems_bdbuf_wait>
4000ef10: 92 10 00 1d mov %i5, %o1
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000ef14: 10 bf ff ac b 4000edc4 <rtems_bdbuf_get_buffer_for_access+0x70>
4000ef18: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4000ef1c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
4000ef20: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000ef24: 84 00 bf ff add %g2, -1, %g2
4000ef28: c4 20 60 0c st %g2, [ %g1 + 0xc ]
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000ef2c: c6 06 00 00 ld [ %i0 ], %g3
previous = the_node->previous;
4000ef30: c4 06 20 04 ld [ %i0 + 4 ], %g2
next->previous = previous;
4000ef34: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4000ef38: c6 20 80 00 st %g3, [ %g2 ]
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4000ef3c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000ef40: 84 00 a0 01 inc %g2
4000ef44: c4 20 60 0c st %g2, [ %g1 + 0xc ]
4000ef48: 81 c7 e0 08 ret
4000ef4c: 81 e8 00 00 restore
return;
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
4000ef50: 90 10 00 18 mov %i0, %o0
4000ef54: 7f ff fc 78 call 4000e134 <rtems_bdbuf_wait>
4000ef58: 92 10 00 1b mov %i3, %o1
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4000ef5c: 10 bf ff 9a b 4000edc4 <rtems_bdbuf_get_buffer_for_access+0x70>
4000ef60: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000ef64: 10 bf ff f2 b 4000ef2c <rtems_bdbuf_get_buffer_for_access+0x1d8>
4000ef68: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
4000ef6c: 10 bf ff f4 b 4000ef3c <rtems_bdbuf_get_buffer_for_access+0x1e8>
4000ef70: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
4000ecf8 <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)
{
4000ecf8: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
4000ecfc: 03 10 00 71 sethi %hi(0x4001c400), %g1
4000ed00: d0 00 61 c8 ld [ %g1 + 0x1c8 ], %o0 ! 4001c5c8 <bdbuf_cache+0x3c>
4000ed04: 92 10 00 18 mov %i0, %o1
4000ed08: 7f ff fd 45 call 4000e21c <rtems_bdbuf_avl_search.isra.0>
4000ed0c: 94 10 00 19 mov %i1, %o2
if (bd == NULL)
4000ed10: 80 a2 20 00 cmp %o0, 0
4000ed14: 02 80 00 04 be 4000ed24 <rtems_bdbuf_get_buffer_for_read_ahead+0x2c><== ALWAYS TAKEN
4000ed18: 82 10 20 00 clr %g1
* thus no need for a read ahead.
*/
bd = NULL;
return bd;
}
4000ed1c: 81 c7 e0 08 ret <== NOT EXECUTED
4000ed20: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
if (bd == NULL)
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
4000ed24: 90 10 00 18 mov %i0, %o0
4000ed28: 7f ff fe ee call 4000e8e0 <rtems_bdbuf_get_buffer_from_lru_list>
4000ed2c: 92 10 00 19 mov %i1, %o1
if (bd != NULL)
4000ed30: 82 92 20 00 orcc %o0, 0, %g1
4000ed34: 02 bf ff fa be 4000ed1c <rtems_bdbuf_get_buffer_for_read_ahead+0x24><== NEVER TAKEN
4000ed38: 01 00 00 00 nop
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
4000ed3c: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
4000ed40: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4000ed44: 86 00 e0 01 inc %g3
4000ed48: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
* thus no need for a read ahead.
*/
bd = NULL;
return bd;
}
4000ed4c: 81 c7 e0 08 ret
4000ed50: 91 e8 00 01 restore %g0, %g1, %o0
4000e8e0 <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)
{
4000e8e0: 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;
4000e8e4: 35 10 00 71 sethi %hi(0x4001c400), %i2
4000e8e8: b4 16 a1 8c or %i2, 0x18c, %i2 ! 4001c58c <bdbuf_cache>
4000e8ec: fa 06 a0 40 ld [ %i2 + 0x40 ], %i5
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
4000e8f0: a4 06 a0 44 add %i2, 0x44, %l2
4000e8f4: a6 06 a0 40 add %i2, 0x40, %l3
4000e8f8: 80 a7 40 12 cmp %i5, %l2
4000e8fc: 12 80 00 07 bne 4000e918 <rtems_bdbuf_get_buffer_from_lru_list+0x38>
4000e900: a8 06 a0 74 add %i2, 0x74, %l4
}
node = rtems_chain_next (node);
}
return NULL;
4000e904: 10 80 00 6c b 4000eab4 <rtems_bdbuf_get_buffer_from_lru_list+0x1d4>
4000e908: ba 10 20 00 clr %i5
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
4000e90c: 80 a7 40 12 cmp %i5, %l2
4000e910: 22 80 00 69 be,a 4000eab4 <rtems_bdbuf_get_buffer_from_lru_list+0x1d4>
4000e914: ba 10 20 00 clr %i5
bd->group->bds_per_group, dd->bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
4000e918: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000e91c: 80 a0 60 00 cmp %g1, 0
4000e920: 32 bf ff fb bne,a 4000e90c <rtems_bdbuf_get_buffer_from_lru_list+0x2c>
4000e924: fa 07 40 00 ld [ %i5 ], %i5
{
if (bd->group->bds_per_group == dd->bds_per_group)
4000e928: e0 07 60 28 ld [ %i5 + 0x28 ], %l0
4000e92c: e2 06 20 34 ld [ %i0 + 0x34 ], %l1
4000e930: f6 04 20 08 ld [ %l0 + 8 ], %i3
4000e934: 80 a6 c0 11 cmp %i3, %l1
4000e938: 02 80 00 37 be 4000ea14 <rtems_bdbuf_get_buffer_from_lru_list+0x134>
4000e93c: 01 00 00 00 nop
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
empty_bd = bd;
}
else if (bd->group->users == 0)
4000e940: c2 04 20 0c ld [ %l0 + 0xc ], %g1
4000e944: 80 a0 60 00 cmp %g1, 0
4000e948: 32 bf ff f1 bne,a 4000e90c <rtems_bdbuf_get_buffer_from_lru_list+0x2c>
4000e94c: fa 07 40 00 ld [ %i5 ], %i5
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
4000e950: ec 06 a0 20 ld [ %i2 + 0x20 ], %l6
4000e954: 92 10 00 1b mov %i3, %o1
4000e958: 40 00 28 2b call 40018a04 <.udiv>
4000e95c: 90 10 00 16 mov %l6, %o0
for (b = 0, bd = group->bdbuf;
4000e960: 80 a6 e0 00 cmp %i3, 0
4000e964: 02 80 00 0f be 4000e9a0 <rtems_bdbuf_get_buffer_from_lru_list+0xc0><== NEVER TAKEN
4000e968: f8 04 20 10 ld [ %l0 + 0x10 ], %i4
4000e96c: 83 2a 20 03 sll %o0, 3, %g1
4000e970: ab 2a 20 06 sll %o0, 6, %l5
4000e974: b6 10 20 00 clr %i3
4000e978: aa 25 40 01 sub %l5, %g1, %l5
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4000e97c: 7f ff ff c7 call 4000e898 <rtems_bdbuf_remove_from_tree_and_lru_list>
4000e980: 90 10 00 1c mov %i4, %o0
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
4000e984: c2 04 20 08 ld [ %l0 + 8 ], %g1
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4000e988: b6 06 e0 01 inc %i3
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
4000e98c: 80 a6 c0 01 cmp %i3, %g1
4000e990: 0a bf ff fb bcs 4000e97c <rtems_bdbuf_get_buffer_from_lru_list+0x9c>
4000e994: b8 07 00 15 add %i4, %l5, %i4
4000e998: ec 06 a0 20 ld [ %i2 + 0x20 ], %l6
4000e99c: f8 04 20 10 ld [ %l0 + 0x10 ], %i4
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
4000e9a0: e2 24 20 08 st %l1, [ %l0 + 8 ]
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
4000e9a4: 90 10 00 16 mov %l6, %o0
4000e9a8: 40 00 28 17 call 40018a04 <.udiv>
4000e9ac: 92 10 00 11 mov %l1, %o1
for (b = 1, bd = group->bdbuf + bufs_per_bd;
4000e9b0: 83 2a 20 03 sll %o0, 3, %g1
4000e9b4: 89 2a 20 06 sll %o0, 6, %g4
4000e9b8: 80 a4 60 01 cmp %l1, 1
4000e9bc: 88 21 00 01 sub %g4, %g1, %g4
4000e9c0: 08 80 00 10 bleu 4000ea00 <rtems_bdbuf_get_buffer_from_lru_list+0x120>
4000e9c4: 82 07 00 04 add %i4, %g4, %g1
4000e9c8: 84 10 20 01 mov 1, %g2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000e9cc: c0 20 60 20 clr [ %g1 + 0x20 ]
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000e9d0: c6 06 a0 40 ld [ %i2 + 0x40 ], %g3
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000e9d4: e6 20 60 04 st %l3, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000e9d8: c2 26 a0 40 st %g1, [ %i2 + 0x40 ]
the_node->next = before_node;
4000e9dc: c6 20 40 00 st %g3, [ %g1 ]
before_node->previous = the_node;
4000e9e0: c2 20 e0 04 st %g1, [ %g3 + 4 ]
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
4000e9e4: 84 00 a0 01 inc %g2
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
4000e9e8: 80 a0 80 11 cmp %g2, %l1
4000e9ec: 12 bf ff f8 bne 4000e9cc <rtems_bdbuf_get_buffer_from_lru_list+0xec>
4000e9f0: 82 00 40 04 add %g1, %g4, %g1
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4000e9f4: 7f ff fe 23 call 4000e280 <rtems_bdbuf_wake>
4000e9f8: 90 10 00 14 mov %l4, %o0
4000e9fc: f8 04 20 10 ld [ %l0 + 0x10 ], %i4
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, dd->bds_per_group);
}
if (empty_bd != NULL)
4000ea00: 80 a7 20 00 cmp %i4, 0
4000ea04: 22 bf ff c2 be,a 4000e90c <rtems_bdbuf_get_buffer_from_lru_list+0x2c><== NEVER TAKEN
4000ea08: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
return group->bdbuf;
4000ea0c: 10 80 00 04 b 4000ea1c <rtems_bdbuf_get_buffer_from_lru_list+0x13c>
4000ea10: ba 10 00 1c mov %i4, %i5
*/
if (bd->waiters == 0)
{
if (bd->group->bds_per_group == dd->bds_per_group)
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
4000ea14: 7f ff ff a1 call 4000e898 <rtems_bdbuf_remove_from_tree_and_lru_list>
4000ea18: 90 10 00 1d mov %i5, %o0
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
4000ea1c: f0 27 60 14 st %i0, [ %i5 + 0x14 ]
bd->block = block;
bd->avl.left = NULL;
4000ea20: c0 27 60 08 clr [ %i5 + 8 ]
bd->avl.right = NULL;
4000ea24: c0 27 60 0c clr [ %i5 + 0xc ]
rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
4000ea28: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
bd->block = block;
4000ea2c: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
4000ea30: 80 a0 60 00 cmp %g1, 0
4000ea34: 02 80 00 5c be 4000eba4 <rtems_bdbuf_get_buffer_from_lru_list+0x2c4>
4000ea38: c0 27 60 24 clr [ %i5 + 0x24 ]
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000ea3c: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
rtems_bdbuf_buffer* p = *root;
rtems_bdbuf_buffer* q;
rtems_bdbuf_buffer* p1;
rtems_bdbuf_buffer* p2;
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
4000ea40: 9e 07 bf 80 add %fp, -128, %o7
4000ea44: 84 10 00 0f mov %o7, %g2
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
4000ea48: c2 20 80 00 st %g1, [ %g2 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
4000ea4c: b8 10 20 01 mov 1, %i4
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
4000ea50: b6 10 3f ff mov -1, %i3
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000ea54: 80 a0 c0 18 cmp %g3, %i0
4000ea58: 1a 80 00 0d bcc 4000ea8c <rtems_bdbuf_get_buffer_from_lru_list+0x1ac><== ALWAYS TAKEN
4000ea5c: 88 00 a0 04 add %g2, 4, %g4
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
q = p->avl.right;
4000ea60: c6 00 60 0c ld [ %g1 + 0xc ], %g3 <== NOT EXECUTED
if (q == NULL)
4000ea64: 80 a0 e0 00 cmp %g3, 0
4000ea68: 02 80 00 1d be 4000eadc <rtems_bdbuf_get_buffer_from_lru_list+0x1fc>
4000ea6c: f8 28 60 10 stb %i4, [ %g1 + 0x10 ]
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
4000ea70: 82 10 00 03 mov %g3, %g1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000ea74: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
4000ea78: 84 10 00 04 mov %g4, %g2
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
4000ea7c: c2 20 80 00 st %g1, [ %g2 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000ea80: 80 a0 c0 18 cmp %g3, %i0
4000ea84: 0a bf ff f7 bcs 4000ea60 <rtems_bdbuf_get_buffer_from_lru_list+0x180><== NEVER TAKEN
4000ea88: 88 00 a0 04 add %g2, 4, %g4
|| ((p->dd == dd) && (p->block < block)))
4000ea8c: 80 a6 00 03 cmp %i0, %g3
4000ea90: 22 80 00 0b be,a 4000eabc <rtems_bdbuf_get_buffer_from_lru_list+0x1dc><== ALWAYS TAKEN
4000ea94: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
q = p->avl.left;
4000ea98: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED
if (q == NULL)
4000ea9c: 80 a0 e0 00 cmp %g3, 0
4000eaa0: 12 bf ff f4 bne 4000ea70 <rtems_bdbuf_get_buffer_from_lru_list+0x190>
4000eaa4: f6 28 60 10 stb %i3, [ %g1 + 0x10 ]
{
q = node;
p->avl.left = q;
4000eaa8: fa 20 60 08 st %i5, [ %g1 + 8 ]
4000eaac: 10 80 00 0e b 4000eae4 <rtems_bdbuf_get_buffer_from_lru_list+0x204>
4000eab0: 88 10 3f ff mov -1, %g4
node = rtems_chain_next (node);
}
return NULL;
}
4000eab4: 81 c7 e0 08 ret
4000eab8: 91 e8 00 1d restore %g0, %i5, %o0
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
4000eabc: 80 a6 40 03 cmp %i1, %g3
4000eac0: 38 bf ff e9 bgu,a 4000ea64 <rtems_bdbuf_get_buffer_from_lru_list+0x184>
4000eac4: c6 00 60 0c ld [ %g1 + 0xc ], %g3
q = node;
p->avl.right = q = node;
break;
}
}
else if ((p->dd != dd) || (p->block != block))
4000eac8: 80 a6 40 03 cmp %i1, %g3
4000eacc: 32 bf ff f4 bne,a 4000ea9c <rtems_bdbuf_get_buffer_from_lru_list+0x1bc><== ALWAYS TAKEN
4000ead0: c6 00 60 08 ld [ %g1 + 8 ], %g3
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
if (rtems_bdbuf_avl_insert (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RECYCLE);
4000ead4: 7f ff fd 22 call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000ead8: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
p->avl.cache = 1;
q = p->avl.right;
if (q == NULL)
{
q = node;
p->avl.right = q = node;
4000eadc: fa 20 60 0c st %i5, [ %g1 + 0xc ]
4000eae0: 88 10 20 01 mov 1, %g4
}
p = q;
}
q->avl.left = q->avl.right = NULL;
4000eae4: c0 27 60 0c clr [ %i5 + 0xc ]
4000eae8: c0 27 60 08 clr [ %i5 + 8 ]
q->avl.bal = 0;
4000eaec: c0 2f 60 11 clrb [ %i5 + 0x11 ]
4000eaf0: 89 29 20 18 sll %g4, 0x18, %g4
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
4000eaf4: b2 10 20 01 mov 1, %i1
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4000eaf8: 10 80 00 12 b 4000eb40 <rtems_bdbuf_get_buffer_from_lru_list+0x260>
4000eafc: b0 10 3f ff mov -1, %i0
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
4000eb00: 86 10 00 01 mov %g1, %g3
4000eb04: b8 10 20 01 mov 1, %i4
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
4000eb08: 80 a0 80 0f cmp %g2, %o7
4000eb0c: 28 80 00 1e bleu,a 4000eb84 <rtems_bdbuf_get_buffer_from_lru_list+0x2a4>
4000eb10: c6 26 a0 3c st %g3, [ %i2 + 0x3c ]
{
p = *--buf_prev;
4000eb14: c2 00 bf fc ld [ %g2 + -4 ], %g1
if (p->avl.cache == -1)
4000eb18: c8 08 60 10 ldub [ %g1 + 0x10 ], %g4
4000eb1c: 89 29 20 18 sll %g4, 0x18, %g4
4000eb20: b7 39 20 18 sra %g4, 0x18, %i3
4000eb24: 80 a6 ff ff cmp %i3, -1
4000eb28: 22 80 00 03 be,a 4000eb34 <rtems_bdbuf_get_buffer_from_lru_list+0x254>
4000eb2c: c6 20 60 08 st %g3, [ %g1 + 8 ]
{
p->avl.left = q;
}
else
{
p->avl.right = q;
4000eb30: c6 20 60 0c st %g3, [ %g1 + 0xc ]
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
4000eb34: 80 8f 20 ff btst 0xff, %i4
4000eb38: 02 80 00 13 be 4000eb84 <rtems_bdbuf_get_buffer_from_lru_list+0x2a4>
4000eb3c: 84 00 bf fc add %g2, -4, %g2
{
if (p->avl.cache == -1)
4000eb40: 89 39 20 18 sra %g4, 0x18, %g4
4000eb44: 80 a1 3f ff cmp %g4, -1
4000eb48: 02 80 00 1e be 4000ebc0 <rtems_bdbuf_get_buffer_from_lru_list+0x2e0>
4000eb4c: c6 48 60 11 ldsb [ %g1 + 0x11 ], %g3
break;
}
}
else
{
switch (p->avl.bal)
4000eb50: 80 a0 e0 00 cmp %g3, 0
4000eb54: 22 bf ff eb be,a 4000eb00 <rtems_bdbuf_get_buffer_from_lru_list+0x220>
4000eb58: f2 28 60 11 stb %i1, [ %g1 + 0x11 ]
4000eb5c: 80 a0 e0 01 cmp %g3, 1
4000eb60: 02 80 00 1f be 4000ebdc <rtems_bdbuf_get_buffer_from_lru_list+0x2fc>
4000eb64: 80 a0 ff ff cmp %g3, -1
4000eb68: 22 80 00 0c be,a 4000eb98 <rtems_bdbuf_get_buffer_from_lru_list+0x2b8><== ALWAYS TAKEN
4000eb6c: c0 28 60 11 clrb [ %g1 + 0x11 ]
4000eb70: 86 10 00 01 mov %g1, %g3 <== NOT EXECUTED
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
4000eb74: 80 a0 80 0f cmp %g2, %o7 <== NOT EXECUTED
4000eb78: 18 bf ff e7 bgu 4000eb14 <rtems_bdbuf_get_buffer_from_lru_list+0x234><== NOT EXECUTED
4000eb7c: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
p->avl.right = q;
}
}
else
{
*root = p;
4000eb80: c6 26 a0 3c st %g3, [ %i2 + 0x3c ] <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000eb84: 82 10 20 01 mov 1, %g1
4000eb88: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
node = rtems_chain_next (node);
}
return NULL;
}
4000eb8c: 81 c7 e0 08 ret
4000eb90: 91 e8 00 1d restore %g0, %i5, %o0
else
{
switch (p->avl.bal)
{
case -1:
p->avl.bal = 0;
4000eb94: c0 28 60 11 clrb [ %g1 + 0x11 ]
4000eb98: 86 10 00 01 mov %g1, %g3
modified = false;
4000eb9c: 10 bf ff db b 4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000eba0: b8 10 20 00 clr %i4
bool modified = false;
if (p == NULL)
{
*root = node;
4000eba4: fa 26 a0 3c st %i5, [ %i2 + 0x3c ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000eba8: 82 10 20 01 mov 1, %g1
bool modified = false;
if (p == NULL)
{
*root = node;
node->avl.left = NULL;
4000ebac: c0 27 60 08 clr [ %i5 + 8 ]
node->avl.right = NULL;
4000ebb0: c0 27 60 0c clr [ %i5 + 0xc ]
node->avl.bal = 0;
4000ebb4: c0 2f 60 11 clrb [ %i5 + 0x11 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000ebb8: 10 bf ff f5 b 4000eb8c <rtems_bdbuf_get_buffer_from_lru_list+0x2ac>
4000ebbc: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
while (modified)
{
if (p->avl.cache == -1)
{
switch (p->avl.bal)
4000ebc0: 80 a0 e0 00 cmp %g3, 0
4000ebc4: 12 80 00 20 bne 4000ec44 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
4000ebc8: 80 a0 e0 01 cmp %g3, 1
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = -1;
4000ebcc: c8 28 60 11 stb %g4, [ %g1 + 0x11 ]
4000ebd0: 86 10 00 01 mov %g1, %g3
4000ebd4: 10 bf ff cd b 4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000ebd8: b8 10 20 01 mov 1, %i4
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
4000ebdc: c8 00 60 0c ld [ %g1 + 0xc ], %g4
if (p1->avl.bal == 1) /* simple RR-turn */
4000ebe0: c6 49 20 11 ldsb [ %g4 + 0x11 ], %g3
4000ebe4: 80 a0 e0 01 cmp %g3, 1
4000ebe8: 02 80 00 32 be 4000ecb0 <rtems_bdbuf_get_buffer_from_lru_list+0x3d0>
4000ebec: c6 01 20 08 ld [ %g4 + 8 ], %g3
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000ebf0: f6 00 e0 0c ld [ %g3 + 0xc ], %i3
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4000ebf4: f8 48 e0 11 ldsb [ %g3 + 0x11 ], %i4
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000ebf8: f6 21 20 08 st %i3, [ %g4 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
4000ebfc: f6 00 e0 08 ld [ %g3 + 8 ], %i3
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
4000ec00: c8 20 e0 0c st %g4, [ %g3 + 0xc ]
p->avl.right = p2->avl.left;
4000ec04: f6 20 60 0c st %i3, [ %g1 + 0xc ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4000ec08: 80 a7 20 01 cmp %i4, 1
4000ec0c: 02 80 00 30 be 4000eccc <rtems_bdbuf_get_buffer_from_lru_list+0x3ec><== NEVER TAKEN
4000ec10: c2 20 e0 08 st %g1, [ %g3 + 8 ]
4000ec14: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
4000ec18: c2 48 e0 11 ldsb [ %g3 + 0x11 ], %g1
4000ec1c: 80 a0 7f ff cmp %g1, -1
4000ec20: 22 80 00 06 be,a 4000ec38 <rtems_bdbuf_get_buffer_from_lru_list+0x358><== NEVER TAKEN
4000ec24: f2 29 20 11 stb %i1, [ %g4 + 0x11 ] <== NOT EXECUTED
4000ec28: c0 29 20 11 clrb [ %g4 + 0x11 ]
p = p2;
}
p->avl.bal = 0;
4000ec2c: c0 28 e0 11 clrb [ %g3 + 0x11 ]
modified = false;
4000ec30: 10 bf ff b6 b 4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000ec34: b8 10 20 00 clr %i4
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
4000ec38: c0 28 e0 11 clrb [ %g3 + 0x11 ] <== NOT EXECUTED
modified = false;
4000ec3c: 10 bf ff b3 b 4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228><== NOT EXECUTED
4000ec40: b8 10 20 00 clr %i4 <== NOT EXECUTED
while (modified)
{
if (p->avl.cache == -1)
{
switch (p->avl.bal)
4000ec44: 02 bf ff d4 be 4000eb94 <rtems_bdbuf_get_buffer_from_lru_list+0x2b4>
4000ec48: 80 a0 ff ff cmp %g3, -1
4000ec4c: 32 bf ff ca bne,a 4000eb74 <rtems_bdbuf_get_buffer_from_lru_list+0x294><== NEVER TAKEN
4000ec50: 86 10 00 01 mov %g1, %g3 <== NOT EXECUTED
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
4000ec54: c8 00 60 08 ld [ %g1 + 8 ], %g4
if (p1->avl.bal == -1) /* simple LL-turn */
4000ec58: c6 49 20 11 ldsb [ %g4 + 0x11 ], %g3
4000ec5c: 80 a0 ff ff cmp %g3, -1
4000ec60: 02 80 00 1d be 4000ecd4 <rtems_bdbuf_get_buffer_from_lru_list+0x3f4>
4000ec64: c6 01 20 0c ld [ %g4 + 0xc ], %g3
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000ec68: f6 00 e0 08 ld [ %g3 + 8 ], %i3
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4000ec6c: f8 48 e0 11 ldsb [ %g3 + 0x11 ], %i4
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000ec70: f6 21 20 0c st %i3, [ %g4 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
4000ec74: f6 00 e0 0c ld [ %g3 + 0xc ], %i3
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
4000ec78: c8 20 e0 08 st %g4, [ %g3 + 8 ]
p->avl.left = p2->avl.right;
4000ec7c: f6 20 60 08 st %i3, [ %g1 + 8 ]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4000ec80: 80 a7 3f ff cmp %i4, -1
4000ec84: 02 80 00 1b be 4000ecf0 <rtems_bdbuf_get_buffer_from_lru_list+0x410>
4000ec88: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
4000ec8c: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000ec90: c2 48 e0 11 ldsb [ %g3 + 0x11 ], %g1
4000ec94: 80 a0 60 01 cmp %g1, 1
4000ec98: 32 bf ff e5 bne,a 4000ec2c <rtems_bdbuf_get_buffer_from_lru_list+0x34c>
4000ec9c: c0 29 20 11 clrb [ %g4 + 0x11 ]
4000eca0: f0 29 20 11 stb %i0, [ %g4 + 0x11 ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
4000eca4: c0 28 e0 11 clrb [ %g3 + 0x11 ]
modified = false;
4000eca8: 10 bf ff 98 b 4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000ecac: b8 10 20 00 clr %i4
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
4000ecb0: c6 20 60 0c st %g3, [ %g1 + 0xc ]
p1->avl.left = p;
p->avl.bal = 0;
4000ecb4: c0 28 60 11 clrb [ %g1 + 0x11 ]
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
p1->avl.left = p;
4000ecb8: c2 21 20 08 st %g1, [ %g4 + 8 ]
p->avl.bal = 0;
4000ecbc: 86 10 00 04 mov %g4, %g3
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
modified = false;
4000ecc0: b8 10 20 00 clr %i4
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
4000ecc4: 10 bf ff 91 b 4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000ecc8: c0 28 e0 11 clrb [ %g3 + 0x11 ]
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4000eccc: 10 bf ff d3 b 4000ec18 <rtems_bdbuf_get_buffer_from_lru_list+0x338><== NOT EXECUTED
4000ecd0: f0 28 60 11 stb %i0, [ %g1 + 0x11 ] <== NOT EXECUTED
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
4000ecd4: c6 20 60 08 st %g3, [ %g1 + 8 ]
p1->avl.right = p;
p->avl.bal = 0;
4000ecd8: c0 28 60 11 clrb [ %g1 + 0x11 ]
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
4000ecdc: c2 21 20 0c st %g1, [ %g4 + 0xc ]
p->avl.bal = 0;
4000ece0: 86 10 00 04 mov %g4, %g3
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
modified = false;
4000ece4: b8 10 20 00 clr %i4
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
4000ece8: 10 bf ff 88 b 4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000ecec: c0 28 e0 11 clrb [ %g3 + 0x11 ]
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
4000ecf0: 10 bf ff e8 b 4000ec90 <rtems_bdbuf_get_buffer_from_lru_list+0x3b0>
4000ecf4: f2 28 60 11 stb %i1, [ %g1 + 0x11 ]
4000f960 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
4000f960: 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())
4000f964: 03 10 00 73 sethi %hi(0x4001cc00), %g1
4000f968: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 4001cfb8 <_Per_CPU_Information+0x8>
4000f96c: 80 a0 60 00 cmp %g1, 0
4000f970: 12 80 00 16 bne 4000f9c8 <rtems_bdbuf_init+0x68> <== NEVER TAKEN
4000f974: 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)
4000f978: 3b 10 00 6a sethi %hi(0x4001a800), %i5
4000f97c: ba 17 63 d8 or %i5, 0x3d8, %i5 ! 4001abd8 <rtems_bdbuf_configuration>
4000f980: f4 07 60 28 ld [ %i5 + 0x28 ], %i2
4000f984: f6 07 60 24 ld [ %i5 + 0x24 ], %i3
4000f988: 90 10 00 1a mov %i2, %o0
4000f98c: 92 10 00 1b mov %i3, %o1
4000f990: 40 00 24 c9 call 40018cb4 <.urem>
4000f994: b0 10 20 0a mov 0xa, %i0
4000f998: 80 a2 20 00 cmp %o0, 0
4000f99c: 12 80 00 fa bne 4000fd84 <rtems_bdbuf_init+0x424> <== NEVER TAKEN
4000f9a0: 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 ();
4000f9a4: 7f ff f9 a9 call 4000e048 <rtems_bdbuf_disable_preemption>
4000f9a8: 33 10 00 71 sethi %hi(0x4001c400), %i1
if (bdbuf_cache.initialised)
4000f9ac: b8 16 61 8c or %i1, 0x18c, %i4 ! 4001c58c <bdbuf_cache>
4000f9b0: c2 0f 20 95 ldub [ %i4 + 0x95 ], %g1
4000f9b4: 80 a0 60 00 cmp %g1, 0
4000f9b8: 02 80 00 06 be 4000f9d0 <rtems_bdbuf_init+0x70> <== ALWAYS TAKEN
4000f9bc: b0 10 00 08 mov %o0, %i0
{
rtems_bdbuf_restore_preemption (prev_mode);
4000f9c0: 7f ff f9 b0 call 4000e080 <rtems_bdbuf_restore_preemption><== NOT EXECUTED
4000f9c4: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
4000f9c8: 81 c7 e0 08 ret <== NOT EXECUTED
4000f9cc: 81 e8 00 00 restore <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
4000f9d0: 92 10 20 00 clr %o1
4000f9d4: 94 10 20 98 mov 0x98, %o2
4000f9d8: 40 00 18 bc call 40015cc8 <memset>
4000f9dc: 90 10 00 1c mov %i4, %o0
bdbuf_cache.initialised = true;
4000f9e0: 82 10 20 01 mov 1, %g1
rtems_bdbuf_restore_preemption (prev_mode);
4000f9e4: 90 10 00 18 mov %i0, %o0
4000f9e8: 7f ff f9 a6 call 4000e080 <rtems_bdbuf_restore_preemption>
4000f9ec: c2 2f 20 95 stb %g1, [ %i4 + 0x95 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000f9f0: 82 07 20 0c add %i4, 0xc, %g1
4000f9f4: c2 27 20 08 st %g1, [ %i4 + 8 ]
head->previous = NULL;
tail->previous = head;
4000f9f8: 82 07 20 08 add %i4, 8, %g1
4000f9fc: c2 27 20 10 st %g1, [ %i4 + 0x10 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000fa00: 82 07 20 50 add %i4, 0x50, %g1
head->previous = NULL;
tail->previous = head;
4000fa04: 84 07 20 40 add %i4, 0x40, %g2
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000fa08: c2 27 20 4c st %g1, [ %i4 + 0x4c ]
4000fa0c: 82 07 20 5c add %i4, 0x5c, %g1
head->previous = NULL;
tail->previous = head;
4000fa10: c4 27 20 48 st %g2, [ %i4 + 0x48 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000fa14: c2 27 20 58 st %g1, [ %i4 + 0x58 ]
head->previous = NULL;
tail->previous = head;
4000fa18: 84 07 20 4c add %i4, 0x4c, %g2
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000fa1c: 82 07 20 8c add %i4, 0x8c, %g1
head->previous = NULL;
tail->previous = head;
4000fa20: c4 27 20 54 st %g2, [ %i4 + 0x54 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000fa24: c2 27 20 88 st %g1, [ %i4 + 0x88 ]
head->previous = NULL;
tail->previous = head;
4000fa28: 84 07 20 58 add %i4, 0x58, %g2
4000fa2c: 82 07 20 88 add %i4, 0x88, %g1
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000fa30: a0 07 20 44 add %i4, 0x44, %l0
*/
cache_aligment = 32; /* FIXME rtems_cache_get_data_line_size() */
if (cache_aligment <= 0)
cache_aligment = CPU_ALIGNMENT;
bdbuf_cache.sync_device = BDBUF_INVALID_DEV;
4000fa34: c0 27 20 38 clr [ %i4 + 0x38 ]
head->previous = NULL;
4000fa38: c0 27 20 0c clr [ %i4 + 0xc ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000fa3c: e0 27 20 40 st %l0, [ %i4 + 0x40 ]
head->previous = NULL;
4000fa40: c0 27 20 44 clr [ %i4 + 0x44 ]
4000fa44: c0 27 20 50 clr [ %i4 + 0x50 ]
4000fa48: c0 27 20 5c clr [ %i4 + 0x5c ]
tail->previous = head;
4000fa4c: c4 27 20 60 st %g2, [ %i4 + 0x60 ]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4000fa50: c0 27 20 8c clr [ %i4 + 0x8c ]
rtems_chain_initialize_empty (&bdbuf_cache.read_ahead_chain);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
4000fa54: 31 10 91 10 sethi %hi(0x42444000), %i0
tail->previous = head;
4000fa58: c2 27 20 90 st %g1, [ %i4 + 0x90 ]
4000fa5c: 90 16 23 6c or %i0, 0x36c, %o0
4000fa60: 92 10 20 01 mov 1, %o1
4000fa64: 94 10 20 54 mov 0x54, %o2
4000fa68: 96 10 20 00 clr %o3
4000fa6c: 7f ff e7 35 call 40009740 <rtems_semaphore_create>
4000fa70: 98 07 20 28 add %i4, 0x28, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
4000fa74: 80 a2 20 00 cmp %o0, 0
4000fa78: 02 80 00 2d be 4000fb2c <rtems_bdbuf_init+0x1cc> <== ALWAYS TAKEN
4000fa7c: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.read_ahead_task != 0)
4000fa80: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
4000fa84: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000fa88: 12 80 00 25 bne 4000fb1c <rtems_bdbuf_init+0x1bc> <== NOT EXECUTED
4000fa8c: 01 00 00 00 nop <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.read_ahead_task);
if (bdbuf_cache.swapout != 0)
4000fa90: d0 06 61 8c ld [ %i1 + 0x18c ], %o0 <== NOT EXECUTED
4000fa94: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000fa98: 12 80 00 1e bne 4000fb10 <rtems_bdbuf_init+0x1b0> <== NOT EXECUTED
4000fa9c: 01 00 00 00 nop <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
free (bdbuf_cache.buffers);
4000faa0: 7f ff d6 2b call 4000534c <free> <== NOT EXECUTED
4000faa4: d0 07 20 18 ld [ %i4 + 0x18 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.groups);
4000faa8: 7f ff d6 29 call 4000534c <free> <== NOT EXECUTED
4000faac: d0 07 20 80 ld [ %i4 + 0x80 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.bds);
4000fab0: 7f ff d6 27 call 4000534c <free> <== NOT EXECUTED
4000fab4: d0 07 20 14 ld [ %i4 + 0x14 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
4000fab8: 7f ff e7 93 call 40009904 <rtems_semaphore_delete> <== NOT EXECUTED
4000fabc: d0 07 20 78 ld [ %i4 + 0x78 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
4000fac0: 7f ff e7 91 call 40009904 <rtems_semaphore_delete> <== NOT EXECUTED
4000fac4: d0 07 20 68 ld [ %i4 + 0x68 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
4000fac8: 7f ff e7 8f call 40009904 <rtems_semaphore_delete> <== NOT EXECUTED
4000facc: d0 07 20 70 ld [ %i4 + 0x70 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
4000fad0: 7f ff e7 8d call 40009904 <rtems_semaphore_delete> <== NOT EXECUTED
4000fad4: d0 07 20 2c ld [ %i4 + 0x2c ], %o0 <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
4000fad8: c2 07 20 28 ld [ %i4 + 0x28 ], %g1 <== NOT EXECUTED
4000fadc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000fae0: 12 80 00 05 bne 4000faf4 <rtems_bdbuf_init+0x194> <== NOT EXECUTED
4000fae4: 01 00 00 00 nop <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
rtems_semaphore_delete (bdbuf_cache.lock);
}
bdbuf_cache.initialised = false;
4000fae8: c0 2f 20 95 clrb [ %i4 + 0x95 ] <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
4000faec: 81 c7 e0 08 ret <== NOT EXECUTED
4000faf0: 91 e8 20 0d restore %g0, 0xd, %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
rtems_semaphore_delete (bdbuf_cache.sync_lock);
if (bdbuf_cache.lock != 0)
{
rtems_bdbuf_unlock_cache ();
4000faf4: 7f ff f9 42 call 4000dffc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000faf8: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
4000fafc: 7f ff e7 82 call 40009904 <rtems_semaphore_delete> <== NOT EXECUTED
4000fb00: d0 07 20 28 ld [ %i4 + 0x28 ], %o0 <== NOT EXECUTED
4000fb04: c0 2f 20 95 clrb [ %i4 + 0x95 ] <== NOT EXECUTED
4000fb08: 81 c7 e0 08 ret <== NOT EXECUTED
4000fb0c: 81 e8 00 00 restore <== NOT EXECUTED
if (bdbuf_cache.read_ahead_task != 0)
rtems_task_delete (bdbuf_cache.read_ahead_task);
if (bdbuf_cache.swapout != 0)
rtems_task_delete (bdbuf_cache.swapout);
4000fb10: 7f ff e8 8c call 40009d40 <rtems_task_delete> <== NOT EXECUTED
4000fb14: 01 00 00 00 nop <== NOT EXECUTED
4000fb18: 30 bf ff e2 b,a 4000faa0 <rtems_bdbuf_init+0x140> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.read_ahead_task != 0)
rtems_task_delete (bdbuf_cache.read_ahead_task);
4000fb1c: 7f ff e8 89 call 40009d40 <rtems_task_delete> <== NOT EXECUTED
4000fb20: 01 00 00 00 nop <== NOT EXECUTED
if (bdbuf_cache.swapout != 0)
4000fb24: 10 bf ff dc b 4000fa94 <rtems_bdbuf_init+0x134> <== NOT EXECUTED
4000fb28: d0 06 61 8c ld [ %i1 + 0x18c ], %o0 <== NOT EXECUTED
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
goto error;
rtems_bdbuf_lock_cache ();
4000fb2c: 7f ff f9 1e call 4000dfa4 <rtems_bdbuf_lock_cache>
4000fb30: 01 00 00 00 nop
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
4000fb34: 90 16 23 73 or %i0, 0x373, %o0
4000fb38: 92 10 20 01 mov 1, %o1
4000fb3c: 94 10 20 54 mov 0x54, %o2
4000fb40: 96 10 20 00 clr %o3
4000fb44: 7f ff e6 ff call 40009740 <rtems_semaphore_create>
4000fb48: 98 07 20 2c add %i4, 0x2c, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
4000fb4c: 80 a2 20 00 cmp %o0, 0
4000fb50: 32 bf ff cd bne,a 4000fa84 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000fb54: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
4000fb58: 90 16 23 61 or %i0, 0x361, %o0
4000fb5c: 92 10 20 00 clr %o1
4000fb60: 94 10 20 24 mov 0x24, %o2
4000fb64: 96 10 20 00 clr %o3
4000fb68: 7f ff e6 f6 call 40009740 <rtems_semaphore_create>
4000fb6c: 98 07 20 68 add %i4, 0x68, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4000fb70: 80 a2 20 00 cmp %o0, 0
4000fb74: 32 bf ff c4 bne,a 4000fa84 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000fb78: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
4000fb7c: 90 16 23 74 or %i0, 0x374, %o0
4000fb80: 92 10 20 00 clr %o1
4000fb84: 94 10 20 24 mov 0x24, %o2
4000fb88: 96 10 20 00 clr %o3
4000fb8c: 7f ff e6 ed call 40009740 <rtems_semaphore_create>
4000fb90: 98 07 20 70 add %i4, 0x70, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4000fb94: 80 a2 20 00 cmp %o0, 0
4000fb98: 32 bf ff bb bne,a 4000fa84 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000fb9c: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
4000fba0: 90 16 23 62 or %i0, 0x362, %o0
4000fba4: 92 10 20 00 clr %o1
4000fba8: 94 10 20 24 mov 0x24, %o2
4000fbac: 96 10 20 00 clr %o3
4000fbb0: 7f ff e6 e4 call 40009740 <rtems_semaphore_create>
4000fbb4: 98 07 20 78 add %i4, 0x78, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
4000fbb8: 80 a2 20 00 cmp %o0, 0
4000fbbc: 32 bf ff b2 bne,a 4000fa84 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000fbc0: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
4000fbc4: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
4000fbc8: 40 00 23 8f call 40018a04 <.udiv>
4000fbcc: 92 10 00 1b mov %i3, %o1
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
4000fbd0: 92 10 00 1b mov %i3, %o1
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
4000fbd4: b0 10 00 08 mov %o0, %i0
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
4000fbd8: d0 27 20 1c st %o0, [ %i4 + 0x1c ]
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
4000fbdc: 40 00 23 8a call 40018a04 <.udiv>
4000fbe0: 90 10 00 1a mov %i2, %o0
4000fbe4: 82 10 00 08 mov %o0, %g1
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4000fbe8: 90 10 00 18 mov %i0, %o0
4000fbec: 92 10 00 01 mov %g1, %o1
4000fbf0: 40 00 23 85 call 40018a04 <.udiv>
4000fbf4: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4000fbf8: 92 10 00 18 mov %i0, %o1
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
4000fbfc: d0 27 20 7c st %o0, [ %i4 + 0x7c ]
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
4000fc00: b4 10 00 08 mov %o0, %i2
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
4000fc04: 7f ff d5 9b call 40005270 <calloc>
4000fc08: 90 10 20 38 mov 0x38, %o0
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
4000fc0c: 80 a2 20 00 cmp %o0, 0
4000fc10: 02 bf ff 9c be 4000fa80 <rtems_bdbuf_init+0x120> <== NEVER TAKEN
4000fc14: d0 27 20 14 st %o0, [ %i4 + 0x14 ]
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
4000fc18: 90 10 20 14 mov 0x14, %o0
4000fc1c: 7f ff d5 95 call 40005270 <calloc>
4000fc20: 92 10 00 1a mov %i2, %o1
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
4000fc24: 80 a2 20 00 cmp %o0, 0
4000fc28: 02 bf ff 96 be 4000fa80 <rtems_bdbuf_init+0x120> <== NEVER TAKEN
4000fc2c: d0 27 20 80 st %o0, [ %i4 + 0x80 ]
*
* The memory allocate allows a
*/
if (rtems_memalign ((void **) &bdbuf_cache.buffers,
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
4000fc30: 92 10 00 1b mov %i3, %o1
4000fc34: 40 00 23 3a call 4001891c <.umul>
4000fc38: 90 10 00 18 mov %i0, %o0
* aligned. It is possible to free the memory allocated by rtems_memalign()
* with free(). Return 0 if allocated.
*
* The memory allocate allows a
*/
if (rtems_memalign ((void **) &bdbuf_cache.buffers,
4000fc3c: 92 10 20 20 mov 0x20, %o1
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
4000fc40: 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,
4000fc44: 11 10 00 71 sethi %hi(0x4001c400), %o0
4000fc48: 40 00 07 73 call 40011a14 <rtems_memalign>
4000fc4c: 90 12 21 a4 or %o0, 0x1a4, %o0 ! 4001c5a4 <bdbuf_cache+0x18>
4000fc50: 80 a2 20 00 cmp %o0, 0
4000fc54: 32 bf ff 8c bne,a 4000fa84 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000fc58: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
4000fc5c: f0 07 20 80 ld [ %i4 + 0x80 ], %i0
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
4000fc60: e2 07 20 14 ld [ %i4 + 0x14 ], %l1
bd->group = group;
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
4000fc64: ea 07 20 20 ld [ %i4 + 0x20 ], %l5
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
4000fc68: e8 07 20 18 ld [ %i4 + 0x18 ], %l4
b < bdbuf_cache.buffer_min_count;
4000fc6c: ee 07 20 1c ld [ %i4 + 0x1c ], %l7
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
4000fc70: ac 05 7f ff add %l5, -1, %l6
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
4000fc74: b4 10 00 11 mov %l1, %i2
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
4000fc78: a6 10 00 18 mov %i0, %l3
4000fc7c: a4 10 20 00 clr %l2
4000fc80: 80 a4 80 17 cmp %l2, %l7
4000fc84: 02 80 00 13 be 4000fcd0 <rtems_bdbuf_init+0x370>
4000fc88: 90 10 00 12 mov %l2, %o0
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dd = BDBUF_INVALID_DEV;
bd->group = group;
4000fc8c: e6 26 a0 28 st %l3, [ %i2 + 0x28 ]
bd->buffer = buffer;
4000fc90: e8 26 a0 1c st %l4, [ %i2 + 0x1c ]
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dd = BDBUF_INVALID_DEV;
4000fc94: c0 26 a0 14 clr [ %i2 + 0x14 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4000fc98: c2 07 20 48 ld [ %i4 + 0x48 ], %g1
the_node->next = tail;
4000fc9c: e0 26 80 00 st %l0, [ %i2 ]
tail->previous = the_node;
4000fca0: f4 27 20 48 st %i2, [ %i4 + 0x48 ]
old_last->next = the_node;
4000fca4: f4 20 40 00 st %i2, [ %g1 ]
the_node->previous = old_last;
4000fca8: c2 26 a0 04 st %g1, [ %i2 + 4 ]
bd->group = group;
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
4000fcac: 40 00 24 02 call 40018cb4 <.urem>
4000fcb0: 92 10 00 15 mov %l5, %o1
4000fcb4: 80 a2 00 16 cmp %o0, %l6
4000fcb8: 22 80 00 02 be,a 4000fcc0 <rtems_bdbuf_init+0x360>
4000fcbc: a6 04 e0 14 add %l3, 0x14, %l3
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
4000fcc0: a4 04 a0 01 inc %l2
4000fcc4: b4 06 a0 38 add %i2, 0x38, %i2
4000fcc8: 10 bf ff ee b 4000fc80 <rtems_bdbuf_init+0x320>
4000fccc: a8 05 00 1b add %l4, %i3, %l4
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
4000fcd0: c4 07 20 20 ld [ %i4 + 0x20 ], %g2
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
4000fcd4: f6 07 20 7c ld [ %i4 + 0x7c ], %i3
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
4000fcd8: 87 28 a0 03 sll %g2, 3, %g3
4000fcdc: 89 28 a0 06 sll %g2, 6, %g4
4000fce0: 82 10 20 00 clr %g1
4000fce4: 86 21 00 03 sub %g4, %g3, %g3
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
4000fce8: 80 a0 40 1b cmp %g1, %i3
4000fcec: 02 80 00 07 be 4000fd08 <rtems_bdbuf_init+0x3a8>
4000fcf0: 82 00 60 01 inc %g1
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
group->bdbuf = bd;
4000fcf4: e2 26 20 10 st %l1, [ %i0 + 0x10 ]
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
4000fcf8: c4 26 20 08 st %g2, [ %i0 + 8 ]
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
4000fcfc: b0 06 20 14 add %i0, 0x14, %i0
bd += bdbuf_cache.max_bds_per_group)
4000fd00: 10 bf ff fa b 4000fce8 <rtems_bdbuf_init+0x388>
4000fd04: a2 04 40 03 add %l1, %g3, %l1
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
4000fd08: d2 07 60 08 ld [ %i5 + 8 ], %o1
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
4000fd0c: b6 10 20 01 mov 1, %i3
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
4000fd10: 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;
4000fd14: f6 2f 20 04 stb %i3, [ %i4 + 4 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
4000fd18: 90 12 23 50 or %o0, 0x350, %o0
4000fd1c: 96 10 20 00 clr %o3
4000fd20: 15 10 00 3c sethi %hi(0x4000f000), %o2
4000fd24: 98 10 00 1c mov %i4, %o4
4000fd28: 7f ff f9 a6 call 4000e3c0 <rtems_bdbuf_create_task.constprop.9>
4000fd2c: 94 12 a2 f4 or %o2, 0x2f4, %o2
bdbuf_config.swapout_priority,
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_task,
0,
&bdbuf_cache.swapout);
if (sc != RTEMS_SUCCESSFUL)
4000fd30: 80 a2 20 00 cmp %o0, 0
4000fd34: 32 bf ff 54 bne,a 4000fa84 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000fd38: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
4000fd3c: 03 10 00 6a sethi %hi(0x4001a800), %g1
4000fd40: c2 00 63 d8 ld [ %g1 + 0x3d8 ], %g1 ! 4001abd8 <rtems_bdbuf_configuration>
4000fd44: 80 a0 60 00 cmp %g1, 0
4000fd48: 02 80 00 0d be 4000fd7c <rtems_bdbuf_init+0x41c>
4000fd4c: 11 10 94 91 sethi %hi(0x42524400), %o0
{
bdbuf_cache.read_ahead_enabled = true;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
4000fd50: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
if (sc != RTEMS_SUCCESSFUL)
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
{
bdbuf_cache.read_ahead_enabled = true;
4000fd54: f6 2f 20 94 stb %i3, [ %i4 + 0x94 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
4000fd58: 15 10 00 3e sethi %hi(0x4000f800), %o2
4000fd5c: 90 12 20 41 or %o0, 0x41, %o0
4000fd60: 94 12 a0 0c or %o2, 0xc, %o2
4000fd64: 96 10 20 00 clr %o3
4000fd68: 7f ff f9 96 call 4000e3c0 <rtems_bdbuf_create_task.constprop.9>
4000fd6c: 98 07 20 84 add %i4, 0x84, %o4
bdbuf_config.read_ahead_priority,
RTEMS_BDBUF_READ_AHEAD_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_read_ahead_task,
0,
&bdbuf_cache.read_ahead_task);
if (sc != RTEMS_SUCCESSFUL)
4000fd70: 80 a2 20 00 cmp %o0, 0
4000fd74: 32 bf ff 44 bne,a 4000fa84 <rtems_bdbuf_init+0x124> <== NEVER TAKEN
4000fd78: d0 07 20 84 ld [ %i4 + 0x84 ], %o0 <== NOT EXECUTED
goto error;
}
rtems_bdbuf_unlock_cache ();
4000fd7c: 7f ff f8 a0 call 4000dffc <rtems_bdbuf_unlock_cache>
4000fd80: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
4000fd84: 81 c7 e0 08 ret
4000fd88: 81 e8 00 00 restore
4000df70 <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)
{
4000df70: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_obtain (lock,
4000df74: 92 10 20 00 clr %o1
4000df78: 90 10 00 18 mov %i0, %o0
4000df7c: 7f ff ee 99 call 400099e0 <rtems_semaphore_obtain>
4000df80: 94 10 20 00 clr %o2
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4000df84: 80 a2 20 00 cmp %o0, 0
4000df88: 12 80 00 04 bne 4000df98 <rtems_bdbuf_lock+0x28> <== NEVER TAKEN
4000df8c: 01 00 00 00 nop
4000df90: 81 c7 e0 08 ret
4000df94: 81 e8 00 00 restore
rtems_bdbuf_fatal (fatal_error_code);
4000df98: 7f ff ff f1 call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000df9c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
400103a4 <rtems_bdbuf_purge_dev>:
}
}
void
rtems_bdbuf_purge_dev (rtems_disk_device *dd)
{
400103a4: 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;
400103a8: b4 07 bf 74 add %fp, -140, %i2
400103ac: b6 07 bf 78 add %fp, -136, %i3
head->previous = NULL;
400103b0: c0 27 bf 78 clr [ %fp + -136 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
400103b4: f6 27 bf 74 st %i3, [ %fp + -140 ]
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
400103b8: 7f ff f6 fb call 4000dfa4 <rtems_bdbuf_lock_cache>
400103bc: f4 27 bf 7c st %i2, [ %fp + -132 ]
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
400103c0: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
400103c4: 80 a0 60 00 cmp %g1, 0
400103c8: 02 80 00 70 be 40010588 <rtems_bdbuf_purge_dev+0x1e4> <== ALWAYS TAKEN
400103cc: c4 06 20 68 ld [ %i0 + 0x68 ], %g2
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
400103d0: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
previous->next = next;
400103d4: 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;
400103d8: c0 26 20 68 clr [ %i0 + 0x68 ] <== NOT EXECUTED
400103dc: c0 26 20 64 clr [ %i0 + 0x64 ] <== NOT EXECUTED
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
400103e0: 03 10 00 71 sethi %hi(0x4001c400), %g1 <== NOT EXECUTED
400103e4: 82 10 61 8c or %g1, 0x18c, %g1 ! 4001c58c <bdbuf_cache>
400103e8: fa 00 60 3c ld [ %g1 + 0x3c ], %i5
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
400103ec: 84 10 3f ff mov -1, %g2
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
400103f0: c0 27 bf 80 clr [ %fp + -128 ]
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
400103f4: c4 26 20 6c st %g2, [ %i0 + 0x6c ]
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
400103f8: 80 a7 60 00 cmp %i5, 0
400103fc: 02 80 00 2e be 400104b4 <rtems_bdbuf_purge_dev+0x110>
40010400: b8 07 bf 80 add %fp, -128, %i4
{
if (cur->dd == dd)
{
switch (cur->state)
40010404: 33 10 00 37 sethi %hi(0x4000dc00), %i1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
40010408: a2 10 20 06 mov 6, %l1
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
4001040c: b2 16 61 ac or %i1, 0x1ac, %i1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
40010410: a4 10 20 0a mov 0xa, %l2
case RTEMS_BDBUF_STATE_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
break;
case RTEMS_BDBUF_STATE_SYNC:
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
40010414: 10 80 00 09 b 40010438 <rtems_bdbuf_purge_dev+0x94>
40010418: a0 00 60 6c add %g1, 0x6c, %l0
default:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);
}
}
if (cur->avl.left != NULL)
4001041c: c2 07 60 08 ld [ %i5 + 8 ], %g1
40010420: 80 a0 60 00 cmp %g1, 0
40010424: 22 80 00 0f be,a 40010460 <rtems_bdbuf_purge_dev+0xbc>
40010428: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
*prev = cur;
4001042c: fa 27 20 04 st %i5, [ %i4 + 4 ]
40010430: ba 10 00 01 mov %g1, %i5
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
40010434: b8 07 20 04 add %i4, 4, %i4
*prev = NULL;
while (cur != NULL)
{
if (cur->dd == dd)
40010438: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001043c: 80 a6 00 01 cmp %i0, %g1
40010440: 32 bf ff f8 bne,a 40010420 <rtems_bdbuf_purge_dev+0x7c>
40010444: c2 07 60 08 ld [ %i5 + 8 ], %g1
{
switch (cur->state)
40010448: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4001044c: 80 a0 60 0a cmp %g1, 0xa
40010450: 28 80 00 34 bleu,a 40010520 <rtems_bdbuf_purge_dev+0x17c><== ALWAYS TAKEN
40010454: 83 28 60 02 sll %g1, 2, %g1
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_set_state (cur, RTEMS_BDBUF_STATE_ACCESS_PURGED);
break;
default:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);
40010458: 7f ff f6 c1 call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4001045c: 90 10 20 17 mov 0x17, %o0 <== NOT EXECUTED
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
40010460: 80 a0 60 00 cmp %g1, 0
40010464: 32 bf ff f3 bne,a 40010430 <rtems_bdbuf_purge_dev+0x8c>
40010468: fa 27 20 04 st %i5, [ %i4 + 4 ]
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
4001046c: c2 07 00 00 ld [ %i4 ], %g1
40010470: 80 a0 60 00 cmp %g1, 0
40010474: 32 80 00 06 bne,a 4001048c <rtems_bdbuf_purge_dev+0xe8>
40010478: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4001047c: 10 80 00 0f b 400104b8 <rtems_bdbuf_purge_dev+0x114>
40010480: d0 07 bf 74 ld [ %fp + -140 ], %o0
40010484: 82 10 00 02 mov %g2, %g1
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
40010488: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4001048c: 80 a0 80 1d cmp %g2, %i5
40010490: 02 80 00 04 be 400104a0 <rtems_bdbuf_purge_dev+0xfc>
40010494: 80 a0 a0 00 cmp %g2, 0
40010498: 32 bf ff e8 bne,a 40010438 <rtems_bdbuf_purge_dev+0x94>
4001049c: ba 10 00 02 mov %g2, %i5
{
/* Up */
cur = *prev;
--prev;
400104a0: b8 07 3f fc add %i4, -4, %i4
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
400104a4: c4 07 00 00 ld [ %i4 ], %g2
400104a8: 80 a0 a0 00 cmp %g2, 0
400104ac: 12 bf ff f6 bne 40010484 <rtems_bdbuf_purge_dev+0xe0>
400104b0: ba 10 00 01 mov %g1, %i5
400104b4: d0 07 bf 74 ld [ %fp + -140 ], %o0
}
static void
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
400104b8: 86 10 20 00 clr %g3
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
400104bc: ba 10 20 01 mov 1, %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
400104c0: 80 a2 00 1b cmp %o0, %i3
400104c4: 02 80 00 0f be 40010500 <rtems_bdbuf_purge_dev+0x15c>
400104c8: 80 88 e0 ff btst 0xff, %g3
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
400104cc: c2 02 00 00 ld [ %o0 ], %g1
while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
400104d0: c4 02 20 24 ld [ %o0 + 0x24 ], %g2
head->next = new_first;
400104d4: c2 27 bf 74 st %g1, [ %fp + -140 ]
400104d8: 80 a0 a0 00 cmp %g2, 0
400104dc: 12 80 00 28 bne 4001057c <rtems_bdbuf_purge_dev+0x1d8>
400104e0: f4 20 60 04 st %i2, [ %g1 + 4 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
400104e4: 7f ff f8 ca call 4000e80c <rtems_bdbuf_discard_buffer.part.4>
400104e8: fa 22 20 20 st %i5, [ %o0 + 0x20 ]
400104ec: d0 07 bf 74 ld [ %fp + -140 ], %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
400104f0: 80 a2 00 1b cmp %o0, %i3
400104f4: 12 bf ff f6 bne 400104cc <rtems_bdbuf_purge_dev+0x128>
400104f8: 86 10 20 01 mov 1, %g3
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
400104fc: 80 88 e0 ff btst 0xff, %g3
40010500: 02 80 00 04 be 40010510 <rtems_bdbuf_purge_dev+0x16c>
40010504: 11 10 00 71 sethi %hi(0x4001c400), %o0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
40010508: 7f ff f7 5e call 4000e280 <rtems_bdbuf_wake>
4001050c: 90 12 22 00 or %o0, 0x200, %o0 ! 4001c600 <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 ();
40010510: 7f ff f6 bb call 4000dffc <rtems_bdbuf_unlock_cache>
40010514: 01 00 00 00 nop
40010518: 81 c7 e0 08 ret
4001051c: 81 e8 00 00 restore
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
40010520: c4 06 40 01 ld [ %i1 + %g1 ], %g2
40010524: 81 c0 80 00 jmp %g2
40010528: 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);
4001052c: 7f ff f7 55 call 4000e280 <rtems_bdbuf_wake>
40010530: 90 10 00 10 mov %l0, %o0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
40010534: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
40010538: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
4001053c: 82 00 7f ff add %g1, -1, %g1
40010540: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
40010544: c4 07 60 04 ld [ %i5 + 4 ], %g2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40010548: c6 07 40 00 ld [ %i5 ], %g3
previous = the_node->previous;
next->previous = previous;
4001054c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
40010550: c6 20 80 00 st %g3, [ %g2 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
40010554: c4 07 bf 7c ld [ %fp + -132 ], %g2
the_node->next = tail;
40010558: f6 27 40 00 st %i3, [ %i5 ]
tail->previous = the_node;
4001055c: fa 27 bf 7c st %i5, [ %fp + -132 ]
old_last->next = the_node;
40010560: fa 20 80 00 st %i5, [ %g2 ]
the_node->previous = old_last;
40010564: 10 bf ff ae b 4001041c <rtems_bdbuf_purge_dev+0x78>
40010568: c4 27 60 04 st %g2, [ %i5 + 4 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4001056c: 10 bf ff ac b 4001041c <rtems_bdbuf_purge_dev+0x78>
40010570: e2 27 60 20 st %l1, [ %i5 + 0x20 ]
40010574: 10 bf ff aa b 4001041c <rtems_bdbuf_purge_dev+0x78>
40010578: e4 27 60 20 st %l2, [ %i5 + 0x20 ]
4001057c: fa 22 20 20 st %i5, [ %o0 + 0x20 ]
40010580: 10 bf ff d0 b 400104c0 <rtems_bdbuf_purge_dev+0x11c>
40010584: 90 10 00 01 mov %g1, %o0
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
40010588: 80 a0 a0 00 cmp %g2, 0
4001058c: 32 bf ff 92 bne,a 400103d4 <rtems_bdbuf_purge_dev+0x30> <== NEVER TAKEN
40010590: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
40010594: 10 bf ff 94 b 400103e4 <rtems_bdbuf_purge_dev+0x40>
40010598: 03 10 00 71 sethi %hi(0x4001c400), %g1
4000fe8c <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
4000fe8c: 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 ();
4000fe90: 7f ff f8 45 call 4000dfa4 <rtems_bdbuf_lock_cache>
4000fe94: 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)
4000fe98: 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;
4000fe9c: 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)
4000fea0: 80 a6 40 01 cmp %i1, %g1
4000fea4: 0a 80 00 07 bcs 4000fec0 <rtems_bdbuf_read+0x34> <== ALWAYS TAKEN
4000fea8: b0 10 20 04 mov 4, %i0
}
rtems_bdbuf_check_read_ahead_trigger (dd, block);
}
rtems_bdbuf_unlock_cache ();
4000feac: 7f ff f8 54 call 4000dffc <rtems_bdbuf_unlock_cache>
4000feb0: 01 00 00 00 nop
*bd_ptr = bd;
4000feb4: f8 26 80 00 st %i4, [ %i2 ]
4000feb8: 81 c7 e0 08 ret
4000febc: 81 e8 00 00 restore
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
4000fec0: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
4000fec4: 80 a2 60 00 cmp %o1, 0
4000fec8: 26 80 00 60 bl,a 40010048 <rtems_bdbuf_read+0x1bc> <== NEVER TAKEN
4000fecc: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
4000fed0: 93 2e 40 09 sll %i1, %o1, %o1
/*
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
4000fed4: 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);
4000fed8: 90 10 00 1d mov %i5, %o0
4000fedc: 7f ff fb 9e call 4000ed54 <rtems_bdbuf_get_buffer_for_access>
4000fee0: 92 02 40 01 add %o1, %g1, %o1
4000fee4: b8 10 00 08 mov %o0, %i4
switch (bd->state)
4000fee8: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
4000feec: 80 a2 20 02 cmp %o0, 2
4000fef0: 02 80 00 4f be 4001002c <rtems_bdbuf_read+0x1a0>
4000fef4: 80 a2 20 07 cmp %o0, 7
4000fef8: 02 80 00 06 be 4000ff10 <rtems_bdbuf_read+0x84>
4000fefc: 80 a2 20 01 cmp %o0, 1
4000ff00: 22 80 00 28 be,a 4000ffa0 <rtems_bdbuf_read+0x114> <== ALWAYS TAKEN
4000ff04: c4 07 60 48 ld [ %i5 + 0x48 ], %g2
{
bd = NULL;
}
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
4000ff08: 7f ff f8 2d call 4000dfbc <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000ff0c: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
break;
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
4000ff10: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000ff14: b0 10 20 00 clr %i0
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
break;
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
4000ff18: 82 00 60 01 inc %g1
4000ff1c: 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;
4000ff20: 82 10 20 04 mov 4, %g1
4000ff24: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
static void
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (bdbuf_cache.read_ahead_task != 0
4000ff28: 37 10 00 71 sethi %hi(0x4001c400), %i3
4000ff2c: b6 16 e1 8c or %i3, 0x18c, %i3 ! 4001c58c <bdbuf_cache>
4000ff30: d0 06 e0 84 ld [ %i3 + 0x84 ], %o0
4000ff34: 80 a2 20 00 cmp %o0, 0
4000ff38: 02 bf ff dd be 4000feac <rtems_bdbuf_read+0x20>
4000ff3c: 01 00 00 00 nop
&& dd->read_ahead.trigger == block
4000ff40: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
4000ff44: 80 a6 40 01 cmp %i1, %g1
4000ff48: 12 bf ff d9 bne 4000feac <rtems_bdbuf_read+0x20>
4000ff4c: 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);
4000ff50: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
4000ff54: 80 a0 60 00 cmp %g1, 0
4000ff58: 12 bf ff d5 bne 4000feac <rtems_bdbuf_read+0x20> <== NEVER TAKEN
4000ff5c: 01 00 00 00 nop
4000ff60: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
4000ff64: 80 a0 60 00 cmp %g1, 0
4000ff68: 12 bf ff d1 bne 4000feac <rtems_bdbuf_read+0x20> <== NEVER TAKEN
4000ff6c: 01 00 00 00 nop
&& !rtems_bdbuf_is_read_ahead_active (dd))
{
rtems_status_code sc;
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
if (rtems_chain_is_empty (chain))
4000ff70: c2 06 e0 88 ld [ %i3 + 0x88 ], %g1
4000ff74: b2 06 e0 8c add %i3, 0x8c, %i1
4000ff78: 80 a0 40 19 cmp %g1, %i1
4000ff7c: 02 80 00 41 be 40010080 <rtems_bdbuf_read+0x1f4> <== ALWAYS TAKEN
4000ff80: 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;
4000ff84: c2 06 e0 90 ld [ %i3 + 0x90 ], %g1 <== NOT EXECUTED
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
}
rtems_chain_append_unprotected (chain, &dd->read_ahead.node);
4000ff88: 84 07 60 64 add %i5, 0x64, %g2
the_node->next = tail;
4000ff8c: f2 27 60 64 st %i1, [ %i5 + 0x64 ]
tail->previous = the_node;
4000ff90: c4 26 e0 90 st %g2, [ %i3 + 0x90 ]
old_last->next = the_node;
4000ff94: c4 20 40 00 st %g2, [ %g1 ]
the_node->previous = old_last;
4000ff98: 10 bf ff c5 b 4000feac <rtems_bdbuf_read+0x20>
4000ff9c: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
static void
rtems_bdbuf_set_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
4000ffa0: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
case RTEMS_BDBUF_STATE_EMPTY:
++dd->stats.read_misses;
4000ffa4: 84 00 a0 01 inc %g2
static void
rtems_bdbuf_set_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
4000ffa8: 80 a6 40 01 cmp %i1, %g1
4000ffac: 02 80 00 0e be 4000ffe4 <rtems_bdbuf_read+0x158>
4000ffb0: c4 27 60 48 st %g2, [ %i5 + 0x48 ]
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
4000ffb4: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
4000ffb8: 80 a0 60 00 cmp %g1, 0
4000ffbc: 02 80 00 2c be 4001006c <rtems_bdbuf_read+0x1e0> <== ALWAYS TAKEN
4000ffc0: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
4000ffc4: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
previous->next = next;
4000ffc8: 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;
4000ffcc: c0 27 60 68 clr [ %i5 + 0x68 ] <== NOT EXECUTED
4000ffd0: c0 27 60 64 clr [ %i5 + 0x64 ] <== NOT EXECUTED
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = block + 1;
4000ffd4: 84 06 60 01 add %i1, 1, %g2 <== NOT EXECUTED
dd->read_ahead.next = block + 2;
4000ffd8: 82 06 60 02 add %i1, 2, %g1
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = block + 1;
4000ffdc: c4 27 60 6c st %g2, [ %i5 + 0x6c ]
dd->read_ahead.next = block + 2;
4000ffe0: 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);
4000ffe4: 90 10 00 1d mov %i5, %o0
4000ffe8: 92 10 00 1c mov %i4, %o1
4000ffec: 7f ff fd cc call 4000f71c <rtems_bdbuf_execute_read_request>
4000fff0: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
4000fff4: b0 92 20 00 orcc %o0, 0, %i0
4000fff8: 32 bf ff cc bne,a 4000ff28 <rtems_bdbuf_read+0x9c>
4000fffc: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
40010000: c2 07 20 28 ld [ %i4 + 0x28 ], %g1
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
40010004: c4 07 20 04 ld [ %i4 + 4 ], %g2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40010008: c6 07 00 00 ld [ %i4 ], %g3
4001000c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
40010010: b6 10 20 03 mov 3, %i3
40010014: f6 27 20 20 st %i3, [ %i4 + 0x20 ]
previous = the_node->previous;
next->previous = previous;
40010018: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
4001001c: c6 20 80 00 st %g3, [ %g2 ]
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
40010020: 84 01 20 01 add %g4, 1, %g2
40010024: 10 bf ff c1 b 4000ff28 <rtems_bdbuf_read+0x9c>
40010028: c4 20 60 0c st %g2, [ %g1 + 0xc ]
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
switch (bd->state)
{
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
4001002c: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
40010030: b0 10 20 00 clr %i0
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
switch (bd->state)
{
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
40010034: 82 00 60 01 inc %g1
40010038: 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;
4001003c: 82 10 20 03 mov 3, %g1
40010040: 10 bf ff ba b 4000ff28 <rtems_bdbuf_read+0x9c>
40010044: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
40010048: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001004c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40010050: 40 00 23 c5 call 40018f64 <__muldi3> <== NOT EXECUTED
40010054: 90 10 20 00 clr %o0 <== NOT EXECUTED
40010058: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
4001005c: 40 00 25 d3 call 400197a8 <__udivdi3> <== NOT EXECUTED
40010060: 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;
40010064: 10 bf ff 9d b 4000fed8 <rtems_bdbuf_read+0x4c> <== NOT EXECUTED
40010068: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
4001006c: 80 a0 a0 00 cmp %g2, 0
40010070: 32 bf ff d5 bne,a 4000ffc4 <rtems_bdbuf_read+0x138> <== NEVER TAKEN
40010074: c4 07 60 68 ld [ %i5 + 0x68 ], %g2 <== NOT EXECUTED
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = block + 1;
40010078: 10 bf ff d8 b 4000ffd8 <rtems_bdbuf_read+0x14c>
4001007c: 84 06 60 01 add %i1, 1, %g2
rtems_status_code sc;
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
if (rtems_chain_is_empty (chain))
{
sc = rtems_event_send (bdbuf_cache.read_ahead_task,
40010080: 7f ff e5 1f call 400094fc <rtems_event_send>
40010084: 92 10 20 02 mov 2, %o1
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
40010088: 80 a2 20 00 cmp %o0, 0
4001008c: 22 bf ff bf be,a 4000ff88 <rtems_bdbuf_read+0xfc> <== ALWAYS TAKEN
40010090: c2 06 e0 90 ld [ %i3 + 0x90 ], %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
40010094: 7f ff f7 b2 call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
40010098: 90 10 20 07 mov 7, %o0 <== NOT EXECUTED
4000f80c <rtems_bdbuf_read_ahead_task>:
return sc;
}
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
4000f80c: 9d e3 bf a0 save %sp, -96, %sp
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
4000f810: 37 10 00 71 sethi %hi(0x4001c400), %i3
4000f814: b6 16 e1 8c or %i3, 0x18c, %i3 ! 4001c58c <bdbuf_cache>
4000f818: c2 0e e0 94 ldub [ %i3 + 0x94 ], %g1
4000f81c: 80 a0 60 00 cmp %g1, 0
4000f820: 02 80 00 22 be 4000f8a8 <rtems_bdbuf_read_ahead_task+0x9c><== NEVER TAKEN
4000f824: b0 06 e0 88 add %i3, 0x88, %i0
4000f828: b2 06 e0 8c add %i3, 0x8c, %i1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000f82c: b4 10 00 1b mov %i3, %i2
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
{
uint32_t transfer_count = dd->block_count - block;
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
4000f830: 23 10 00 6a sethi %hi(0x4001a800), %l1
while (bdbuf_cache.read_ahead_enabled)
{
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
4000f834: 7f ff fa 53 call 4000e180 <rtems_bdbuf_wait_for_event>
4000f838: 90 10 20 02 mov 2, %o0
rtems_bdbuf_lock_cache ();
4000f83c: 7f ff f9 da call 4000dfa4 <rtems_bdbuf_lock_cache>
4000f840: 01 00 00 00 nop
4000f844: fa 06 e0 88 ld [ %i3 + 0x88 ], %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
4000f848: 80 a7 40 19 cmp %i5, %i1
4000f84c: 02 80 00 11 be 4000f890 <rtems_bdbuf_read_ahead_task+0x84>
4000f850: 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;
4000f854: c2 07 40 00 ld [ %i5 ], %g1
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
((char *) node - offsetof (rtems_disk_device, read_ahead.node));
rtems_blkdev_bnum block = dd->read_ahead.next;
4000f858: f8 07 60 0c ld [ %i5 + 0xc ], %i4
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
4000f85c: c4 07 7f c4 ld [ %i5 + -60 ], %g2
head->next = new_first;
4000f860: c2 26 a0 88 st %g1, [ %i2 + 0x88 ]
4000f864: 80 a7 00 02 cmp %i4, %g2
4000f868: 0a 80 00 12 bcs 4000f8b0 <rtems_bdbuf_read_ahead_task+0xa4>
4000f86c: f0 20 60 04 st %i0, [ %g1 + 4 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
4000f870: c0 27 60 04 clr [ %i5 + 4 ]
4000f874: c0 27 40 00 clr [ %i5 ]
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
}
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
4000f878: 82 10 3f ff mov -1, %g1
4000f87c: c2 27 60 08 st %g1, [ %i5 + 8 ]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000f880: fa 06 e0 88 ld [ %i3 + 0x88 ], %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
4000f884: 80 a7 40 19 cmp %i5, %i1
4000f888: 32 bf ff f4 bne,a 4000f858 <rtems_bdbuf_read_ahead_task+0x4c><== NEVER TAKEN
4000f88c: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
}
}
rtems_bdbuf_unlock_cache ();
4000f890: 7f ff f9 db call 4000dffc <rtems_bdbuf_unlock_cache>
4000f894: 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)
4000f898: c2 0e a0 94 ldub [ %i2 + 0x94 ], %g1
4000f89c: 80 a0 60 00 cmp %g1, 0
4000f8a0: 12 bf ff e5 bne 4000f834 <rtems_bdbuf_read_ahead_task+0x28><== ALWAYS TAKEN
4000f8a4: 01 00 00 00 nop
}
rtems_bdbuf_unlock_cache ();
}
rtems_task_delete (RTEMS_SELF);
4000f8a8: 7f ff e9 26 call 40009d40 <rtems_task_delete> <== NOT EXECUTED
4000f8ac: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
4000f8b0: d2 07 7f cc ld [ %i5 + -52 ], %o1
4000f8b4: 80 a2 60 00 cmp %o1, 0
4000f8b8: 26 80 00 21 bl,a 4000f93c <rtems_bdbuf_read_ahead_task+0x130><== NEVER TAKEN
4000f8bc: d2 07 7f c0 ld [ %i5 + -64 ], %o1 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
4000f8c0: 93 2f 00 09 sll %i4, %o1, %o1
/*
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
4000f8c4: c2 07 7f b4 ld [ %i5 + -76 ], %g1
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
rtems_bdbuf_lock_cache ();
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
4000f8c8: a0 07 7f 9c add %i5, -100, %l0
rtems_chain_set_off_chain (&dd->read_ahead.node);
if (sc == RTEMS_SUCCESSFUL)
{
rtems_bdbuf_buffer *bd =
4000f8cc: 92 02 40 01 add %o1, %g1, %o1
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
4000f8d0: c0 27 60 04 clr [ %i5 + 4 ]
4000f8d4: c0 27 40 00 clr [ %i5 ]
4000f8d8: 7f ff fd 08 call 4000ecf8 <rtems_bdbuf_get_buffer_for_read_ahead>
4000f8dc: 90 10 00 10 mov %l0, %o0
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
4000f8e0: 92 92 20 00 orcc %o0, 0, %o1
4000f8e4: 02 bf ff d8 be 4000f844 <rtems_bdbuf_read_ahead_task+0x38><== NEVER TAKEN
4000f8e8: c2 04 63 d8 ld [ %l1 + 0x3d8 ], %g1
{
uint32_t transfer_count = dd->block_count - block;
4000f8ec: d4 07 7f c4 ld [ %i5 + -60 ], %o2
4000f8f0: 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)
4000f8f4: 80 a2 80 01 cmp %o2, %g1
4000f8f8: 2a 80 00 0f bcs,a 4000f934 <rtems_bdbuf_read_ahead_task+0x128>
4000f8fc: 82 10 3f ff mov -1, %g1
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
dd->read_ahead.next = block + transfer_count;
4000f900: 84 00 40 1c add %g1, %i4, %g2
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
4000f904: 87 30 60 01 srl %g1, 1, %g3
dd->read_ahead.next = block + transfer_count;
4000f908: c4 27 60 0c st %g2, [ %i5 + 0xc ]
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
4000f90c: b8 00 c0 1c add %g3, %i4, %i4
dd->read_ahead.next = block + transfer_count;
4000f910: 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;
4000f914: f8 27 60 08 st %i4, [ %i5 + 8 ]
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
4000f918: c2 07 7f e8 ld [ %i5 + -24 ], %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
4000f91c: 90 10 00 10 mov %l0, %o0
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
4000f920: 82 00 60 01 inc %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
4000f924: 7f ff ff 7e call 4000f71c <rtems_bdbuf_execute_read_request>
4000f928: c2 27 7f e8 st %g1, [ %i5 + -24 ]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000f92c: 10 bf ff c7 b 4000f848 <rtems_bdbuf_read_ahead_task+0x3c>
4000f930: fa 06 e0 88 ld [ %i3 + 0x88 ], %i5
dd->read_ahead.trigger = block + transfer_count / 2;
dd->read_ahead.next = block + transfer_count;
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
4000f934: 10 bf ff f9 b 4000f918 <rtems_bdbuf_read_ahead_task+0x10c>
4000f938: c2 27 60 08 st %g1, [ %i5 + 8 ]
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
4000f93c: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4000f940: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000f944: 40 00 25 88 call 40018f64 <__muldi3> <== NOT EXECUTED
4000f948: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000f94c: d6 07 7f bc ld [ %i5 + -68 ], %o3 <== NOT EXECUTED
4000f950: 40 00 27 96 call 400197a8 <__udivdi3> <== NOT EXECUTED
4000f954: 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;
4000f958: 10 bf ff dc b 4000f8c8 <rtems_bdbuf_read_ahead_task+0xbc> <== NOT EXECUTED
4000f95c: c2 07 7f b4 ld [ %i5 + -76 ], %g1 <== NOT EXECUTED
400100a0 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
400100a0: 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)
400100a4: 80 a6 20 00 cmp %i0, 0
400100a8: 02 80 00 0f be 400100e4 <rtems_bdbuf_release+0x44> <== NEVER TAKEN
400100ac: 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();
400100b0: 7f ff f7 bd call 4000dfa4 <rtems_bdbuf_lock_cache>
400100b4: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
400100b8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
400100bc: 80 a2 20 04 cmp %o0, 4
400100c0: 02 80 00 14 be 40010110 <rtems_bdbuf_release+0x70>
400100c4: 01 00 00 00 nop
400100c8: 18 80 00 09 bgu 400100ec <rtems_bdbuf_release+0x4c>
400100cc: 80 a2 20 06 cmp %o0, 6
400100d0: 80 a2 20 03 cmp %o0, 3
400100d4: 22 80 00 15 be,a 40010128 <rtems_bdbuf_release+0x88> <== ALWAYS TAKEN
400100d8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
break;
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);
400100dc: 7f ff f7 b8 call 4000dfbc <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
400100e0: 92 10 20 0e mov 0xe, %o1 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
400100e4: 81 c7 e0 08 ret <== NOT EXECUTED
400100e8: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
400100ec: 18 bf ff fc bgu 400100dc <rtems_bdbuf_release+0x3c> <== NEVER TAKEN
400100f0: 01 00 00 00 nop
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
rtems_bdbuf_add_to_lru_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
400100f4: 90 10 00 18 mov %i0, %o0
400100f8: 7f ff f9 d2 call 4000e840 <rtems_bdbuf_discard_buffer_after_access>
400100fc: b0 10 20 00 clr %i0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
40010100: 7f ff f7 bf call 4000dffc <rtems_bdbuf_unlock_cache>
40010104: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
40010108: 81 c7 e0 08 ret
4001010c: 81 e8 00 00 restore
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
40010110: 7f ff f8 6b call 4000e2bc <rtems_bdbuf_add_to_modified_list_after_access>
40010114: 90 10 00 18 mov %i0, %o0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
40010118: 7f ff f7 b9 call 4000dffc <rtems_bdbuf_unlock_cache>
4001011c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
40010120: 81 c7 e0 08 ret
40010124: 81 e8 00 00 restore
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
40010128: 11 10 00 71 sethi %hi(0x4001c400), %o0
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
4001012c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40010130: 90 12 21 8c or %o0, 0x18c, %o0
40010134: 84 00 bf ff add %g2, -1, %g2
40010138: c4 20 60 0c st %g2, [ %g1 + 0xc ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4001013c: 82 10 20 02 mov 2, %g1
the_node->next = tail;
40010140: 84 02 20 44 add %o0, 0x44, %g2
40010144: 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;
40010148: c2 02 20 48 ld [ %o0 + 0x48 ], %g1
the_node->next = tail;
4001014c: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
40010150: f0 22 20 48 st %i0, [ %o0 + 0x48 ]
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_make_cached_and_add_to_lru_list (bd);
if (bd->waiters)
40010154: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
old_last->next = the_node;
the_node->previous = old_last;
40010158: c2 26 20 04 st %g1, [ %i0 + 4 ]
4001015c: 80 a0 a0 00 cmp %g2, 0
40010160: 12 80 00 05 bne 40010174 <rtems_bdbuf_release+0xd4>
40010164: f0 20 40 00 st %i0, [ %g1 ]
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
40010168: 7f ff f8 46 call 4000e280 <rtems_bdbuf_wake>
4001016c: 90 02 20 74 add %o0, 0x74, %o0
40010170: 30 bf ff ea b,a 40010118 <rtems_bdbuf_release+0x78>
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_make_cached_and_add_to_lru_list (bd);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
40010174: 7f ff f8 43 call 4000e280 <rtems_bdbuf_wake>
40010178: 90 02 20 64 add %o0, 0x64, %o0
4001017c: 30 bf ff e7 b,a 40010118 <rtems_bdbuf_release+0x78>
40010180 <rtems_bdbuf_release_modified>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
40010180: 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)
40010184: 80 a6 20 00 cmp %i0, 0
40010188: 02 80 00 13 be 400101d4 <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
4001018c: 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();
40010190: 7f ff f7 85 call 4000dfa4 <rtems_bdbuf_lock_cache>
40010194: 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)
40010198: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4001019c: 80 a2 20 03 cmp %o0, 3
400101a0: 1a 80 00 04 bcc 400101b0 <rtems_bdbuf_release_modified+0x30><== ALWAYS TAKEN
400101a4: 80 a2 20 05 cmp %o0, 5
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);
400101a8: 7f ff f7 85 call 4000dfbc <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
400101ac: 92 10 20 12 mov 0x12, %o1 <== NOT EXECUTED
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
400101b0: 18 80 00 0b bgu 400101dc <rtems_bdbuf_release_modified+0x5c>
400101b4: 80 a2 20 06 cmp %o0, 6
{
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
400101b8: 90 10 00 18 mov %i0, %o0
400101bc: 7f ff f8 40 call 4000e2bc <rtems_bdbuf_add_to_modified_list_after_access>
400101c0: b0 10 20 00 clr %i0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
400101c4: 7f ff f7 8e call 4000dffc <rtems_bdbuf_unlock_cache>
400101c8: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
400101cc: 81 c7 e0 08 ret
400101d0: 81 e8 00 00 restore
}
400101d4: 81 c7 e0 08 ret <== NOT EXECUTED
400101d8: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
400101dc: 12 bf ff f3 bne 400101a8 <rtems_bdbuf_release_modified+0x28><== NEVER TAKEN
400101e0: 01 00 00 00 nop
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
400101e4: 90 10 00 18 mov %i0, %o0
400101e8: 7f ff f9 96 call 4000e840 <rtems_bdbuf_discard_buffer_after_access>
400101ec: b0 10 20 00 clr %i0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
400101f0: 7f ff f7 83 call 4000dffc <rtems_bdbuf_unlock_cache>
400101f4: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
400101f8: 81 c7 e0 08 ret
400101fc: 81 e8 00 00 restore
4000e420 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
4000e420: 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;
4000e424: 35 10 00 71 sethi %hi(0x4001c400), %i2
4000e428: b4 16 a1 8c or %i2, 0x18c, %i2 ! 4001c58c <bdbuf_cache>
4000e42c: fa 06 a0 3c ld [ %i2 + 0x3c ], %i5
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
4000e430: b6 07 bf 80 add %fp, -128, %i3
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
4000e434: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
rtems_blkdev_bnum block = node->block;
4000e438: e0 06 20 18 ld [ %i0 + 0x18 ], %l0
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
4000e43c: 90 10 00 1b mov %i3, %o0
4000e440: 92 10 20 00 clr %o1
4000e444: 40 00 1e 21 call 40015cc8 <memset>
4000e448: 94 10 20 80 mov 0x80, %o2
while (p != NULL)
4000e44c: 80 a7 60 00 cmp %i5, 0
4000e450: 02 80 00 11 be 4000e494 <rtems_bdbuf_remove_from_tree+0x74><== NEVER TAKEN
4000e454: 84 10 00 1b mov %i3, %g2
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
4000e458: 88 10 20 01 mov 1, %g4
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
4000e45c: b2 10 3f ff mov -1, %i1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000e460: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
4000e464: fa 20 80 00 st %i5, [ %g2 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
4000e468: 80 a0 c0 1c cmp %g3, %i4
4000e46c: 0a 80 00 65 bcs 4000e600 <rtems_bdbuf_remove_from_tree+0x1e0><== NEVER TAKEN
4000e470: 82 00 a0 04 add %g2, 4, %g1
|| ((p->dd == dd) && (p->block < block)))
4000e474: 80 a7 00 03 cmp %i4, %g3
4000e478: 22 80 00 0a be,a 4000e4a0 <rtems_bdbuf_remove_from_tree+0x80><== ALWAYS TAKEN
4000e47c: c6 07 60 18 ld [ %i5 + 0x18 ], %g3
p->avl.cache = 1;
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
4000e480: f2 2f 60 10 stb %i1, [ %i5 + 0x10 ] <== NOT EXECUTED
p = p->avl.left;
4000e484: fa 07 60 08 ld [ %i5 + 8 ], %i5
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
4000e488: 80 a7 60 00 cmp %i5, 0
4000e48c: 12 bf ff f5 bne 4000e460 <rtems_bdbuf_remove_from_tree+0x40><== ALWAYS TAKEN
4000e490: 84 10 00 01 mov %g1, %g2
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_TREE_RM);
4000e494: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
4000e498: 7f ff fe c9 call 4000dfbc <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000e49c: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
4000e4a0: 80 a4 00 03 cmp %l0, %g3
4000e4a4: 38 80 00 58 bgu,a 4000e604 <rtems_bdbuf_remove_from_tree+0x1e4>
4000e4a8: c8 2f 60 10 stb %g4, [ %i5 + 0x10 ]
{
p->avl.cache = 1;
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
4000e4ac: 80 a4 00 03 cmp %l0, %g3
4000e4b0: 32 bf ff f5 bne,a 4000e484 <rtems_bdbuf_remove_from_tree+0x64>
4000e4b4: f2 2f 60 10 stb %i1, [ %i5 + 0x10 ]
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
4000e4b8: 9a 10 00 01 mov %g1, %o5
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
4000e4bc: 80 a0 80 1b cmp %g2, %i3
4000e4c0: 18 80 00 6a bgu 4000e668 <rtems_bdbuf_remove_from_tree+0x248>
4000e4c4: b0 10 20 00 clr %i0
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
4000e4c8: f2 07 60 0c ld [ %i5 + 0xc ], %i1
4000e4cc: 80 a6 60 00 cmp %i1, 0
4000e4d0: 22 80 00 6b be,a 4000e67c <rtems_bdbuf_remove_from_tree+0x25c>
4000e4d4: c6 07 60 08 ld [ %i5 + 8 ], %g3
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
4000e4d8: c6 06 60 08 ld [ %i1 + 8 ], %g3
4000e4dc: 84 10 00 19 mov %i1, %g2
4000e4e0: 80 a0 e0 00 cmp %g3, 0
4000e4e4: 12 80 00 06 bne 4000e4fc <rtems_bdbuf_remove_from_tree+0xdc>
4000e4e8: b8 10 3f ff mov -1, %i4
{
r->avl.left = q->avl.left;
4000e4ec: 10 80 00 ba b 4000e7d4 <rtems_bdbuf_remove_from_tree+0x3b4>
4000e4f0: c6 07 60 08 ld [ %i5 + 8 ], %g3
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
4000e4f4: 84 10 00 03 mov %g3, %g2
4000e4f8: 86 10 00 04 mov %g4, %g3
4000e4fc: c8 00 e0 08 ld [ %g3 + 8 ], %g4
{
*buf_prev++ = r = s;
4000e500: c4 20 40 00 st %g2, [ %g1 ]
s = r->avl.left;
r->avl.cache = -1;
4000e504: f8 28 a0 10 stb %i4, [ %g2 + 0x10 ]
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
4000e508: 80 a1 20 00 cmp %g4, 0
4000e50c: 12 bf ff fa bne 4000e4f4 <rtems_bdbuf_remove_from_tree+0xd4>
4000e510: 82 00 60 04 add %g1, 4, %g1
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
4000e514: de 07 60 08 ld [ %i5 + 8 ], %o7
r->avl.left = s->avl.right;
4000e518: f8 00 e0 0c ld [ %g3 + 0xc ], %i4
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
4000e51c: c8 0f 60 11 ldub [ %i5 + 0x11 ], %g4
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
4000e520: de 20 e0 08 st %o7, [ %g3 + 8 ]
r->avl.left = s->avl.right;
4000e524: f8 20 a0 08 st %i4, [ %g2 + 8 ]
s->avl.right = q->avl.right;
4000e528: f2 20 e0 0c st %i1, [ %g3 + 0xc ]
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
4000e52c: 84 10 20 01 mov 1, %g2
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
4000e530: c8 28 e0 11 stb %g4, [ %g3 + 0x11 ]
s->avl.cache = 1;
4000e534: c4 28 e0 10 stb %g2, [ %g3 + 0x10 ]
*t = q = s;
4000e538: c6 23 7f fc st %g3, [ %o5 + -4 ]
}
}
if (p != NULL)
4000e53c: 80 a6 20 00 cmp %i0, 0
4000e540: 22 80 00 07 be,a 4000e55c <rtems_bdbuf_remove_from_tree+0x13c>
4000e544: c6 26 a0 3c st %g3, [ %i2 + 0x3c ]
{
if (p->avl.cache == -1)
4000e548: c4 4e 20 10 ldsb [ %i0 + 0x10 ], %g2
4000e54c: 80 a0 bf ff cmp %g2, -1
4000e550: 22 80 00 03 be,a 4000e55c <rtems_bdbuf_remove_from_tree+0x13c>
4000e554: c6 26 20 08 st %g3, [ %i0 + 8 ]
{
p->avl.left = q;
}
else
{
p->avl.right = q;
4000e558: c6 26 20 0c st %g3, [ %i0 + 0xc ]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
4000e55c: 80 a0 40 1b cmp %g1, %i3
4000e560: 08 80 00 26 bleu 4000e5f8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000e564: b2 10 3f ff mov -1, %i1
4000e568: c4 00 7f fc ld [ %g1 + -4 ], %g2
4000e56c: c8 08 a0 10 ldub [ %g2 + 0x10 ], %g4
4000e570: 10 80 00 10 b 4000e5b0 <rtems_bdbuf_remove_from_tree+0x190>
4000e574: 89 29 20 18 sll %g4, 0x18, %g4
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
4000e578: 86 10 00 02 mov %g2, %g3
modified = false;
4000e57c: ba 10 20 00 clr %i5
default:
break;
}
}
if (buf_prev > buf_stack)
4000e580: 80 a0 40 1b cmp %g1, %i3
4000e584: 28 80 00 1d bleu,a 4000e5f8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000e588: c6 26 a0 3c st %g3, [ %i2 + 0x3c ]
{
q = *(buf_prev - 1);
4000e58c: c4 00 7f fc ld [ %g1 + -4 ], %g2
if (q->avl.cache == -1)
4000e590: c8 08 a0 10 ldub [ %g2 + 0x10 ], %g4
4000e594: 89 29 20 18 sll %g4, 0x18, %g4
4000e598: b9 39 20 18 sra %g4, 0x18, %i4
4000e59c: 80 a7 3f ff cmp %i4, -1
4000e5a0: 02 80 00 47 be 4000e6bc <rtems_bdbuf_remove_from_tree+0x29c>
4000e5a4: 80 8f 60 ff btst 0xff, %i5
*root = q;
}
modified = true;
while (modified)
4000e5a8: 02 80 00 14 be 4000e5f8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000e5ac: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
else
{
break;
}
if (p->avl.cache == -1)
4000e5b0: 89 39 20 18 sra %g4, 0x18, %g4
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
4000e5b4: 82 00 7f fc add %g1, -4, %g1
else
{
break;
}
if (p->avl.cache == -1)
4000e5b8: 80 a1 3f ff cmp %g4, -1
4000e5bc: 02 80 00 38 be 4000e69c <rtems_bdbuf_remove_from_tree+0x27c>
4000e5c0: c6 48 a0 11 ldsb [ %g2 + 0x11 ], %g3
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
4000e5c4: 80 a0 e0 00 cmp %g3, 0
4000e5c8: 22 bf ff ec be,a 4000e578 <rtems_bdbuf_remove_from_tree+0x158>
4000e5cc: f2 28 a0 11 stb %i1, [ %g2 + 0x11 ]
4000e5d0: 80 a0 e0 01 cmp %g3, 1
4000e5d4: 02 80 00 42 be 4000e6dc <rtems_bdbuf_remove_from_tree+0x2bc>
4000e5d8: 80 a0 ff ff cmp %g3, -1
4000e5dc: 22 80 00 0c be,a 4000e60c <rtems_bdbuf_remove_from_tree+0x1ec><== ALWAYS TAKEN
4000e5e0: c8 00 a0 08 ld [ %g2 + 8 ], %g4
4000e5e4: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED
default:
break;
}
}
if (buf_prev > buf_stack)
4000e5e8: 80 a0 40 1b cmp %g1, %i3 <== NOT EXECUTED
4000e5ec: 18 bf ff e8 bgu 4000e58c <rtems_bdbuf_remove_from_tree+0x16c><== NOT EXECUTED
4000e5f0: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
q->avl.right = p;
}
}
else
{
*root = p;
4000e5f4: c6 26 a0 3c st %g3, [ %i2 + 0x3c ] <== NOT EXECUTED
4000e5f8: 81 c7 e0 08 ret
4000e5fc: 81 e8 00 00 restore
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
4000e600: c8 2f 60 10 stb %g4, [ %i5 + 0x10 ] <== NOT EXECUTED
p = p->avl.right;
4000e604: 10 bf ff a1 b 4000e488 <rtems_bdbuf_remove_from_tree+0x68>
4000e608: fa 07 60 0c ld [ %i5 + 0xc ], %i5
break;
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
4000e60c: c6 49 20 11 ldsb [ %g4 + 0x11 ], %g3
4000e610: 80 a0 e0 00 cmp %g3, 0
4000e614: 24 80 00 41 ble,a 4000e718 <rtems_bdbuf_remove_from_tree+0x2f8>
4000e618: fa 01 20 0c ld [ %g4 + 0xc ], %i5
}
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
4000e61c: c6 01 20 0c ld [ %g4 + 0xc ], %g3
p1->avl.right = p2->avl.left;
4000e620: f8 00 e0 08 ld [ %g3 + 8 ], %i4
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4000e624: fa 48 e0 11 ldsb [ %g3 + 0x11 ], %i5
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
4000e628: f8 21 20 0c st %i4, [ %g4 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
4000e62c: f8 00 e0 0c ld [ %g3 + 0xc ], %i4
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
4000e630: c8 20 e0 08 st %g4, [ %g3 + 8 ]
p->avl.left = p2->avl.right;
4000e634: f8 20 a0 08 st %i4, [ %g2 + 8 ]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4000e638: 80 a7 7f ff cmp %i5, -1
4000e63c: 02 80 00 40 be 4000e73c <rtems_bdbuf_remove_from_tree+0x31c>
4000e640: c4 20 e0 0c st %g2, [ %g3 + 0xc ]
4000e644: c0 28 a0 11 clrb [ %g2 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000e648: c4 48 e0 11 ldsb [ %g3 + 0x11 ], %g2
4000e64c: 80 a0 a0 01 cmp %g2, 1
4000e650: 22 80 00 42 be,a 4000e758 <rtems_bdbuf_remove_from_tree+0x338>
4000e654: f2 29 20 11 stb %i1, [ %g4 + 0x11 ]
4000e658: c0 29 20 11 clrb [ %g4 + 0x11 ]
p = p2;
p2->avl.bal = 0;
4000e65c: c0 28 e0 11 clrb [ %g3 + 0x11 ]
4000e660: 10 bf ff c8 b 4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e664: ba 10 20 01 mov 1, %i5
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
4000e668: f2 07 60 0c ld [ %i5 + 0xc ], %i1
4000e66c: 80 a6 60 00 cmp %i1, 0
4000e670: 12 bf ff 9a bne 4000e4d8 <rtems_bdbuf_remove_from_tree+0xb8>
4000e674: f0 00 7f f8 ld [ %g1 + -8 ], %i0
{
r = q->avl.left;
4000e678: c6 07 60 08 ld [ %i5 + 8 ], %g3
if (r != NULL)
4000e67c: 80 a0 e0 00 cmp %g3, 0
4000e680: 02 80 00 61 be 4000e804 <rtems_bdbuf_remove_from_tree+0x3e4>
4000e684: 80 a6 20 00 cmp %i0, 0
{
r->avl.bal = 0;
4000e688: c0 28 e0 11 clrb [ %g3 + 0x11 ]
*t = q = s;
}
}
if (p != NULL)
4000e68c: 12 bf ff af bne 4000e548 <rtems_bdbuf_remove_from_tree+0x128>
4000e690: 82 10 00 02 mov %g2, %g1
p->avl.right = q;
}
}
else
{
*root = q;
4000e694: 10 bf ff b2 b 4000e55c <rtems_bdbuf_remove_from_tree+0x13c>
4000e698: c6 26 a0 3c st %g3, [ %i2 + 0x3c ]
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
4000e69c: 80 a0 e0 00 cmp %g3, 0
4000e6a0: 12 80 00 0b bne 4000e6cc <rtems_bdbuf_remove_from_tree+0x2ac>
4000e6a4: 80 a0 e0 01 cmp %g3, 1
{
case -1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = 1;
4000e6a8: 88 10 20 01 mov 1, %g4
4000e6ac: 86 10 00 02 mov %g2, %g3
4000e6b0: c8 28 a0 11 stb %g4, [ %g2 + 0x11 ]
modified = false;
4000e6b4: 10 bf ff b3 b 4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e6b8: ba 10 20 00 clr %i5
*root = q;
}
modified = true;
while (modified)
4000e6bc: 12 bf ff bd bne 4000e5b0 <rtems_bdbuf_remove_from_tree+0x190>
4000e6c0: c6 20 a0 08 st %g3, [ %g2 + 8 ]
4000e6c4: 81 c7 e0 08 ret
4000e6c8: 81 e8 00 00 restore
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
4000e6cc: 02 80 00 08 be 4000e6ec <rtems_bdbuf_remove_from_tree+0x2cc>
4000e6d0: 80 a0 ff ff cmp %g3, -1
4000e6d4: 32 bf ff c5 bne,a 4000e5e8 <rtems_bdbuf_remove_from_tree+0x1c8><== NEVER TAKEN
4000e6d8: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
4000e6dc: c0 28 a0 11 clrb [ %g2 + 0x11 ]
4000e6e0: 86 10 00 02 mov %g2, %g3
4000e6e4: 10 bf ff a7 b 4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e6e8: ba 10 20 01 mov 1, %i5
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
4000e6ec: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
if (p1->avl.bal >= 0) /* simple RR-turn */
4000e6f0: fa 48 e0 11 ldsb [ %g3 + 0x11 ], %i5
4000e6f4: 80 a7 60 00 cmp %i5, 0
4000e6f8: 26 80 00 24 bl,a 4000e788 <rtems_bdbuf_remove_from_tree+0x368>
4000e6fc: fa 00 e0 08 ld [ %g3 + 8 ], %i5
{
p->avl.right = p1->avl.left;
4000e700: f8 00 e0 08 ld [ %g3 + 8 ], %i4
p1->avl.left = p;
4000e704: c4 20 e0 08 st %g2, [ %g3 + 8 ]
if (p1->avl.bal == 0)
4000e708: 12 80 00 17 bne 4000e764 <rtems_bdbuf_remove_from_tree+0x344>
4000e70c: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
{
p1->avl.bal = -1;
4000e710: 10 bf ff 9c b 4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e714: c8 28 e0 11 stb %g4, [ %g3 + 0x11 ]
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
4000e718: c4 21 20 0c st %g2, [ %g4 + 0xc ]
if (p1->avl.bal == 0)
4000e71c: 80 a0 e0 00 cmp %g3, 0
4000e720: 12 80 00 15 bne 4000e774 <rtems_bdbuf_remove_from_tree+0x354>
4000e724: fa 20 a0 08 st %i5, [ %g2 + 8 ]
{
p1->avl.bal = 1;
4000e728: 84 10 20 01 mov 1, %g2
4000e72c: 86 10 00 04 mov %g4, %g3
4000e730: c4 29 20 11 stb %g2, [ %g4 + 0x11 ]
modified = false;
4000e734: 10 bf ff 93 b 4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e738: ba 10 20 00 clr %i5
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
4000e73c: ba 10 20 01 mov 1, %i5
4000e740: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000e744: c4 48 e0 11 ldsb [ %g3 + 0x11 ], %g2
4000e748: 80 a0 a0 01 cmp %g2, 1
4000e74c: 32 bf ff c4 bne,a 4000e65c <rtems_bdbuf_remove_from_tree+0x23c><== ALWAYS TAKEN
4000e750: c0 29 20 11 clrb [ %g4 + 0x11 ]
4000e754: f2 29 20 11 stb %i1, [ %g4 + 0x11 ] <== NOT EXECUTED
p = p2;
p2->avl.bal = 0;
4000e758: c0 28 e0 11 clrb [ %g3 + 0x11 ]
4000e75c: 10 bf ff 89 b 4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e760: ba 10 20 01 mov 1, %i5
p1->avl.bal = -1;
modified = false;
}
else
{
p->avl.bal = 0;
4000e764: c0 28 a0 11 clrb [ %g2 + 0x11 ]
p1->avl.bal = 0;
4000e768: c0 28 e0 11 clrb [ %g3 + 0x11 ]
4000e76c: 10 bf ff 85 b 4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e770: ba 10 20 01 mov 1, %i5
p1->avl.bal = 1;
modified = false;
}
else
{
p->avl.bal = 0;
4000e774: c0 28 a0 11 clrb [ %g2 + 0x11 ]
p1->avl.bal = 0;
4000e778: c0 29 20 11 clrb [ %g4 + 0x11 ]
4000e77c: 86 10 00 04 mov %g4, %g3
4000e780: 10 bf ff 80 b 4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e784: ba 10 20 01 mov 1, %i5
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000e788: f0 07 60 0c ld [ %i5 + 0xc ], %i0
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4000e78c: f8 4f 60 11 ldsb [ %i5 + 0x11 ], %i4
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
4000e790: f0 20 e0 08 st %i0, [ %g3 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
4000e794: f0 07 60 08 ld [ %i5 + 8 ], %i0
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
4000e798: c6 27 60 0c st %g3, [ %i5 + 0xc ]
p->avl.right = p2->avl.left;
4000e79c: f0 20 a0 0c st %i0, [ %g2 + 0xc ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4000e7a0: 80 a7 20 01 cmp %i4, 1
4000e7a4: 02 80 00 16 be 4000e7fc <rtems_bdbuf_remove_from_tree+0x3dc>
4000e7a8: c4 27 60 08 st %g2, [ %i5 + 8 ]
4000e7ac: c0 28 a0 11 clrb [ %g2 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
4000e7b0: c4 4f 60 11 ldsb [ %i5 + 0x11 ], %g2
4000e7b4: 80 a0 bf ff cmp %g2, -1
4000e7b8: 02 80 00 0f be 4000e7f4 <rtems_bdbuf_remove_from_tree+0x3d4><== NEVER TAKEN
4000e7bc: 84 10 20 01 mov 1, %g2
4000e7c0: c0 28 e0 11 clrb [ %g3 + 0x11 ]
p = p2;
p2->avl.bal = 0;
4000e7c4: c0 2f 60 11 clrb [ %i5 + 0x11 ]
4000e7c8: 86 10 00 1d mov %i5, %g3
4000e7cc: 10 bf ff 6d b 4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e7d0: ba 10 20 01 mov 1, %i5
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
4000e7d4: c4 0f 60 11 ldub [ %i5 + 0x11 ], %g2
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
4000e7d8: c6 26 60 08 st %g3, [ %i1 + 8 ]
r->avl.bal = q->avl.bal;
4000e7dc: c4 2e 60 11 stb %g2, [ %i1 + 0x11 ]
r->avl.cache = 1;
*buf_prev++ = q = r;
4000e7e0: f2 20 7f fc st %i1, [ %g1 + -4 ]
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
4000e7e4: 84 10 20 01 mov 1, %g2
*buf_prev++ = q = r;
4000e7e8: 86 10 00 19 mov %i1, %g3
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
4000e7ec: 10 bf ff 54 b 4000e53c <rtems_bdbuf_remove_from_tree+0x11c>
4000e7f0: c4 2e 60 10 stb %g2, [ %i1 + 0x10 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
4000e7f4: 10 bf ff f4 b 4000e7c4 <rtems_bdbuf_remove_from_tree+0x3a4><== NOT EXECUTED
4000e7f8: c4 28 e0 11 stb %g2, [ %g3 + 0x11 ] <== NOT EXECUTED
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
4000e7fc: 10 bf ff ed b 4000e7b0 <rtems_bdbuf_remove_from_tree+0x390>
4000e800: c8 28 a0 11 stb %g4, [ %g2 + 0x11 ]
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
{
r = q->avl.left;
if (r != NULL)
4000e804: 10 bf ff 4e b 4000e53c <rtems_bdbuf_remove_from_tree+0x11c>
4000e808: 82 10 00 02 mov %g2, %g1
4000e898 <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)
{
4000e898: 9d e3 bf a0 save %sp, -96, %sp
switch (bd->state)
4000e89c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000e8a0: 80 a2 20 00 cmp %o0, 0
4000e8a4: 22 80 00 0a be,a 4000e8cc <rtems_bdbuf_remove_from_tree_and_lru_list+0x34>
4000e8a8: c4 06 00 00 ld [ %i0 ], %g2
4000e8ac: 80 a2 20 02 cmp %o0, 2
4000e8b0: 02 80 00 04 be 4000e8c0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x28><== ALWAYS TAKEN
4000e8b4: 01 00 00 00 nop
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_10);
4000e8b8: 7f ff fd c1 call 4000dfbc <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4000e8bc: 92 10 20 16 mov 0x16, %o1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
switch (bd->state)
{
case RTEMS_BDBUF_STATE_FREE:
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
4000e8c0: 7f ff fe d8 call 4000e420 <rtems_bdbuf_remove_from_tree>
4000e8c4: 90 10 00 18 mov %i0, %o0
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000e8c8: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
4000e8cc: c2 06 20 04 ld [ %i0 + 4 ], %g1
next->previous = previous;
4000e8d0: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
4000e8d4: c4 20 40 00 st %g2, [ %g1 ]
4000e8d8: 81 c7 e0 08 ret
4000e8dc: 81 e8 00 00 restore
4000e080 <rtems_bdbuf_restore_preemption>:
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
4000e080: 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);
4000e084: 13 00 00 3f sethi %hi(0xfc00), %o1
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
4000e088: 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);
4000e08c: 90 10 00 18 mov %i0, %o0
4000e090: 94 07 a0 44 add %fp, 0x44, %o2
4000e094: 40 00 12 3e call 4001298c <rtems_task_mode>
4000e098: 92 12 63 ff or %o1, 0x3ff, %o1
if (sc != RTEMS_SUCCESSFUL)
4000e09c: 80 a2 20 00 cmp %o0, 0
4000e0a0: 12 80 00 04 bne 4000e0b0 <rtems_bdbuf_restore_preemption+0x30><== NEVER TAKEN
4000e0a4: 01 00 00 00 nop
4000e0a8: 81 c7 e0 08 ret
4000e0ac: 81 e8 00 00 restore
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_RST);
4000e0b0: 7f ff ff ab call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e0b4: 90 10 20 06 mov 6, %o0 <== NOT EXECUTED
4001059c <rtems_bdbuf_set_block_size>:
rtems_status_code
rtems_bdbuf_set_block_size (rtems_disk_device *dd,
uint32_t block_size,
bool sync)
{
4001059c: 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)
400105a0: 80 a6 a0 00 cmp %i2, 0
400105a4: 12 80 00 43 bne 400106b0 <rtems_bdbuf_set_block_size+0x114>
400105a8: 01 00 00 00 nop
rtems_bdbuf_syncdev (dd);
rtems_bdbuf_lock_cache ();
400105ac: 7f ff f6 7e call 4000dfa4 <rtems_bdbuf_lock_cache>
400105b0: b8 10 20 0a mov 0xa, %i4 ! a <PROM_START+0xa>
if (block_size > 0)
400105b4: 80 a6 60 00 cmp %i1, 0
400105b8: 12 80 00 06 bne 400105d0 <rtems_bdbuf_set_block_size+0x34>
400105bc: 03 10 00 6a sethi %hi(0x4001a800), %g1
else
{
sc = RTEMS_INVALID_NUMBER;
}
rtems_bdbuf_unlock_cache ();
400105c0: 7f ff f6 8f call 4000dffc <rtems_bdbuf_unlock_cache>
400105c4: b0 10 00 1c mov %i4, %i0
return sc;
}
400105c8: 81 c7 e0 08 ret
400105cc: 81 e8 00 00 restore
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
400105d0: 82 10 63 d8 or %g1, 0x3d8, %g1
400105d4: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
400105d8: 80 a6 40 02 cmp %i1, %g2
400105dc: 18 bf ff f9 bgu 400105c0 <rtems_bdbuf_set_block_size+0x24><== NEVER TAKEN
400105e0: 01 00 00 00 nop
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
400105e4: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
400105e8: 40 00 21 07 call 40018a04 <.udiv>
400105ec: 90 06 7f ff add %i1, -1, %o0
400105f0: 90 02 20 01 inc %o0
for (bds_per_size = 1;
400105f4: 80 a2 20 01 cmp %o0, 1
400105f8: 08 80 00 06 bleu 40010610 <rtems_bdbuf_set_block_size+0x74>
400105fc: 92 10 20 01 mov 1, %o1
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
40010600: 93 2a 60 01 sll %o1, 1, %o1
if (size > bdbuf_config.buffer_max)
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
for (bds_per_size = 1;
40010604: 80 a2 00 09 cmp %o0, %o1
40010608: 38 bf ff ff bgu,a 40010604 <rtems_bdbuf_set_block_size+0x68>
4001060c: 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;
40010610: 03 10 00 71 sethi %hi(0x4001c400), %g1
40010614: d0 00 61 ac ld [ %g1 + 0x1ac ], %o0 ! 4001c5ac <bdbuf_cache+0x20>
40010618: 40 00 20 fb call 40018a04 <.udiv>
4001061c: b8 10 20 0a mov 0xa, %i4
if (block_size > 0)
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (block_size);
if (bds_per_group != 0)
40010620: 80 a2 20 00 cmp %o0, 0
40010624: 02 bf ff e7 be 400105c0 <rtems_bdbuf_set_block_size+0x24> <== NEVER TAKEN
40010628: 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;
4001062c: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
40010630: 90 10 00 19 mov %i1, %o0
40010634: 92 10 00 1c mov %i4, %o1
40010638: 40 00 20 f3 call 40018a04 <.udiv>
4001063c: ba 10 20 00 clr %i5
uint32_t one = 1;
while ((one << block_to_media_block_shift) < media_blocks_per_block)
40010640: 80 a2 20 01 cmp %o0, 1
40010644: 08 80 00 08 bleu 40010664 <rtems_bdbuf_set_block_size+0xc8>
40010648: b6 10 00 08 mov %o0, %i3
4001064c: 84 10 20 01 mov 1, %g2
{
++block_to_media_block_shift;
40010650: ba 07 60 01 inc %i5
{
int block_to_media_block_shift = 0;
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
uint32_t one = 1;
while ((one << block_to_media_block_shift) < media_blocks_per_block)
40010654: 83 28 80 1d sll %g2, %i5, %g1
40010658: 80 a6 c0 01 cmp %i3, %g1
4001065c: 38 bf ff fe bgu,a 40010654 <rtems_bdbuf_set_block_size+0xb8>
40010660: ba 07 60 01 inc %i5
{
++block_to_media_block_shift;
}
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
40010664: b9 2f 00 1d sll %i4, %i5, %i4
40010668: 80 a7 00 19 cmp %i4, %i1
4001066c: 32 80 00 02 bne,a 40010674 <rtems_bdbuf_set_block_size+0xd8><== NEVER TAKEN
40010670: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
block_to_media_block_shift = -1;
dd->block_size = block_size;
dd->block_count = dd->size / media_blocks_per_block;
40010674: d0 06 20 1c ld [ %i0 + 0x1c ], %o0
40010678: 92 10 00 1b mov %i3, %o1
4001067c: 40 00 20 e2 call 40018a04 <.udiv>
40010680: f2 26 20 24 st %i1, [ %i0 + 0x24 ]
40010684: d0 26 20 28 st %o0, [ %i0 + 0x28 ]
dd->media_blocks_per_block = media_blocks_per_block;
dd->block_to_media_block_shift = block_to_media_block_shift;
dd->bds_per_group = bds_per_group;
rtems_bdbuf_purge_dev (dd);
40010688: 90 10 00 18 mov %i0, %o0
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
block_to_media_block_shift = -1;
dd->block_size = block_size;
dd->block_count = dd->size / media_blocks_per_block;
dd->media_blocks_per_block = media_blocks_per_block;
4001068c: f6 26 20 2c st %i3, [ %i0 + 0x2c ]
dd->block_to_media_block_shift = block_to_media_block_shift;
40010690: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
dd->bds_per_group = bds_per_group;
40010694: f4 26 20 34 st %i2, [ %i0 + 0x34 ]
rtems_bdbuf_purge_dev (dd);
40010698: 7f ff ff 43 call 400103a4 <rtems_bdbuf_purge_dev>
4001069c: b8 10 20 00 clr %i4
else
{
sc = RTEMS_INVALID_NUMBER;
}
rtems_bdbuf_unlock_cache ();
400106a0: 7f ff f6 57 call 4000dffc <rtems_bdbuf_unlock_cache>
400106a4: b0 10 00 1c mov %i4, %i0
return sc;
}
400106a8: 81 c7 e0 08 ret
400106ac: 81 e8 00 00 restore
/*
* We do not care about the synchronization status since we will purge the
* device later.
*/
if (sync)
rtems_bdbuf_syncdev (dd);
400106b0: 7f ff ff 26 call 40010348 <rtems_bdbuf_syncdev>
400106b4: 90 10 00 18 mov %i0, %o0
400106b8: 30 bf ff bd b,a 400105ac <rtems_bdbuf_set_block_size+0x10>
4000ddd8 <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
4000ddd8: 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;
4000dddc: 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 );
4000dde0: b2 06 60 04 add %i1, 4, %i1
if (!rtems_chain_is_empty (chain))
4000dde4: 80 a0 40 19 cmp %g1, %i1
4000dde8: 02 80 00 2e be 4000dea0 <rtems_bdbuf_swapout_modified_processing+0xc8>
4000ddec: 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))
4000ddf0: 12 80 00 57 bne 4000df4c <rtems_bdbuf_swapout_modified_processing+0x174>
4000ddf4: 9e 10 20 00 clr %o7
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
4000ddf8: 05 10 00 71 sethi %hi(0x4001c400), %g2
4000ddfc: d8 00 a2 00 ld [ %g2 + 0x200 ], %o4 ! 4001c600 <bdbuf_cache+0x74>
4000de00: 9e 0b e0 ff and %o7, 0xff, %o7
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000de04: 96 10 20 09 mov 9, %o3
* or someone waits for a buffer written force all the timers to 0.
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dd_ptr == bd->dd))
4000de08: 80 a3 e0 00 cmp %o7, 0
4000de0c: 32 80 00 3b bne,a 4000def8 <rtems_bdbuf_swapout_modified_processing+0x120>
4000de10: c4 06 00 00 ld [ %i0 ], %g2
4000de14: 80 a6 e0 00 cmp %i3, 0
4000de18: 02 80 00 07 be 4000de34 <rtems_bdbuf_swapout_modified_processing+0x5c>
4000de1c: 80 a3 20 00 cmp %o4, 0
4000de20: c4 06 00 00 ld [ %i0 ], %g2
4000de24: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
4000de28: 80 a0 80 03 cmp %g2, %g3
4000de2c: 02 80 00 34 be 4000defc <rtems_bdbuf_swapout_modified_processing+0x124>
4000de30: 80 a3 20 00 cmp %o4, 0
|| rtems_bdbuf_has_buffer_waiters ())
4000de34: 32 80 00 31 bne,a 4000def8 <rtems_bdbuf_swapout_modified_processing+0x120>
4000de38: c4 06 00 00 ld [ %i0 ], %g2
bd->hold_timer = 0;
if (bd->hold_timer)
4000de3c: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
4000de40: 80 a0 a0 00 cmp %g2, 0
4000de44: 02 80 00 0b be 4000de70 <rtems_bdbuf_swapout_modified_processing+0x98><== NEVER TAKEN
4000de48: 80 a7 20 00 cmp %i4, 0
{
if (update_timers)
4000de4c: 22 80 00 12 be,a 4000de94 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000de50: c2 00 40 00 ld [ %g1 ], %g1
{
if (bd->hold_timer > timer_delta)
4000de54: 80 a0 80 1d cmp %g2, %i5
4000de58: 28 80 00 3a bleu,a 4000df40 <rtems_bdbuf_swapout_modified_processing+0x168>
4000de5c: c0 20 60 2c clr [ %g1 + 0x2c ]
bd->hold_timer -= timer_delta;
4000de60: 84 20 80 1d sub %g2, %i5, %g2
else
bd->hold_timer = 0;
}
if (bd->hold_timer)
4000de64: 80 a0 a0 00 cmp %g2, 0
4000de68: 12 80 00 0a bne 4000de90 <rtems_bdbuf_swapout_modified_processing+0xb8><== ALWAYS TAKEN
4000de6c: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
4000de70: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
4000de74: c6 00 60 14 ld [ %g1 + 0x14 ], %g3 <== NOT EXECUTED
/*
* This assumes we can set it to BDBUF_INVALID_DEV which is just an
* assumption. Cannot use the transfer list being empty the sync dev
* calls sets the dev to use.
*/
if (*dd_ptr == BDBUF_INVALID_DEV)
4000de78: 80 a0 a0 00 cmp %g2, 0
4000de7c: 22 80 00 24 be,a 4000df0c <rtems_bdbuf_swapout_modified_processing+0x134>
4000de80: 84 10 00 03 mov %g3, %g2
*dd_ptr = bd->dd;
if (bd->dd == *dd_ptr)
4000de84: 80 a0 c0 02 cmp %g3, %g2
4000de88: 22 80 00 08 be,a 4000dea8 <rtems_bdbuf_swapout_modified_processing+0xd0><== ALWAYS TAKEN
4000de8c: c4 00 60 04 ld [ %g1 + 4 ], %g2
node = next_node;
}
else
{
node = node->next;
4000de90: c2 00 40 00 ld [ %g1 ], %g1
if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
while (!rtems_chain_is_tail (chain, node))
4000de94: 80 a0 40 19 cmp %g1, %i1
4000de98: 12 bf ff dd bne 4000de0c <rtems_bdbuf_swapout_modified_processing+0x34>
4000de9c: 80 a3 e0 00 cmp %o7, 0
4000dea0: 81 c7 e0 08 ret
4000dea4: 81 e8 00 00 restore
if (*dd_ptr == BDBUF_INVALID_DEV)
*dd_ptr = bd->dd;
if (bd->dd == *dd_ptr)
{
rtems_chain_node* next_node = node->next;
4000dea8: da 00 40 00 ld [ %g1 ], %o5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
4000deac: d6 20 60 20 st %o3, [ %g1 + 0x20 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
4000deb0: c4 23 60 04 st %g2, [ %o5 + 4 ]
previous->next = next;
4000deb4: da 20 80 00 st %o5, [ %g2 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
4000deb8: c4 06 a0 08 ld [ %i2 + 8 ], %g2
while (node && !rtems_chain_is_head (transfer, tnode))
4000debc: 80 a0 80 1a cmp %g2, %i2
4000dec0: 22 80 00 1a be,a 4000df28 <rtems_bdbuf_swapout_modified_processing+0x150>
4000dec4: c4 06 80 00 ld [ %i2 ], %g2
{
rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
if (bd->block > tbd->block)
4000dec8: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
4000decc: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4000ded0: 80 a1 00 03 cmp %g4, %g3
4000ded4: 28 80 00 11 bleu,a 4000df18 <rtems_bdbuf_swapout_modified_processing+0x140>
4000ded8: c4 00 a0 04 ld [ %g2 + 4 ], %g2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000dedc: c6 00 80 00 ld [ %g2 ], %g3
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000dee0: c4 20 60 04 st %g2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000dee4: c2 20 80 00 st %g1, [ %g2 ]
the_node->next = before_node;
4000dee8: c6 20 40 00 st %g3, [ %g1 ]
before_node->previous = the_node;
4000deec: c2 20 e0 04 st %g1, [ %g3 + 4 ]
4000def0: 10 bf ff e9 b 4000de94 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000def4: 82 10 00 0d mov %o5, %g1
4000def8: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
/*
* This assumes we can set it to BDBUF_INVALID_DEV which is just an
* assumption. Cannot use the transfer list being empty the sync dev
* calls sets the dev to use.
*/
if (*dd_ptr == BDBUF_INVALID_DEV)
4000defc: 80 a0 a0 00 cmp %g2, 0
4000df00: 12 bf ff e1 bne 4000de84 <rtems_bdbuf_swapout_modified_processing+0xac>
4000df04: c0 20 60 2c clr [ %g1 + 0x2c ]
*dd_ptr = bd->dd;
4000df08: 84 10 00 03 mov %g3, %g2
4000df0c: c6 26 00 00 st %g3, [ %i0 ]
4000df10: 10 bf ff dd b 4000de84 <rtems_bdbuf_swapout_modified_processing+0xac>
4000df14: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
4000df18: 80 a0 80 1a cmp %g2, %i2
4000df1c: 32 bf ff ec bne,a 4000decc <rtems_bdbuf_swapout_modified_processing+0xf4>
4000df20: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4000df24: c4 06 80 00 ld [ %i2 ], %g2
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000df28: f4 20 60 04 st %i2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000df2c: c2 26 80 00 st %g1, [ %i2 ]
the_node->next = before_node;
4000df30: c4 20 40 00 st %g2, [ %g1 ]
before_node->previous = the_node;
4000df34: c2 20 a0 04 st %g1, [ %g2 + 4 ]
4000df38: 10 bf ff d7 b 4000de94 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000df3c: 82 10 00 0d mov %o5, %g1
4000df40: c4 06 00 00 ld [ %i0 ], %g2
4000df44: 10 bf ff cd b 4000de78 <rtems_bdbuf_swapout_modified_processing+0xa0>
4000df48: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
node = node->next;
/*
* A sync active with no valid dev means sync all.
*/
if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))
4000df4c: c4 06 00 00 ld [ %i0 ], %g2
4000df50: 80 a0 00 02 cmp %g0, %g2
4000df54: 10 bf ff a9 b 4000ddf8 <rtems_bdbuf_swapout_modified_processing+0x20>
4000df58: 9e 60 3f ff subx %g0, -1, %o7
4000f2f4 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
4000f2f4: 9d e3 bf 78 save %sp, -136, %sp
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;
4000f2f8: 23 10 00 6a sethi %hi(0x4001a800), %l1
4000f2fc: a2 14 63 d8 or %l1, 0x3d8, %l1 ! 4001abd8 <rtems_bdbuf_configuration>
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4000f300: 7f ff fb b2 call 4000e1c8 <rtems_bdbuf_swapout_writereq_alloc>
4000f304: f6 04 60 0c ld [ %l1 + 0xc ], %i3
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4000f308: 03 10 00 6a sethi %hi(0x4001a800), %g1
4000f30c: d2 00 63 9c ld [ %g1 + 0x39c ], %o1 ! 4001ab9c <Configuration+0xc>
4000f310: 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 ();
4000f314: d0 27 bf fc st %o0, [ %fp + -4 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000f318: b4 07 bf e8 add %fp, -24, %i2
4000f31c: b0 07 bf ec add %fp, -20, %i0
head->previous = NULL;
4000f320: c0 27 bf ec clr [ %fp + -20 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000f324: f0 27 bf e8 st %i0, [ %fp + -24 ]
head->previous = NULL;
tail->previous = head;
4000f328: f4 27 bf f0 st %i2, [ %fp + -16 ]
rtems_chain_initialize_empty (&transfer.bds);
transfer.dd = BDBUF_INVALID_DEV;
4000f32c: c0 27 bf f4 clr [ %fp + -12 ]
transfer.syncing = false;
4000f330: c0 2f bf f8 clrb [ %fp + -8 ]
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4000f334: 91 2e e0 07 sll %i3, 7, %o0
4000f338: 90 22 00 01 sub %o0, %g1, %o0
4000f33c: 90 02 00 1b add %o0, %i3, %o0
4000f340: 40 00 25 b1 call 40018a04 <.udiv>
4000f344: 91 2a 20 03 sll %o0, 3, %o0
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
4000f348: 7f ff fb 17 call 4000dfa4 <rtems_bdbuf_lock_cache>
4000f34c: ac 10 00 08 mov %o0, %l6
for (w = 0; w < bdbuf_config.swapout_workers; w++)
4000f350: c2 04 60 14 ld [ %l1 + 0x14 ], %g1
* @param arg A pointer to the global cache data. Use the global variable and
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
4000f354: b2 10 20 61 mov 0x61, %i1
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
4000f358: 80 a0 60 00 cmp %g1, 0
4000f35c: 02 80 00 c3 be 4000f668 <rtems_bdbuf_swapout_task+0x374> <== ALWAYS TAKEN
4000f360: a4 00 60 61 add %g1, 0x61, %l2
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4000f364: 21 10 00 71 sethi %hi(0x4001c400), %l0 <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000f368: 29 10 91 1b sethi %hi(0x42446c00), %l4 <== NOT EXECUTED
4000f36c: a0 14 21 8c or %l0, 0x18c, %l0 <== NOT EXECUTED
4000f370: 27 10 00 3d sethi %hi(0x4000f400), %l3 <== NOT EXECUTED
the_node->next = tail;
4000f374: ae 04 20 0c add %l0, 0xc, %l7 <== NOT EXECUTED
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
4000f378: aa 10 20 01 mov 1, %l5 <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000f37c: a8 15 23 00 or %l4, 0x300, %l4 <== NOT EXECUTED
4000f380: a6 14 e2 88 or %l3, 0x288, %l3 <== NOT EXECUTED
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
4000f384: 7f ff d9 3a call 4000586c <malloc> <== NOT EXECUTED
4000f388: 90 10 20 28 mov 0x28, %o0 <== NOT EXECUTED
if (!worker)
4000f38c: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4000f390: 02 80 00 bb be 4000f67c <rtems_bdbuf_swapout_task+0x388> <== NOT EXECUTED
4000f394: 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;
4000f398: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED
the_node->next = tail;
4000f39c: ee 27 40 00 st %l7, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
old_last->next = the_node;
4000f3a0: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
the_node->previous = old_last;
4000f3a4: 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;
4000f3a8: fa 24 20 10 st %i5, [ %l0 + 0x10 ] <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
4000f3ac: 7f ff fb 87 call 4000e1c8 <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
4000f3b0: ea 2f 60 0c stb %l5, [ %i5 + 0xc ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000f3b4: d2 04 60 18 ld [ %l1 + 0x18 ], %o1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4000f3b8: 82 07 60 10 add %i5, 0x10, %g1 <== NOT EXECUTED
4000f3bc: 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 ();
4000f3c0: d0 27 60 24 st %o0, [ %i5 + 0x24 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000f3c4: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
4000f3c8: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000f3cc: c4 27 60 10 st %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
head->previous = NULL;
tail->previous = head;
4000f3d0: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
4000f3d4: c0 27 60 1c clr [ %i5 + 0x1c ] <== NOT EXECUTED
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000f3d8: 90 16 40 14 or %i1, %l4, %o0 <== NOT EXECUTED
4000f3dc: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
4000f3e0: 98 07 60 08 add %i5, 8, %o4 <== NOT EXECUTED
4000f3e4: 7f ff fb f7 call 4000e3c0 <rtems_bdbuf_create_task.constprop.9><== NOT EXECUTED
4000f3e8: b8 10 00 10 mov %l0, %i4 <== NOT EXECUTED
bdbuf_config.swapout_worker_priority,
RTEMS_BDBUF_SWAPOUT_WORKER_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
4000f3ec: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000f3f0: 12 80 00 a1 bne 4000f674 <rtems_bdbuf_swapout_task+0x380> <== NOT EXECUTED
4000f3f4: b2 06 60 01 inc %i1 <== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
4000f3f8: 80 a6 40 12 cmp %i1, %l2 <== NOT EXECUTED
4000f3fc: 12 bf ff e2 bne 4000f384 <rtems_bdbuf_swapout_task+0x90> <== NOT EXECUTED
4000f400: 01 00 00 00 nop <== NOT EXECUTED
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
}
rtems_bdbuf_unlock_cache ();
4000f404: 7f ff fa fe call 4000dffc <rtems_bdbuf_unlock_cache>
4000f408: 01 00 00 00 nop
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
4000f40c: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
4000f410: 80 a0 60 00 cmp %g1, 0
4000f414: 02 80 00 75 be 4000f5e8 <rtems_bdbuf_swapout_task+0x2f4> <== NEVER TAKEN
4000f418: 82 07 20 08 add %i4, 8, %g1
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000f41c: a2 07 20 4c add %i4, 0x4c, %l1
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000f420: aa 07 20 58 add %i4, 0x58, %l5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
4000f424: a8 07 20 0c add %i4, 0xc, %l4
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000f428: e2 27 bf dc st %l1, [ %fp + -36 ]
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
new_first->previous = head;
4000f42c: c2 27 bf d8 st %g1, [ %fp + -40 ]
* @param arg A pointer to the global cache data. Use the global variable and
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
4000f430: b2 10 20 01 mov 1, %i1
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
4000f434: a0 10 20 01 mov 1, %l0
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
4000f438: 7f ff fa db call 4000dfa4 <rtems_bdbuf_lock_cache>
4000f43c: 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)
4000f440: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
4000f444: 80 a0 60 00 cmp %g1, 0
4000f448: 32 80 00 2f bne,a 4000f504 <rtems_bdbuf_swapout_task+0x210>
4000f44c: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
4000f450: e6 07 20 08 ld [ %i4 + 8 ], %l3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
4000f454: 80 a4 c0 14 cmp %l3, %l4
4000f458: 02 80 00 7b be 4000f644 <rtems_bdbuf_swapout_task+0x350> <== ALWAYS TAKEN
4000f45c: c2 07 bf d8 ld [ %fp + -40 ], %g1
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
4000f460: c4 04 c0 00 ld [ %l3 ], %g2 <== NOT EXECUTED
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get_unprotected (&bdbuf_cache.swapout_workers);
if (worker)
transfer = &worker->transfer;
4000f464: ba 04 e0 10 add %l3, 0x10, %i5 <== NOT EXECUTED
head->next = new_first;
4000f468: c4 27 20 08 st %g2, [ %i4 + 8 ] <== NOT EXECUTED
new_first->previous = head;
4000f46c: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4000f470: ae 07 60 04 add %i5, 4, %l7
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000f474: a4 07 60 0c add %i5, 0xc, %l2
4000f478: 96 10 20 01 mov 1, %o3
4000f47c: 98 10 20 00 clr %o4
4000f480: 9a 10 00 1b mov %i3, %o5
4000f484: 90 10 00 12 mov %l2, %o0
4000f488: 94 10 00 1d mov %i5, %o2
head->next = tail;
4000f48c: ee 27 40 00 st %l7, [ %i5 ]
head->previous = NULL;
4000f490: c0 27 60 04 clr [ %i5 + 4 ]
tail->previous = head;
4000f494: fa 27 60 08 st %i5, [ %i5 + 8 ]
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
4000f498: c0 27 60 0c clr [ %i5 + 0xc ]
transfer->syncing = bdbuf_cache.sync_active;
4000f49c: c0 2f 60 10 clrb [ %i5 + 0x10 ]
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000f4a0: 13 10 00 71 sethi %hi(0x4001c400), %o1
4000f4a4: 7f ff fa 4d call 4000ddd8 <rtems_bdbuf_swapout_modified_processing>
4000f4a8: 92 12 61 e4 or %o1, 0x1e4, %o1 ! 4001c5e4 <bdbuf_cache+0x58>
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000f4ac: d2 07 bf dc ld [ %fp + -36 ], %o1
4000f4b0: d6 0f 20 30 ldub [ %i4 + 0x30 ], %o3
4000f4b4: 90 10 00 12 mov %l2, %o0
4000f4b8: 94 10 00 1d mov %i5, %o2
4000f4bc: 98 0e 60 01 and %i1, 1, %o4
4000f4c0: 7f ff fa 46 call 4000ddd8 <rtems_bdbuf_swapout_modified_processing>
4000f4c4: 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 ();
4000f4c8: 7f ff fa cd call 4000dffc <rtems_bdbuf_unlock_cache>
4000f4cc: 01 00 00 00 nop
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
4000f4d0: c6 07 40 00 ld [ %i5 ], %g3
4000f4d4: 80 a0 c0 17 cmp %g3, %l7
4000f4d8: 02 80 00 28 be 4000f578 <rtems_bdbuf_swapout_task+0x284>
4000f4dc: 80 a4 e0 00 cmp %l3, 0
{
if (worker)
4000f4e0: 02 80 00 22 be 4000f568 <rtems_bdbuf_swapout_task+0x274> <== ALWAYS TAKEN
4000f4e4: 01 00 00 00 nop
{
rtems_status_code sc = rtems_event_send (worker->id,
4000f4e8: d0 04 e0 08 ld [ %l3 + 8 ], %o0 <== NOT EXECUTED
4000f4ec: 7f ff e8 04 call 400094fc <rtems_event_send> <== NOT EXECUTED
4000f4f0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
4000f4f4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000f4f8: 12 80 00 56 bne 4000f650 <rtems_bdbuf_swapout_task+0x35c> <== NOT EXECUTED
4000f4fc: b2 10 20 00 clr %i1 <== NOT EXECUTED
4000f500: 30 bf ff ce b,a 4000f438 <rtems_bdbuf_swapout_task+0x144><== NOT EXECUTED
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000f504: 96 10 20 01 mov 1, %o3
* When the sync is for a device limit the sync to that device. If the sync
* is for a buffer handle process the devices in the order on the sync
* list. This means the dev is BDBUF_INVALID_DEV.
*/
if (bdbuf_cache.sync_active)
transfer->dd = bdbuf_cache.sync_device;
4000f508: c2 27 bf f4 st %g1, [ %fp + -12 ]
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000f50c: 98 10 20 00 clr %o4
4000f510: 9a 10 00 1b mov %i3, %o5
4000f514: 90 07 bf f4 add %fp, -12, %o0
4000f518: 92 10 00 15 mov %l5, %o1
4000f51c: 94 10 00 1a mov %i2, %o2
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000f520: f0 27 bf e8 st %i0, [ %fp + -24 ]
head->previous = NULL;
4000f524: c0 27 bf ec clr [ %fp + -20 ]
tail->previous = head;
4000f528: f4 27 bf f0 st %i2, [ %fp + -16 ]
4000f52c: 7f ff fa 2b call 4000ddd8 <rtems_bdbuf_swapout_modified_processing>
4000f530: e0 2f bf f8 stb %l0, [ %fp + -8 ]
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
4000f534: d6 0f 20 30 ldub [ %i4 + 0x30 ], %o3
4000f538: 90 07 bf f4 add %fp, -12, %o0
4000f53c: 92 10 00 11 mov %l1, %o1
4000f540: 94 10 00 1a mov %i2, %o2
4000f544: 98 0e 60 01 and %i1, 1, %o4
4000f548: 7f ff fa 24 call 4000ddd8 <rtems_bdbuf_swapout_modified_processing>
4000f54c: 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 ();
4000f550: 7f ff fa ab call 4000dffc <rtems_bdbuf_unlock_cache>
4000f554: 01 00 00 00 nop
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
4000f558: c2 07 bf e8 ld [ %fp + -24 ], %g1
4000f55c: 80 a0 40 18 cmp %g1, %i0
4000f560: 02 80 00 06 be 4000f578 <rtems_bdbuf_swapout_task+0x284>
4000f564: ba 10 00 1a mov %i2, %i5
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);
}
else
{
rtems_bdbuf_swapout_write (transfer);
4000f568: 7f ff ff 09 call 4000f18c <rtems_bdbuf_swapout_write>
4000f56c: 90 10 00 1d mov %i5, %o0
4000f570: 10 bf ff b2 b 4000f438 <rtems_bdbuf_swapout_task+0x144>
4000f574: b2 10 20 00 clr %i1
}
transfered_buffers = true;
}
if (bdbuf_cache.sync_active && !transfered_buffers)
4000f578: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
4000f57c: 80 a0 60 00 cmp %g1, 0
4000f580: 02 80 00 0f be 4000f5bc <rtems_bdbuf_swapout_task+0x2c8>
4000f584: 90 10 20 04 mov 4, %o0
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
4000f588: 7f ff fa 87 call 4000dfa4 <rtems_bdbuf_lock_cache>
4000f58c: 01 00 00 00 nop
sync_requester = bdbuf_cache.sync_requester;
4000f590: fa 07 20 34 ld [ %i4 + 0x34 ], %i5
bdbuf_cache.sync_active = false;
4000f594: c0 2f 20 30 clrb [ %i4 + 0x30 ]
bdbuf_cache.sync_requester = 0;
rtems_bdbuf_unlock_cache ();
4000f598: 7f ff fa 99 call 4000dffc <rtems_bdbuf_unlock_cache>
4000f59c: c0 27 20 34 clr [ %i4 + 0x34 ]
if (sync_requester)
4000f5a0: 80 a7 60 00 cmp %i5, 0
4000f5a4: 02 80 00 06 be 4000f5bc <rtems_bdbuf_swapout_task+0x2c8> <== NEVER TAKEN
4000f5a8: 90 10 20 04 mov 4, %o0
*/
RTEMS_INLINE_ROUTINE rtems_status_code rtems_event_transient_send(
rtems_id id
)
{
return rtems_event_system_send( id, RTEMS_EVENT_SYSTEM_TRANSIENT );
4000f5ac: 90 10 00 1d mov %i5, %o0
4000f5b0: 7f ff e9 86 call 40009bc8 <rtems_event_system_send>
4000f5b4: 13 20 00 00 sethi %hi(0x80000000), %o1
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
4000f5b8: 90 10 20 04 mov 4, %o0
4000f5bc: 92 10 20 00 clr %o1
4000f5c0: 94 10 00 16 mov %l6, %o2
4000f5c4: 7f ff e7 6a call 4000936c <rtems_event_receive>
4000f5c8: 96 07 bf e4 add %fp, -28, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
4000f5cc: 80 a2 20 06 cmp %o0, 6
4000f5d0: 12 80 00 22 bne 4000f658 <rtems_bdbuf_swapout_task+0x364>
4000f5d4: 80 a2 20 00 cmp %o0, 0
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
4000f5d8: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
4000f5dc: 80 a0 60 00 cmp %g1, 0
4000f5e0: 12 bf ff 95 bne 4000f434 <rtems_bdbuf_swapout_task+0x140> <== ALWAYS TAKEN
4000f5e4: b2 10 20 01 mov 1, %i1
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
4000f5e8: 7f ff fa 6f call 4000dfa4 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
4000f5ec: 01 00 00 00 nop <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000f5f0: 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))
4000f5f4: b8 07 20 0c add %i4, 0xc, %i4 <== NOT EXECUTED
4000f5f8: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
4000f5fc: 02 80 00 0a be 4000f624 <rtems_bdbuf_swapout_task+0x330> <== NOT EXECUTED
4000f600: 01 00 00 00 nop <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
4000f604: d0 07 60 08 ld [ %i5 + 8 ], %o0 <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
4000f608: c0 2f 60 0c clrb [ %i5 + 0xc ] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
4000f60c: 7f ff e7 bc call 400094fc <rtems_event_send> <== NOT EXECUTED
4000f610: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000f614: 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))
4000f618: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
4000f61c: 32 bf ff fb bne,a 4000f608 <rtems_bdbuf_swapout_task+0x314><== NOT EXECUTED
4000f620: 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 ();
4000f624: 7f ff fa 76 call 4000dffc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000f628: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
4000f62c: 7f ff d7 48 call 4000534c <free> <== NOT EXECUTED
4000f630: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
4000f634: 7f ff e9 c3 call 40009d40 <rtems_task_delete> <== NOT EXECUTED
4000f638: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000f63c: 81 c7 e0 08 ret <== NOT EXECUTED
4000f640: 81 e8 00 00 restore <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
4000f644: a6 10 20 00 clr %l3
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
4000f648: 10 bf ff 8a b 4000f470 <rtems_bdbuf_swapout_task+0x17c>
4000f64c: ba 10 00 1a mov %i2, %i5
if (worker)
{
rtems_status_code sc = rtems_event_send (worker->id,
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);
4000f650: 7f ff fa 43 call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000f654: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
4000f658: 22 bf ff e1 be,a 4000f5dc <rtems_bdbuf_swapout_task+0x2e8><== ALWAYS TAKEN
4000f65c: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
4000f660: 7f ff fa 3f call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000f664: 90 10 20 18 mov 0x18, %o0 <== NOT EXECUTED
4000f668: 39 10 00 71 sethi %hi(0x4001c400), %i4
4000f66c: 10 bf ff 66 b 4000f404 <rtems_bdbuf_swapout_task+0x110>
4000f670: b8 17 21 8c or %i4, 0x18c, %i4 ! 4001c58c <bdbuf_cache>
RTEMS_BDBUF_SWAPOUT_WORKER_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
4000f674: 7f ff fa 3a call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000f678: 90 10 20 0d mov 0xd, %o0 <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
4000f67c: 7f ff fa 38 call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000f680: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
4000f688 <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)
{
4000f688: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
4000f68c: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
4000f690: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000f694: 02 80 00 1b be 4000f700 <rtems_bdbuf_swapout_worker_task+0x78><== NOT EXECUTED
4000f698: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
4000f69c: 39 10 00 71 sethi %hi(0x4001c400), %i4 <== NOT EXECUTED
4000f6a0: b6 06 20 10 add %i0, 0x10, %i3 <== NOT EXECUTED
4000f6a4: b8 17 21 8c or %i4, 0x18c, %i4 <== NOT EXECUTED
4000f6a8: b2 06 20 14 add %i0, 0x14, %i1 <== NOT EXECUTED
4000f6ac: b4 07 20 0c add %i4, 0xc, %i2 <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
4000f6b0: 7f ff fa b4 call 4000e180 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
4000f6b4: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
4000f6b8: 7f ff fe b5 call 4000f18c <rtems_bdbuf_swapout_write> <== NOT EXECUTED
4000f6bc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
4000f6c0: 7f ff fa 39 call 4000dfa4 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
4000f6c4: 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;
4000f6c8: c2 07 20 10 ld [ %i4 + 0x10 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4000f6cc: f2 27 60 10 st %i1, [ %i5 + 0x10 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
4000f6d0: c0 27 60 1c clr [ %i5 + 0x1c ] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
4000f6d4: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
4000f6d8: fa 27 20 10 st %i5, [ %i4 + 0x10 ] <== NOT EXECUTED
old_last->next = the_node;
4000f6dc: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
the_node->previous = old_last;
4000f6e0: c2 27 60 04 st %g1, [ %i5 + 4 ] <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4000f6e4: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
4000f6e8: 7f ff fa 45 call 4000dffc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
4000f6ec: f6 27 60 18 st %i3, [ %i5 + 0x18 ] <== NOT EXECUTED
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
4000f6f0: c2 0f 60 0c ldub [ %i5 + 0xc ], %g1 <== NOT EXECUTED
4000f6f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000f6f8: 12 bf ff ee bne 4000f6b0 <rtems_bdbuf_swapout_worker_task+0x28><== NOT EXECUTED
4000f6fc: 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);
4000f700: d0 07 60 24 ld [ %i5 + 0x24 ], %o0 <== NOT EXECUTED
4000f704: 7f ff d7 12 call 4000534c <free> <== NOT EXECUTED
4000f708: b0 10 20 00 clr %i0 <== NOT EXECUTED
free (worker);
4000f70c: 7f ff d7 10 call 4000534c <free> <== NOT EXECUTED
4000f710: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
4000f714: 7f ff e9 8b call 40009d40 <rtems_task_delete> <== NOT EXECUTED
4000f718: 81 e8 00 00 restore <== NOT EXECUTED
4000f18c <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
4000f18c: 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;
4000f190: 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 );
4000f194: ba 06 20 04 add %i0, 4, %i5
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dd->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
4000f198: 80 a0 40 1d cmp %g1, %i5
4000f19c: 02 80 00 4f be 4000f2d8 <rtems_bdbuf_swapout_write+0x14c> <== NEVER TAKEN
4000f1a0: b8 10 20 00 clr %i4
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
4000f1a4: e0 06 20 0c ld [ %i0 + 0xc ], %l0
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4000f1a8: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
4000f1ac: c4 04 20 08 ld [ %l0 + 8 ], %g2
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
4000f1b0: f4 04 20 2c ld [ %l0 + 0x2c ], %i2
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
4000f1b4: e2 00 a0 0c ld [ %g2 + 0xc ], %l1
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4000f1b8: 84 10 20 0c mov 0xc, %g2
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
4000f1bc: a2 0c 60 01 and %l1, 1, %l1
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4000f1c0: c4 22 60 0c st %g2, [ %o1 + 0xc ]
transfer->write_req->bufnum = 0;
4000f1c4: c0 22 60 10 clr [ %o1 + 0x10 ]
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4000f1c8: b6 10 20 0c mov 0xc, %i3
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
4000f1cc: 10 80 00 23 b 4000f258 <rtems_bdbuf_swapout_write+0xcc>
4000f1d0: 25 10 00 6a sethi %hi(0x4001a800), %l2
4000f1d4: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000f1d8: c8 02 60 10 ld [ %o1 + 0x10 ], %g4
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
buf->length = dd->block_size;
buf->buffer = bd->buffer;
4000f1dc: f2 00 60 1c ld [ %g1 + 0x1c ], %i1
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
buf->length = dd->block_size;
4000f1e0: de 04 20 24 ld [ %l0 + 0x24 ], %o7
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
4000f1e4: b8 01 20 01 add %g4, 1, %i4
4000f1e8: f8 22 60 10 st %i4, [ %o1 + 0x10 ]
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000f1ec: 89 29 20 04 sll %g4, 4, %g4
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
4000f1f0: b8 10 00 03 mov %g3, %i4
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000f1f4: 88 01 20 18 add %g4, 0x18, %g4
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
4000f1f8: 9a 10 20 00 clr %o5
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000f1fc: 86 02 40 04 add %o1, %g4, %g3
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
4000f200: f8 22 40 04 st %i4, [ %o1 + %g4 ]
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
4000f204: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
buf->block = bd->block;
buf->length = dd->block_size;
4000f208: de 20 e0 04 st %o7, [ %g3 + 4 ]
buf->buffer = bd->buffer;
4000f20c: f2 20 e0 08 st %i1, [ %g3 + 8 ]
4000f210: 82 10 00 02 mov %g2, %g1
/*
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
4000f214: 80 a7 40 01 cmp %i5, %g1
4000f218: 02 80 00 07 be 4000f234 <rtems_bdbuf_swapout_write+0xa8>
4000f21c: 84 14 a3 d8 or %l2, 0x3d8, %g2
4000f220: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
4000f224: c4 00 a0 04 ld [ %g2 + 4 ], %g2
4000f228: 80 a0 c0 02 cmp %g3, %g2
4000f22c: 0a 80 00 1e bcs 4000f2a4 <rtems_bdbuf_swapout_write+0x118>
4000f230: 80 8b 60 ff btst 0xff, %o5
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
4000f234: 90 10 00 10 mov %l0, %o0
4000f238: 7f ff ff 5d call 4000efac <rtems_bdbuf_execute_transfer_request>
4000f23c: 94 10 20 00 clr %o2
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
4000f240: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
4000f244: c2 06 00 00 ld [ %i0 ], %g1
4000f248: f6 22 60 0c st %i3, [ %o1 + 0xc ]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
4000f24c: 80 a7 40 01 cmp %i5, %g1
4000f250: 02 80 00 19 be 4000f2b4 <rtems_bdbuf_swapout_write+0x128>
4000f254: c0 22 60 10 clr [ %o1 + 0x10 ]
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
4000f258: c4 00 40 00 ld [ %g1 ], %g2
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
4000f25c: 80 a4 60 00 cmp %l1, 0
head->next = new_first;
4000f260: c4 26 00 00 st %g2, [ %i0 ]
4000f264: 02 bf ff dc be 4000f1d4 <rtems_bdbuf_swapout_write+0x48>
4000f268: f0 20 a0 04 st %i0, [ %g2 + 4 ]
4000f26c: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
4000f270: 80 a0 e0 00 cmp %g3, 0
4000f274: 02 bf ff d9 be 4000f1d8 <rtems_bdbuf_swapout_write+0x4c>
4000f278: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
bd->block != last_block + media_blocks_per_block)
4000f27c: 88 07 00 1a add %i4, %i2, %g4
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
4000f280: 80 a0 c0 04 cmp %g3, %g4
4000f284: 02 bf ff d5 be 4000f1d8 <rtems_bdbuf_swapout_write+0x4c>
4000f288: 9a 10 20 01 mov 1, %o5
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000f28c: f0 20 60 04 st %i0, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
4000f290: c2 26 00 00 st %g1, [ %i0 ]
the_node->next = before_node;
4000f294: c4 20 40 00 st %g2, [ %g1 ]
before_node->previous = the_node;
4000f298: c2 20 a0 04 st %g1, [ %g2 + 4 ]
bd->block != last_block + media_blocks_per_block)
{
rtems_chain_prepend_unprotected (&transfer->bds, &bd->link);
write = true;
4000f29c: 10 bf ff de b 4000f214 <rtems_bdbuf_swapout_write+0x88>
4000f2a0: c2 06 00 00 ld [ %i0 ], %g1
if (rtems_chain_is_empty (&transfer->bds) ||
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
4000f2a4: 12 bf ff e4 bne 4000f234 <rtems_bdbuf_swapout_write+0xa8>
4000f2a8: 80 a7 40 01 cmp %i5, %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
4000f2ac: 32 bf ff ec bne,a 4000f25c <rtems_bdbuf_swapout_write+0xd0><== ALWAYS TAKEN
4000f2b0: c4 00 40 00 ld [ %g1 ], %g2
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
4000f2b4: c2 0e 20 10 ldub [ %i0 + 0x10 ], %g1
4000f2b8: 80 a0 60 00 cmp %g1, 0
4000f2bc: 02 80 00 0c be 4000f2ec <rtems_bdbuf_swapout_write+0x160>
4000f2c0: 01 00 00 00 nop
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
4000f2c4: d0 04 20 08 ld [ %l0 + 8 ], %o0
4000f2c8: 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 &&
4000f2cc: 80 88 60 02 btst 2, %g1
4000f2d0: 32 80 00 04 bne,a 4000f2e0 <rtems_bdbuf_swapout_write+0x154><== NEVER TAKEN
4000f2d4: c2 04 20 38 ld [ %l0 + 0x38 ], %g1 <== NOT EXECUTED
4000f2d8: 81 c7 e0 08 ret
4000f2dc: 81 e8 00 00 restore
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
4000f2e0: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
4000f2e4: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000f2e8: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000f2ec: 81 c7 e0 08 ret
4000f2f0: 81 e8 00 00 restore
4000e1c8 <rtems_bdbuf_swapout_writereq_alloc>:
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
4000e1c8: 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)));
4000e1cc: 03 10 00 6a sethi %hi(0x4001a800), %g1
4000e1d0: d0 00 63 dc ld [ %g1 + 0x3dc ], %o0 ! 4001abdc <rtems_bdbuf_configuration+0x4>
4000e1d4: 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 =
4000e1d8: 7f ff dd a5 call 4000586c <malloc>
4000e1dc: 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)
4000e1e0: ba 92 20 00 orcc %o0, 0, %i5
4000e1e4: 02 80 00 0b be 4000e210 <rtems_bdbuf_swapout_writereq_alloc+0x48><== NEVER TAKEN
4000e1e8: 82 10 20 01 mov 1, %g1
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
4000e1ec: c2 27 40 00 st %g1, [ %i5 ]
write_req->done = rtems_bdbuf_transfer_done;
4000e1f0: 03 10 00 3d sethi %hi(0x4000f400), %g1
4000e1f4: 82 10 63 f0 or %g1, 0x3f0, %g1 ! 4000f7f0 <rtems_bdbuf_transfer_done>
write_req->io_task = rtems_task_self ();
return write_req;
}
4000e1f8: b0 10 00 1d mov %i5, %i0
if (!write_req)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
write_req->done = rtems_bdbuf_transfer_done;
write_req->io_task = rtems_task_self ();
4000e1fc: 40 00 12 50 call 40012b3c <rtems_task_self>
4000e200: c2 27 60 04 st %g1, [ %i5 + 4 ]
4000e204: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
return write_req;
}
4000e208: 81 c7 e0 08 ret
4000e20c: 81 e8 00 00 restore
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);
4000e210: 7f ff ff 53 call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e214: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
40010200 <rtems_bdbuf_sync>:
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
40010200: 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)
40010204: 80 a6 20 00 cmp %i0, 0
40010208: 02 80 00 30 be 400102c8 <rtems_bdbuf_sync+0xc8> <== NEVER TAKEN
4001020c: 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();
40010210: 7f ff f7 65 call 4000dfa4 <rtems_bdbuf_lock_cache>
40010214: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
40010218: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4001021c: 80 a2 20 03 cmp %o0, 3
40010220: 1a 80 00 04 bcc 40010230 <rtems_bdbuf_sync+0x30> <== ALWAYS TAKEN
40010224: 80 a2 20 05 cmp %o0, 5
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);
40010228: 7f ff f7 65 call 4000dfbc <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
4001022c: 92 10 20 11 mov 0x11, %o1 <== NOT EXECUTED
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
40010230: 08 80 00 0b bleu 4001025c <rtems_bdbuf_sync+0x5c>
40010234: 82 10 20 08 mov 8, %g1
40010238: 80 a2 20 06 cmp %o0, 6
4001023c: 12 bf ff fb bne 40010228 <rtems_bdbuf_sync+0x28> <== NEVER TAKEN
40010240: 01 00 00 00 nop
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_sync_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
40010244: 7f ff f9 7f call 4000e840 <rtems_bdbuf_discard_buffer_after_access>
40010248: 90 10 00 18 mov %i0, %o0
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
4001024c: 7f ff f7 6c call 4000dffc <rtems_bdbuf_unlock_cache>
40010250: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
40010254: 81 c7 e0 08 ret
40010258: 81 e8 00 00 restore
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
4001025c: 3b 10 00 71 sethi %hi(0x4001c400), %i5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
40010260: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
40010264: ba 17 61 8c or %i5, 0x18c, %i5
40010268: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
the_node->next = tail;
4001026c: 84 07 60 5c add %i5, 0x5c, %g2
tail->previous = the_node;
40010270: f0 27 60 60 st %i0, [ %i5 + 0x60 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
40010274: c4 26 00 00 st %g2, [ %i0 ]
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
40010278: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
tail->previous = the_node;
old_last->next = the_node;
the_node->previous = old_last;
4001027c: c2 26 20 04 st %g1, [ %i0 + 4 ]
40010280: 80 a0 a0 00 cmp %g2, 0
40010284: 12 80 00 13 bne 400102d0 <rtems_bdbuf_sync+0xd0>
40010288: f0 20 40 00 st %i0, [ %g1 ]
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
rtems_bdbuf_wake_swapper ();
4001028c: 7f ff f7 62 call 4000e014 <rtems_bdbuf_wake_swapper>
40010290: 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);
40010294: 13 10 00 71 sethi %hi(0x4001c400), %o1
40010298: b8 12 61 f8 or %o1, 0x1f8, %i4 ! 4001c5f8 <bdbuf_cache+0x6c>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
4001029c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
400102a0: 80 a2 20 01 cmp %o0, 1
400102a4: 0a 80 00 07 bcs 400102c0 <rtems_bdbuf_sync+0xc0> <== NEVER TAKEN
400102a8: 80 a2 20 07 cmp %o0, 7
400102ac: 28 80 00 10 bleu,a 400102ec <rtems_bdbuf_sync+0xec>
400102b0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
400102b4: 80 a2 20 0a cmp %o0, 0xa
400102b8: 28 80 00 09 bleu,a 400102dc <rtems_bdbuf_sync+0xdc> <== ALWAYS TAKEN
400102bc: 90 10 00 18 mov %i0, %o0
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_9);
400102c0: 7f ff f7 3f call 4000dfbc <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
400102c4: 92 10 20 15 mov 0x15, %o1 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
400102c8: 81 c7 e0 08 ret <== NOT EXECUTED
400102cc: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
400102d0: 7f ff f7 ec call 4000e280 <rtems_bdbuf_wake>
400102d4: 90 07 60 64 add %i5, 0x64, %o0
400102d8: 30 bf ff ed b,a 4001028c <rtems_bdbuf_sync+0x8c>
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
return;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
400102dc: 7f ff f7 96 call 4000e134 <rtems_bdbuf_wait>
400102e0: 92 10 00 1c mov %i4, %o1
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
400102e4: 10 bf ff ef b 400102a0 <rtems_bdbuf_sync+0xa0>
400102e8: 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
400102ec: 80 a0 60 00 cmp %g1, 0
400102f0: 12 bf ff d7 bne 4001024c <rtems_bdbuf_sync+0x4c>
400102f4: 82 02 3f ff add %o0, -1, %g1
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
400102f8: 80 a0 60 01 cmp %g1, 1
400102fc: 18 bf ff d4 bgu 4001024c <rtems_bdbuf_sync+0x4c> <== NEVER TAKEN
40010300: 80 a2 20 01 cmp %o0, 1
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
40010304: 02 80 00 06 be 4001031c <rtems_bdbuf_sync+0x11c>
40010308: 01 00 00 00 nop
{
rtems_bdbuf_remove_from_tree (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
4001030c: 11 10 00 71 sethi %hi(0x4001c400), %o0
40010310: 7f ff f7 dc call 4000e280 <rtems_bdbuf_wake>
40010314: 90 12 22 00 or %o0, 0x200, %o0 ! 4001c600 <bdbuf_cache+0x74>
40010318: 30 bf ff cd b,a 4001024c <rtems_bdbuf_sync+0x4c>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
{
rtems_bdbuf_remove_from_tree (bd);
4001031c: 7f ff f8 41 call 4000e420 <rtems_bdbuf_remove_from_tree>
40010320: 90 10 00 18 mov %i0, %o0
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
40010324: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
40010328: c0 26 20 20 clr [ %i0 + 0x20 ]
after_node->next = the_node;
4001032c: f0 27 60 40 st %i0, [ %i5 + 0x40 ]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
40010330: 05 10 00 71 sethi %hi(0x4001c400), %g2
40010334: 84 10 a1 cc or %g2, 0x1cc, %g2 ! 4001c5cc <bdbuf_cache+0x40>
40010338: c4 26 20 04 st %g2, [ %i0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
4001033c: c2 26 00 00 st %g1, [ %i0 ]
before_node->previous = the_node;
40010340: 10 bf ff f3 b 4001030c <rtems_bdbuf_sync+0x10c>
40010344: f0 20 60 04 st %i0, [ %g1 + 4 ]
4000dfd0 <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)
{
4000dfd0: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_release (lock);
4000dfd4: 7f ff ee d2 call 40009b1c <rtems_semaphore_release>
4000dfd8: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL)
4000dfdc: 80 a2 20 00 cmp %o0, 0
4000dfe0: 12 80 00 04 bne 4000dff0 <rtems_bdbuf_unlock+0x20> <== NEVER TAKEN
4000dfe4: 01 00 00 00 nop
4000dfe8: 81 c7 e0 08 ret
4000dfec: 81 e8 00 00 restore
rtems_bdbuf_fatal (fatal_error_code);
4000dff0: 7f ff ff db call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000dff4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4000e180 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
4000e180: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
4000e184: 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;
4000e188: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_event_receive (event,
4000e18c: 90 10 00 18 mov %i0, %o0
4000e190: 94 10 20 00 clr %o2
4000e194: 7f ff ec 76 call 4000936c <rtems_event_receive>
4000e198: 96 07 bf fc add %fp, -4, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
4000e19c: 80 a2 20 00 cmp %o0, 0
4000e1a0: 12 80 00 07 bne 4000e1bc <rtems_bdbuf_wait_for_event+0x3c><== NEVER TAKEN
4000e1a4: c2 07 bf fc ld [ %fp + -4 ], %g1
4000e1a8: 80 a0 40 18 cmp %g1, %i0
4000e1ac: 12 80 00 04 bne 4000e1bc <rtems_bdbuf_wait_for_event+0x3c><== NEVER TAKEN
4000e1b0: 01 00 00 00 nop
4000e1b4: 81 c7 e0 08 ret
4000e1b8: 81 e8 00 00 restore
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
4000e1bc: 7f ff ff 68 call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e1c0: 90 10 20 1c mov 0x1c, %o0 <== NOT EXECUTED
4000ef74 <rtems_bdbuf_wait_for_transient_event>:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
}
static void
rtems_bdbuf_wait_for_transient_event (void)
{
4000ef74: 9d e3 bf 98 save %sp, -104, %sp
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
4000ef78: 11 20 00 00 sethi %hi(0x80000000), %o0
4000ef7c: 92 10 20 00 clr %o1
4000ef80: 94 10 20 00 clr %o2
4000ef84: 40 00 0e 5f call 40012900 <rtems_event_system_receive>
4000ef88: 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)
4000ef8c: 80 a2 20 00 cmp %o0, 0
4000ef90: 12 80 00 04 bne 4000efa0 <rtems_bdbuf_wait_for_transient_event+0x2c><== NEVER TAKEN
4000ef94: 01 00 00 00 nop
4000ef98: 81 c7 e0 08 ret
4000ef9c: 81 e8 00 00 restore
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);
4000efa0: 7f ff fb ef call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000efa4: 90 10 20 1d mov 0x1d, %o0 <== NOT EXECUTED
4000e280 <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)
{
4000e280: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
4000e284: c2 06 00 00 ld [ %i0 ], %g1
4000e288: 80 a0 60 00 cmp %g1, 0
4000e28c: 12 80 00 04 bne 4000e29c <rtems_bdbuf_wake+0x1c>
4000e290: 01 00 00 00 nop
4000e294: 81 c7 e0 08 ret
4000e298: 81 e8 00 00 restore
{
sc = rtems_semaphore_flush (waiters->sema);
4000e29c: 40 00 11 6c call 4001284c <rtems_semaphore_flush>
4000e2a0: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4000e2a4: 80 a2 20 00 cmp %o0, 0
4000e2a8: 02 bf ff fb be 4000e294 <rtems_bdbuf_wake+0x14> <== ALWAYS TAKEN
4000e2ac: 01 00 00 00 nop
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAKE);
4000e2b0: 7f ff ff 2b call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e2b4: 90 10 20 04 mov 4, %o0 ! 4 <PROM_START+0x4> <== NOT EXECUTED
4000e014 <rtems_bdbuf_wake_swapper>:
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
4000e014: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
4000e018: 03 10 00 71 sethi %hi(0x4001c400), %g1
4000e01c: d0 00 61 8c ld [ %g1 + 0x18c ], %o0 ! 4001c58c <bdbuf_cache>
4000e020: 7f ff ed 37 call 400094fc <rtems_event_send>
4000e024: 92 10 20 04 mov 4, %o1
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
4000e028: 80 a2 20 00 cmp %o0, 0
4000e02c: 12 80 00 04 bne 4000e03c <rtems_bdbuf_wake_swapper+0x28> <== NEVER TAKEN
4000e030: 01 00 00 00 nop
4000e034: 81 c7 e0 08 ret
4000e038: 81 e8 00 00 restore
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);
4000e03c: 7f ff ff c8 call 4000df5c <rtems_bdbuf_fatal> <== NOT EXECUTED
4000e040: 90 10 20 0b mov 0xb, %o0 <== NOT EXECUTED
400039fc <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
400039fc: 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;
40003a00: 80 a6 60 00 cmp %i1, 0
40003a04: 02 80 00 06 be 40003a1c <rtems_bdpart_create+0x20> <== NEVER TAKEN
40003a08: 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
40003a0c: c2 06 40 00 ld [ %i1 ], %g1
40003a10: 80 a0 60 00 cmp %g1, 0
40003a14: 22 80 00 12 be,a 40003a5c <rtems_bdpart_create+0x60> <== ALWAYS TAKEN
40003a18: c2 0e 60 08 ldub [ %i1 + 8 ], %g1
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
40003a1c: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
const unsigned *dist,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
40003a20: a2 10 20 00 clr %l1 <== NOT EXECUTED
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
40003a24: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
rtems_blkdev_bnum overhead = 0;
rtems_blkdev_bnum free_space = 0;
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
40003a28: 80 a7 20 00 cmp %i4, 0
40003a2c: 02 80 00 0a be 40003a54 <rtems_bdpart_create+0x58> <== NEVER TAKEN
40003a30: b0 10 20 00 clr %i0
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
40003a34: 80 a6 a0 00 cmp %i2, 0
40003a38: 02 80 00 07 be 40003a54 <rtems_bdpart_create+0x58> <== NEVER TAKEN
40003a3c: b0 10 20 09 mov 9, %i0
40003a40: 80 a6 60 00 cmp %i1, 0
40003a44: 02 80 00 04 be 40003a54 <rtems_bdpart_create+0x58> <== NEVER TAKEN
40003a48: 80 a6 e0 00 cmp %i3, 0
40003a4c: 12 80 00 0a bne 40003a74 <rtems_bdpart_create+0x78> <== ALWAYS TAKEN
40003a50: 92 10 20 00 clr %o1
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
return RTEMS_SUCCESSFUL;
}
40003a54: 81 c7 e0 08 ret <== NOT EXECUTED
40003a58: 81 e8 00 00 restore <== NOT EXECUTED
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
40003a5c: 80 a0 60 00 cmp %g1, 0
40003a60: 02 bf ff f0 be 40003a20 <rtems_bdpart_create+0x24> <== NEVER TAKEN
40003a64: c0 27 bf fc clr [ %fp + -4 ]
const unsigned *dist,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
40003a68: a2 10 20 01 mov 1, %l1
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
40003a6c: 10 bf ff ef b 40003a28 <rtems_bdpart_create+0x2c>
40003a70: a0 10 20 3f mov 0x3f, %l0
if (format == NULL || pt == NULL || dist == NULL) {
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end);
40003a74: 94 10 20 00 clr %o2
40003a78: 40 00 01 3d call 40003f6c <rtems_bdpart_get_disk_data>
40003a7c: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL) {
40003a80: b0 92 20 00 orcc %o0, 0, %i0
40003a84: 12 80 00 72 bne 40003c4c <rtems_bdpart_create+0x250> <== NEVER TAKEN
40003a88: 01 00 00 00 nop
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
40003a8c: e4 06 c0 00 ld [ %i3 ], %l2
if (dist_sum < prev_sum) {
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
40003a90: ba 94 a0 00 orcc %l2, 0, %i5
40003a94: 12 80 00 0b bne 40003ac0 <rtems_bdpart_create+0xc4> <== ALWAYS TAKEN
40003a98: 82 10 20 00 clr %g1
return RTEMS_INVALID_NUMBER;
40003a9c: 81 c7 e0 08 ret <== NOT EXECUTED
40003aa0: 91 e8 20 0a restore %g0, 0xa, %o0 <== NOT EXECUTED
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
40003aa4: c4 06 c0 02 ld [ %i3 + %g2 ], %g2
40003aa8: 86 07 40 02 add %i5, %g2, %g3
if (dist_sum < prev_sum) {
40003aac: 80 a0 c0 1d cmp %g3, %i5
40003ab0: 0a 80 00 0e bcs 40003ae8 <rtems_bdpart_create+0xec> <== NEVER TAKEN
40003ab4: 80 a0 a0 00 cmp %g2, 0
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
40003ab8: 02 80 00 0c be 40003ae8 <rtems_bdpart_create+0xec> <== NEVER TAKEN
40003abc: ba 10 00 03 mov %g3, %i5
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
40003ac0: 82 00 60 01 inc %g1
40003ac4: 80 a0 40 1c cmp %g1, %i4
40003ac8: 12 bf ff f7 bne 40003aa4 <rtems_bdpart_create+0xa8>
40003acc: 85 28 60 02 sll %g1, 2, %g2
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
40003ad0: c2 06 40 00 ld [ %i1 ], %g1
40003ad4: 80 a0 60 00 cmp %g1, 0
40003ad8: 02 80 00 06 be 40003af0 <rtems_bdpart_create+0xf4> <== ALWAYS TAKEN
40003adc: a2 8c 60 ff andcc %l1, 0xff, %l1
return RTEMS_NOT_IMPLEMENTED;
40003ae0: 81 c7 e0 08 ret <== NOT EXECUTED
40003ae4: 91 e8 20 18 restore %g0, 0x18, %o0 <== NOT EXECUTED
if (dist_sum < prev_sum) {
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
return RTEMS_INVALID_NUMBER;
40003ae8: 81 c7 e0 08 ret <== NOT EXECUTED
40003aec: 91 e8 20 0a restore %g0, 0xa, %o0 <== NOT EXECUTED
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
40003af0: 02 80 00 06 be 40003b08 <rtems_bdpart_create+0x10c> <== NEVER TAKEN
40003af4: ec 07 bf fc ld [ %fp + -4 ], %l6
disk_end -= (disk_end % record_space);
40003af8: 90 10 00 16 mov %l6, %o0
40003afc: 40 00 7d 81 call 40023100 <.urem>
40003b00: 92 10 00 10 mov %l0, %o1
40003b04: ac 25 80 08 sub %l6, %o0, %l6
/*
* In case we need an extended partition and logical partitions we have to
* account for the space of each EBR.
*/
if (count > 4) {
40003b08: 80 a7 20 04 cmp %i4, 4
40003b0c: 08 80 00 06 bleu 40003b24 <rtems_bdpart_create+0x128> <== NEVER TAKEN
40003b10: aa 10 00 10 mov %l0, %l5
overhead += (count - 3) * record_space;
40003b14: 90 10 00 10 mov %l0, %o0
40003b18: 40 00 7c 94 call 40022d68 <.umul>
40003b1c: 92 07 3f fd add %i4, -3, %o1
40003b20: aa 02 00 10 add %o0, %l0, %l5
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
40003b24: 80 a4 60 00 cmp %l1, 0
40003b28: 02 80 00 07 be 40003b44 <rtems_bdpart_create+0x148> <== NEVER TAKEN
40003b2c: 82 05 40 1c add %l5, %i4, %g1
overhead += (count - 1) * record_space;
40003b30: 90 10 00 10 mov %l0, %o0
40003b34: 40 00 7c 8d call 40022d68 <.umul>
40003b38: 92 07 3f ff add %i4, -1, %o1
40003b3c: aa 05 40 08 add %l5, %o0, %l5
}
/* Check disk space */
if ((overhead + count) > disk_end) {
40003b40: 82 05 40 1c add %l5, %i4, %g1
40003b44: 80 a0 40 16 cmp %g1, %l6
40003b48: 08 80 00 04 bleu 40003b58 <rtems_bdpart_create+0x15c> <== ALWAYS TAKEN
40003b4c: aa 25 80 15 sub %l6, %l5, %l5
return RTEMS_IO_ERROR;
40003b50: 81 c7 e0 08 ret <== NOT EXECUTED
40003b54: 91 e8 20 1b restore %g0, 0x1b, %o0 <== NOT EXECUTED
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
40003b58: 92 10 00 12 mov %l2, %o1
40003b5c: 40 00 7c 83 call 40022d68 <.umul>
40003b60: 90 10 00 15 mov %l5, %o0
if (s < free_space || s < dist [i]) {
40003b64: 80 a5 40 08 cmp %l5, %o0
40003b68: 18 bf ff e0 bgu 40003ae8 <rtems_bdpart_create+0xec> <== NEVER TAKEN
40003b6c: 80 a4 80 08 cmp %l2, %o0
40003b70: 18 bf ff de bgu 40003ae8 <rtems_bdpart_create+0xec> <== NEVER TAKEN
40003b74: 80 a7 20 04 cmp %i4, 4
40003b78: 18 80 00 03 bgu 40003b84 <rtems_bdpart_create+0x188> <== ALWAYS TAKEN
40003b7c: ae 10 20 01 mov 1, %l7
40003b80: ae 10 20 00 clr %l7 <== NOT EXECUTED
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
40003b84: a8 06 a0 30 add %i2, 0x30, %l4
40003b88: a6 10 00 1a mov %i2, %l3
if ((overhead + count) > disk_end) {
return RTEMS_IO_ERROR;
}
/* Begin of first primary partition */
pos = record_space;
40003b8c: a2 10 00 10 mov %l0, %l1
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
40003b90: b2 10 20 00 clr %i1
/* Align partition upwards */
s += record_space - (s % record_space);
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
40003b94: 10 80 00 0b b 40003bc0 <rtems_bdpart_create+0x1c4>
40003b98: ae 0d e0 ff and %l7, 0xff, %l7
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
40003b9c: e4 06 c0 01 ld [ %i3 + %g1 ], %l2
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
40003ba0: a6 10 00 14 mov %l4, %l3
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
40003ba4: 40 00 7c 71 call 40022d68 <.umul>
40003ba8: 90 10 00 12 mov %l2, %o0
if (s < free_space || s < dist [i]) {
40003bac: 80 a5 40 08 cmp %l5, %o0
40003bb0: 18 bf ff ce bgu 40003ae8 <rtems_bdpart_create+0xec> <== NEVER TAKEN
40003bb4: 80 a4 80 08 cmp %l2, %o0
40003bb8: 18 bf ff cc bgu 40003ae8 <rtems_bdpart_create+0xec> <== NEVER TAKEN
40003bbc: a8 05 20 30 add %l4, 0x30, %l4
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
40003bc0: 40 00 7c a4 call 40022e50 <.udiv>
40003bc4: 92 10 00 1d mov %i5, %o1
if (s == 0) {
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
40003bc8: 92 10 00 10 mov %l0, %o1
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
/* Ensure that the partition is not empty */
if (s == 0) {
40003bcc: 80 a2 20 00 cmp %o0, 0
40003bd0: 12 80 00 03 bne 40003bdc <rtems_bdpart_create+0x1e0> <== ALWAYS TAKEN
40003bd4: a4 10 00 08 mov %o0, %l2
s = 1;
40003bd8: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
}
/* Align partition upwards */
s += record_space - (s % record_space);
40003bdc: 40 00 7d 49 call 40023100 <.urem>
40003be0: 90 10 00 12 mov %l2, %o0
40003be4: a4 04 80 10 add %l2, %l0, %l2
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
40003be8: 92 10 00 15 mov %l5, %o1
/* Align partition upwards */
s += record_space - (s % record_space);
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
40003bec: 82 10 20 01 mov 1, %g1
40003bf0: 80 a6 60 02 cmp %i1, 2
40003bf4: 18 80 00 03 bgu 40003c00 <rtems_bdpart_create+0x204>
40003bf8: 90 24 80 08 sub %l2, %o0, %o0
40003bfc: 82 10 20 00 clr %g1
40003c00: 80 88 60 ff btst 0xff, %g1
40003c04: 22 80 00 06 be,a 40003c1c <rtems_bdpart_create+0x220>
40003c08: e2 24 c0 00 st %l1, [ %l3 ]
40003c0c: 80 a5 e0 00 cmp %l7, 0
40003c10: 32 80 00 02 bne,a 40003c18 <rtems_bdpart_create+0x21c> <== ALWAYS TAKEN
40003c14: a2 04 40 10 add %l1, %l0, %l1
pos += record_space;
}
/* Partition begin and end */
p->begin = pos;
40003c18: e2 24 c0 00 st %l1, [ %l3 ]
pos += s;
40003c1c: a2 04 40 08 add %l1, %o0, %l1
p->end = pos;
40003c20: e2 24 e0 04 st %l1, [ %l3 + 4 ]
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
40003c24: b2 06 60 01 inc %i1
40003c28: 80 a7 00 19 cmp %i4, %i1
40003c2c: 18 bf ff dc bgu 40003b9c <rtems_bdpart_create+0x1a0>
40003c30: 83 2e 60 02 sll %i1, 2, %g1
pos += s;
p->end = pos;
}
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
40003c34: b8 07 3f ff add %i4, -1, %i4
40003c38: 83 2f 20 04 sll %i4, 4, %g1
40003c3c: b9 2f 20 06 sll %i4, 6, %i4
40003c40: 82 27 00 01 sub %i4, %g1, %g1
40003c44: b4 06 80 01 add %i2, %g1, %i2
40003c48: ec 26 a0 04 st %l6, [ %i2 + 4 ]
40003c4c: 81 c7 e0 08 ret
40003c50: 81 e8 00 00 restore
40003c54 <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
40003c54: 9d e3 bf 60 save %sp, -160, %sp
size_t i = 0;
printf(
40003c58: 11 10 00 99 sethi %hi(0x40026400), %o0
40003c5c: 40 00 4d 83 call 40017268 <puts>
40003c60: 90 12 21 28 or %o0, 0x128, %o0 ! 40026528 <Callbacks.6428+0x178>
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40003c64: 80 a6 60 00 cmp %i1, 0
40003c68: 02 80 00 3a be 40003d50 <rtems_bdpart_dump+0xfc> <== NEVER TAKEN
40003c6c: 11 10 00 99 sethi %hi(0x40026400), %o0
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40003c70: 29 10 00 99 sethi %hi(0x40026400), %l4
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
40003c74: 37 10 00 99 sethi %hi(0x40026400), %i3
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40003c78: 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";
40003c7c: 2b 10 00 99 sethi %hi(0x40026400), %l5
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40003c80: a8 15 22 68 or %l4, 0x268, %l4
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
40003c84: 27 10 00 99 sethi %hi(0x40026400), %l3
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
40003c88: 25 10 00 99 sethi %hi(0x40026400), %l2
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
40003c8c: 23 10 00 99 sethi %hi(0x40026400), %l1
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
40003c90: 21 10 00 99 sethi %hi(0x40026400), %l0
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
40003c94: 35 10 00 99 sethi %hi(0x40026400), %i2
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
40003c98: 10 80 00 19 b 40003cfc <rtems_bdpart_dump+0xa8>
40003c9c: b6 16 e2 70 or %i3, 0x270, %i3
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
40003ca0: 80 a2 e0 0b cmp %o3, 0xb
40003ca4: 22 80 00 0e be,a 40003cdc <rtems_bdpart_dump+0x88> <== ALWAYS TAKEN
40003ca8: 96 15 61 10 or %l5, 0x110, %o3
40003cac: 18 80 00 2d bgu 40003d60 <rtems_bdpart_dump+0x10c> <== NOT EXECUTED
40003cb0: 80 a2 e0 0e cmp %o3, 0xe <== NOT EXECUTED
40003cb4: 80 a2 e0 01 cmp %o3, 1 <== NOT EXECUTED
40003cb8: 02 80 00 36 be 40003d90 <rtems_bdpart_dump+0x13c> <== NOT EXECUTED
40003cbc: 80 a2 e0 04 cmp %o3, 4 <== NOT EXECUTED
40003cc0: 22 80 00 07 be,a 40003cdc <rtems_bdpart_dump+0x88> <== NOT EXECUTED
40003cc4: 96 16 a0 e8 or %i2, 0xe8, %o3 <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40003cc8: 90 07 bf c8 add %fp, -56, %o0 <== NOT EXECUTED
40003ccc: 92 10 20 34 mov 0x34, %o1 <== NOT EXECUTED
40003cd0: 40 00 4d a0 call 40017350 <snprintf> <== NOT EXECUTED
40003cd4: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
type = type_buffer;
40003cd8: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
40003cdc: d2 06 00 00 ld [ %i0 ], %o1
40003ce0: d4 06 20 04 ld [ %i0 + 4 ], %o2
40003ce4: 40 00 4d 2b call 40017190 <printf>
40003ce8: 90 10 00 1b mov %i3, %o0
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40003cec: ba 07 60 01 inc %i5
40003cf0: 80 a7 40 19 cmp %i5, %i1
40003cf4: 02 80 00 16 be 40003d4c <rtems_bdpart_dump+0xf8>
40003cf8: b0 06 20 30 add %i0, 0x30, %i0
const rtems_bdpart_partition *p = pt + i;
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
40003cfc: c0 2f bf c7 clrb [ %fp + -57 ]
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
40003d00: b8 06 20 08 add %i0, 8, %i4
40003d04: 92 07 bf c7 add %fp, -57, %o1
40003d08: 40 00 00 8d call 40003f3c <rtems_bdpart_to_mbr_partition_type>
40003d0c: 90 10 00 1c mov %i4, %o0
40003d10: 80 8a 20 ff btst 0xff, %o0
40003d14: 12 bf ff e3 bne 40003ca0 <rtems_bdpart_dump+0x4c> <== ALWAYS TAKEN
40003d18: d6 0f bf c7 ldub [ %fp + -57 ], %o3
static void rtems_bdpart_type_to_string(
const uuid_t type,
char str [37]
)
{
uuid_unparse_lower( type, str);
40003d1c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40003d20: 40 00 2c d2 call 4000f068 <uuid_unparse_lower> <== NOT EXECUTED
40003d24: 92 07 bf c8 add %fp, -56, %o1 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
40003d28: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
40003d2c: d4 06 20 04 ld [ %i0 + 4 ], %o2 <== NOT EXECUTED
type = type_buffer;
break;
}
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
40003d30: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
}
printf(
40003d34: 40 00 4d 17 call 40017190 <printf> <== NOT EXECUTED
40003d38: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
40003d3c: ba 07 60 01 inc %i5 <== NOT EXECUTED
40003d40: 80 a7 40 19 cmp %i5, %i1 <== NOT EXECUTED
40003d44: 12 bf ff ee bne 40003cfc <rtems_bdpart_dump+0xa8> <== NOT EXECUTED
40003d48: b0 06 20 30 add %i0, 0x30, %i0 <== NOT EXECUTED
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
40003d4c: 11 10 00 99 sethi %hi(0x40026400), %o0
40003d50: 40 00 4d 46 call 40017268 <puts>
40003d54: 90 12 22 18 or %o0, 0x218, %o0 ! 40026618 <Callbacks.6428+0x268>
40003d58: 81 c7 e0 08 ret
40003d5c: 81 e8 00 00 restore
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
40003d60: 02 80 00 0a be 40003d88 <rtems_bdpart_dump+0x134> <== NOT EXECUTED
40003d64: 80 a2 e0 da cmp %o3, 0xda <== NOT EXECUTED
40003d68: 02 80 00 06 be 40003d80 <rtems_bdpart_dump+0x12c> <== NOT EXECUTED
40003d6c: 80 a2 e0 0c cmp %o3, 0xc <== NOT EXECUTED
40003d70: 12 bf ff d7 bne 40003ccc <rtems_bdpart_dump+0x78> <== NOT EXECUTED
40003d74: 90 07 bf c8 add %fp, -56, %o0 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
40003d78: 10 bf ff d9 b 40003cdc <rtems_bdpart_dump+0x88> <== NOT EXECUTED
40003d7c: 96 14 61 00 or %l1, 0x100, %o3 <== NOT EXECUTED
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
40003d80: 10 bf ff d7 b 40003cdc <rtems_bdpart_dump+0x88> <== NOT EXECUTED
40003d84: 96 14 a0 f8 or %l2, 0xf8, %o3 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
break;
40003d88: 10 bf ff d5 b 40003cdc <rtems_bdpart_dump+0x88> <== NOT EXECUTED
40003d8c: 96 14 e1 18 or %l3, 0x118, %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";
40003d90: 10 bf ff d3 b 40003cdc <rtems_bdpart_dump+0x88> <== NOT EXECUTED
40003d94: 96 14 20 f0 or %l0, 0xf0, %o3 <== NOT EXECUTED
40003f6c <rtems_bdpart_get_disk_data>:
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
40003f6c: 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);
40003f70: 92 10 20 02 mov 2, %o1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rv = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
40003f74: 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);
40003f78: 40 00 0d 2a call 40007420 <open>
40003f7c: 90 10 00 18 mov %i0, %o0
if (fd < 0) {
40003f80: ba 92 20 00 orcc %o0, 0, %i5
40003f84: 16 80 00 07 bge 40003fa0 <rtems_bdpart_get_disk_data+0x34><== ALWAYS TAKEN
40003f88: 94 07 bf fc add %fp, -4, %o2
sc = RTEMS_INVALID_NAME;
40003f8c: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
*fd_ptr = fd;
*dd_ptr = dd;
} else {
close( fd);
40003f90: 40 00 09 50 call 400064d0 <close> <== NOT EXECUTED
40003f94: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40003f98: 81 c7 e0 08 ret <== NOT EXECUTED
40003f9c: 81 e8 00 00 restore <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
40003fa0: 13 10 01 10 sethi %hi(0x40044000), %o1
40003fa4: 40 00 09 ed call 40006758 <ioctl>
40003fa8: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <__end+0x1b119>
goto error;
}
/* Get disk handle */
rv = rtems_disk_fd_get_disk_device( fd, &dd);
if (rv != 0) {
40003fac: 80 a2 20 00 cmp %o0, 0
40003fb0: 32 bf ff f8 bne,a 40003f90 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
40003fb4: 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;
40003fb8: c2 07 bf fc ld [ %fp + -4 ], %g1
*disk_end = dd->size;
40003fbc: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
sc = RTEMS_INVALID_NAME;
goto error;
}
/* Get disk begin, end and block size */
disk_begin = dd->start;
40003fc0: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
*disk_end = dd->size;
40003fc4: c4 26 c0 00 st %g2, [ %i3 ]
block_size = dd->block_size;
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
40003fc8: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
40003fcc: 80 a0 a1 ff cmp %g2, 0x1ff
40003fd0: 08 bf ff f0 bleu 40003f90 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
40003fd4: b0 10 20 1b mov 0x1b, %i0
sc = RTEMS_IO_ERROR;
goto error;
}
/* Check that we have do not have a logical disk */
if (disk_begin != 0) {
40003fd8: 80 a0 e0 00 cmp %g3, 0
40003fdc: 12 bf ff ed bne 40003f90 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
40003fe0: 80 a6 60 00 cmp %i1, 0
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
40003fe4: 02 80 00 08 be 40004004 <rtems_bdpart_get_disk_data+0x98>
40003fe8: 80 a6 a0 00 cmp %i2, 0
40003fec: 02 80 00 07 be 40004008 <rtems_bdpart_get_disk_data+0x9c> <== NEVER TAKEN
40003ff0: b0 10 20 00 clr %i0
*fd_ptr = fd;
40003ff4: fa 26 40 00 st %i5, [ %i1 ]
*dd_ptr = dd;
40003ff8: c2 26 80 00 st %g1, [ %i2 ]
40003ffc: 81 c7 e0 08 ret
40004000: 81 e8 00 00 restore
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
40004004: b0 10 20 00 clr %i0
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
*fd_ptr = fd;
*dd_ptr = dd;
} else {
close( fd);
40004008: 40 00 09 32 call 400064d0 <close>
4000400c: 90 10 00 1d mov %i5, %o0
40004010: 81 c7 e0 08 ret
40004014: 81 e8 00 00 restore
40025100 <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
40025100: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
40025104: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
40025108: 40 00 7d 89 call 4004472c <strrchr> <== NOT EXECUTED
4002510c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40025110: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
char *logical_disk_name = NULL;
char *logical_disk_marker = NULL;
char *mount_point = NULL;
char *mount_marker = NULL;
size_t disk_file_name_size = 0;
size_t disk_name_size = strlen( disk_name);
40025114: 40 00 79 63 call 400436a0 <strlen> <== NOT EXECUTED
40025118: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4002511c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
40025120: 40 00 79 60 call 400436a0 <strlen> <== NOT EXECUTED
40025124: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
40025128: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
char *logical_disk_marker = NULL;
char *mount_point = NULL;
char *mount_marker = NULL;
size_t disk_file_name_size = 0;
size_t disk_name_size = strlen( disk_name);
size_t mount_base_size = strlen( mount_base);
4002512c: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
40025130: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED
size_t disk_name_size = strlen( disk_name);
size_t mount_base_size = strlen( mount_base);
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
40025134: 7f ff 7b e9 call 400040d8 <malloc> <== NOT EXECUTED
40025138: 90 04 20 04 add %l0, 4, %o0 <== NOT EXECUTED
if (logical_disk_name == NULL) {
4002513c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40025140: 02 80 00 4f be 4002527c <rtems_bdpart_mount+0x17c> <== NOT EXECUTED
40025144: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
40025148: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4002514c: 40 00 7a 11 call 40043990 <strncpy> <== NOT EXECUTED
40025150: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
40025154: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40025158: 02 80 00 06 be 40025170 <rtems_bdpart_mount+0x70> <== NOT EXECUTED
4002515c: a6 10 00 10 mov %l0, %l3 <== NOT EXECUTED
disk_file_name += 1;
40025160: ba 07 20 01 add %i4, 1, %i5 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
40025164: 40 00 79 4f call 400436a0 <strlen> <== NOT EXECUTED
40025168: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4002516c: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
40025170: a4 04 c0 11 add %l3, %l1, %l2 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
40025174: 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);
40025178: 7f ff 7b d8 call 400040d8 <malloc> <== NOT EXECUTED
4002517c: 90 04 a0 05 add %l2, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
40025180: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40025184: 02 80 00 3a be 4002526c <rtems_bdpart_mount+0x16c> <== NOT EXECUTED
40025188: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
4002518c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40025190: 40 00 7a 00 call 40043990 <strncpy> <== NOT EXECUTED
40025194: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
40025198: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
4002519c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400251a0: 90 04 60 01 add %l1, 1, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
400251a4: c2 2f 00 11 stb %g1, [ %i4 + %l1 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
400251a8: 90 07 00 08 add %i4, %o0, %o0 <== NOT EXECUTED
400251ac: 40 00 79 f9 call 40043990 <strncpy> <== NOT EXECUTED
400251b0: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
400251b4: b0 04 a0 01 add %l2, 1, %i0 <== NOT EXECUTED
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
400251b8: b6 06 40 10 add %i1, %l0, %i3 <== NOT EXECUTED
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
400251bc: ba 10 20 00 clr %i5 <== NOT EXECUTED
400251c0: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
400251c4: 02 80 00 29 be 40025268 <rtems_bdpart_mount+0x168> <== NOT EXECUTED
400251c8: b0 07 00 18 add %i4, %i0, %i0 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
400251cc: 21 10 01 86 sethi %hi(0x40061800), %l0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
400251d0: 23 10 01 7e sethi %hi(0x4005f800), %l1 <== NOT EXECUTED
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
400251d4: a0 14 21 08 or %l0, 0x108, %l0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
400251d8: 10 80 00 04 b 400251e8 <rtems_bdpart_mount+0xe8> <== NOT EXECUTED
400251dc: a2 14 62 20 or %l1, 0x220, %l1 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
400251e0: 22 80 00 23 be,a 4002526c <rtems_bdpart_mount+0x16c> <== NOT EXECUTED
400251e4: b0 10 20 00 clr %i0 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
400251e8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400251ec: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
400251f0: ba 07 60 01 inc %i5 <== NOT EXECUTED
400251f4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
400251f8: 40 00 75 b2 call 400428c0 <snprintf> <== NOT EXECUTED
400251fc: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
40025200: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
40025204: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
40025208: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
4002520c: 14 80 00 1e bg 40025284 <rtems_bdpart_mount+0x184> <== NOT EXECUTED
40025210: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
40025214: 40 00 79 df call 40043990 <strncpy> <== NOT EXECUTED
40025218: 01 00 00 00 nop <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
4002521c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40025220: 40 00 0f e7 call 400291bc <rtems_mkdir> <== NOT EXECUTED
40025224: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED
if (rv != 0) {
40025228: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4002522c: 12 80 00 1c bne 4002529c <rtems_bdpart_mount+0x19c> <== NOT EXECUTED
40025230: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
40025234: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
40025238: 96 10 20 00 clr %o3 <== NOT EXECUTED
4002523c: 98 10 20 00 clr %o4 <== NOT EXECUTED
40025240: 7f ff 7c 2c call 400042f0 <mount> <== NOT EXECUTED
40025244: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
40025248: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4002524c: 02 bf ff e5 be 400251e0 <rtems_bdpart_mount+0xe0> <== NOT EXECUTED
40025250: 80 a7 40 1a cmp %i5, %i2 <== NOT EXECUTED
rmdir( mount_point);
40025254: 40 00 0f ae call 4002910c <rmdir> <== NOT EXECUTED
40025258: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
4002525c: 80 a7 40 1a cmp %i5, %i2 <== NOT EXECUTED
40025260: 12 bf ff e3 bne 400251ec <rtems_bdpart_mount+0xec> <== NOT EXECUTED
40025264: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
40025268: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
4002526c: 7f ff 7a c1 call 40003d70 <free> <== NOT EXECUTED
40025270: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
free( mount_point);
40025274: 7f ff 7a bf call 40003d70 <free> <== NOT EXECUTED
40025278: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return esc;
}
4002527c: 81 c7 e0 08 ret <== NOT EXECUTED
40025280: 81 e8 00 00 restore <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
40025284: 7f ff 7a bb call 40003d70 <free> <== NOT EXECUTED
40025288: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
esc = RTEMS_INVALID_NAME;
4002528c: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
}
cleanup:
free( logical_disk_name);
free( mount_point);
40025290: 7f ff 7a b8 call 40003d70 <free> <== NOT EXECUTED
40025294: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40025298: 30 bf ff f9 b,a 4002527c <rtems_bdpart_mount+0x17c> <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
4002529c: 7f ff 7a b5 call 40003d70 <free> <== NOT EXECUTED
400252a0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv != 0) {
esc = RTEMS_IO_ERROR;
400252a4: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
}
cleanup:
free( logical_disk_name);
free( mount_point);
400252a8: 7f ff 7a b2 call 40003d70 <free> <== NOT EXECUTED
400252ac: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
400252b0: 30 bf ff f3 b,a 4002527c <rtems_bdpart_mount+0x17c> <== NOT EXECUTED
4000448c <rtems_bdpart_new_record>:
static rtems_status_code rtems_bdpart_new_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
4000448c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
40004490: d0 06 80 00 ld [ %i2 ], %o0
40004494: 80 a2 20 00 cmp %o0, 0
40004498: 22 80 00 07 be,a 400044b4 <rtems_bdpart_new_record+0x28>
4000449c: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_sync( *block);
400044a0: 40 00 34 2c call 40011550 <rtems_bdbuf_sync>
400044a4: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
400044a8: ba 92 20 00 orcc %o0, 0, %i5
400044ac: 12 80 00 17 bne 40004508 <rtems_bdpart_new_record+0x7c> <== NEVER TAKEN
400044b0: 90 10 00 18 mov %i0, %o0
return sc;
}
}
/* Read the new record block (this accounts for disk block sizes > 512) */
sc = rtems_bdbuf_read( dd, index, block);
400044b4: 92 10 00 19 mov %i1, %o1
400044b8: 40 00 33 49 call 400111dc <rtems_bdbuf_read>
400044bc: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
400044c0: ba 92 20 00 orcc %o0, 0, %i5
400044c4: 12 80 00 11 bne 40004508 <rtems_bdpart_new_record+0x7c> <== NEVER TAKEN
400044c8: 01 00 00 00 nop
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
400044cc: c2 06 80 00 ld [ %i2 ], %g1
400044d0: 80 a0 60 00 cmp %g1, 0
400044d4: 02 80 00 0f be 40004510 <rtems_bdpart_new_record+0x84> <== NEVER TAKEN
400044d8: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
}
/* Clear record */
memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);
400044dc: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
400044e0: 40 00 4a d9 call 40017044 <memset>
400044e4: 94 10 22 00 mov 0x200, %o2
/* Write signature */
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =
400044e8: c2 06 80 00 ld [ %i2 ], %g1
400044ec: 84 10 20 55 mov 0x55, %g2
400044f0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
400044f4: c4 28 61 fe stb %g2, [ %g1 + 0x1fe ]
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
400044f8: c2 06 80 00 ld [ %i2 ], %g1
400044fc: 84 10 3f aa mov -86, %g2
40004500: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40004504: c4 28 61 ff stb %g2, [ %g1 + 0x1ff ]
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
40004508: 81 c7 e0 08 ret
4000450c: 91 e8 00 1d restore %g0, %i5, %o0
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
return RTEMS_INVALID_ADDRESS;
40004510: 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;
}
40004514: 81 c7 e0 08 ret <== NOT EXECUTED
40004518: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
40004018 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
40004018: 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;
4000401c: 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;
40004020: c0 27 bf e8 clr [ %fp + -24 ]
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
40004024: 80 a6 e0 00 cmp %i3, 0
40004028: 02 80 00 0a be 40004050 <rtems_bdpart_read+0x38> <== NEVER TAKEN
4000402c: c2 27 bf ec st %g1, [ %fp + -20 ]
rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
40004030: 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 */
40004034: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
40004038: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
4000403c: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
40004040: c0 27 bf fc clr [ %fp + -4 ]
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
40004044: 80 a6 a0 00 cmp %i2, 0
40004048: 12 80 00 04 bne 40004058 <rtems_bdpart_read+0x40> <== ALWAYS TAKEN
4000404c: fa 06 c0 00 ld [ %i3 ], %i5
return RTEMS_INVALID_ADDRESS;
40004050: 81 c7 e0 08 ret <== NOT EXECUTED
40004054: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
const uint8_t *data = NULL;
int fd = -1;
rtems_disk_device *dd = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
40004058: 80 a6 60 00 cmp %i1, 0
4000405c: 02 bf ff fd be 40004050 <rtems_bdpart_read+0x38> <== NEVER TAKEN
40004060: 90 10 00 18 mov %i0, %o0
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
40004064: c0 26 c0 00 clr [ %i3 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
40004068: 92 07 bf f8 add %fp, -8, %o1
4000406c: 94 07 bf fc add %fp, -4, %o2
40004070: 7f ff ff bf call 40003f6c <rtems_bdpart_get_disk_data>
40004074: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
40004078: b0 92 20 00 orcc %o0, 0, %i0
4000407c: 12 80 00 14 bne 400040cc <rtems_bdpart_read+0xb4> <== NEVER TAKEN
40004080: d0 07 bf fc ld [ %fp + -4 ], %o0
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( dd, 0, &block);
40004084: 92 10 20 00 clr %o1
40004088: 7f ff ff 44 call 40003d98 <rtems_bdpart_read_record>
4000408c: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
40004090: b0 92 20 00 orcc %o0, 0, %i0
40004094: 02 80 00 10 be 400040d4 <rtems_bdpart_read+0xbc> <== ALWAYS TAKEN
40004098: c4 07 bf e8 ld [ %fp + -24 ], %g2
/* Return partition count */
*count = (size_t) (p - pt + 1);
cleanup:
if (fd >= 0) {
4000409c: d0 07 bf f8 ld [ %fp + -8 ], %o0
400040a0: 80 a2 20 00 cmp %o0, 0
400040a4: 26 80 00 05 bl,a 400040b8 <rtems_bdpart_read+0xa0> <== NEVER TAKEN
400040a8: d0 07 bf e8 ld [ %fp + -24 ], %o0 <== NOT EXECUTED
close( fd);
400040ac: 40 00 09 09 call 400064d0 <close>
400040b0: 01 00 00 00 nop
}
if (block != NULL) {
400040b4: d0 07 bf e8 ld [ %fp + -24 ], %o0
400040b8: 80 a2 20 00 cmp %o0, 0
400040bc: 02 80 00 04 be 400040cc <rtems_bdpart_read+0xb4> <== NEVER TAKEN
400040c0: 01 00 00 00 nop
rtems_bdbuf_release( block);
400040c4: 40 00 34 cb call 400113f0 <rtems_bdbuf_release>
400040c8: 01 00 00 00 nop
}
return esc;
}
400040cc: 81 c7 e0 08 ret
400040d0: 81 e8 00 00 restore
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
400040d4: 83 2f 60 04 sll %i5, 4, %g1
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
400040d8: e2 00 a0 1c ld [ %g2 + 0x1c ], %l1
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
400040dc: b9 2f 60 06 sll %i5, 6, %i4
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
400040e0: a0 04 61 be add %l1, 0x1be, %l0
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
400040e4: b8 27 00 01 sub %i4, %g1, %i4
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
400040e8: 90 10 00 10 mov %l0, %o0
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
400040ec: b8 06 80 1c add %i2, %i4, %i4
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
400040f0: 92 07 bf ec add %fp, -20, %o1
400040f4: 94 10 00 1c mov %i4, %o2
400040f8: 7f ff ff 54 call 40003e48 <rtems_bdpart_read_mbr_partition>
400040fc: 96 07 bf f0 add %fp, -16, %o3
if (sc != RTEMS_SUCCESSFUL) {
40004100: b0 92 20 00 orcc %o0, 0, %i0
40004104: 32 bf ff e7 bne,a 400040a0 <rtems_bdpart_read+0x88> <== NEVER TAKEN
40004108: 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) {
4000410c: c2 07 bf ec ld [ %fp + -20 ], %g1
40004110: c2 08 60 08 ldub [ %g1 + 8 ], %g1
40004114: 80 a0 60 ee cmp %g1, 0xee
40004118: 02 bf ff e1 be 4000409c <rtems_bdpart_read+0x84> <== NEVER TAKEN
4000411c: 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
40004120: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
40004124: c0 26 40 00 clr [ %i1 ]
format->mbr.disk_id = rtems_uint32_from_little_endian(
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
40004128: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
return value;
}
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
4000412c: 84 10 20 00 clr %g2
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
40004130: 82 01 21 bb add %g4, 0x1bb, %g1
40004134: 88 01 21 b7 add %g4, 0x1b7, %g4
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
value = (value << 8) + data [i];
40004138: c6 08 40 00 ldub [ %g1 ], %g3
4000413c: 85 28 a0 08 sll %g2, 8, %g2
40004140: 82 00 7f ff add %g1, -1, %g1
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
40004144: 80 a0 40 04 cmp %g1, %g4
40004148: 12 bf ff fc bne 40004138 <rtems_bdpart_read+0x120>
4000414c: 84 00 c0 02 add %g3, %g2, %g2
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
40004150: 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(
40004154: c4 26 60 04 st %g2, [ %i1 + 4 ]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
40004158: c2 2e 60 08 stb %g1, [ %i1 + 8 ]
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
4000415c: a2 04 61 ee add %l1, 0x1ee, %l1
);
format->mbr.dos_compatibility = true;
/* Iterate through the rest of the primary partition table */
for (i = 1; i < 4; ++i) {
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
40004160: a0 04 20 10 add %l0, 0x10, %l0
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40004164: 92 07 bf ec add %fp, -20, %o1
40004168: 90 10 00 10 mov %l0, %o0
4000416c: 94 10 00 1c mov %i4, %o2
40004170: 7f ff ff 36 call 40003e48 <rtems_bdpart_read_mbr_partition>
40004174: 96 07 bf f0 add %fp, -16, %o3
if (sc != RTEMS_SUCCESSFUL) {
40004178: 80 a2 20 00 cmp %o0, 0
4000417c: 12 80 00 4a bne 400042a4 <rtems_bdpart_read+0x28c> <== NEVER TAKEN
40004180: 80 a4 00 11 cmp %l0, %l1
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
/* Iterate through the rest of the primary partition table */
for (i = 1; i < 4; ++i) {
40004184: 32 bf ff f8 bne,a 40004164 <rtems_bdpart_read+0x14c>
40004188: a0 04 20 10 add %l0, 0x10, %l0
goto cleanup;
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
4000418c: fa 07 bf f0 ld [ %fp + -16 ], %i5
while (ebr != 0) {
40004190: 80 a7 60 00 cmp %i5, 0
40004194: 02 80 00 2c be 40004244 <rtems_bdpart_read+0x22c> <== NEVER TAKEN
40004198: c8 07 bf ec ld [ %fp + -20 ], %g4
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( dd, ebr, &block);
4000419c: d0 07 bf fc ld [ %fp + -4 ], %o0
400041a0: 92 10 00 1d mov %i5, %o1
400041a4: 7f ff fe fd call 40003d98 <rtems_bdpart_read_record>
400041a8: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
400041ac: 80 a2 20 00 cmp %o0, 0
400041b0: 12 80 00 3d bne 400042a4 <rtems_bdpart_read+0x28c> <== NEVER TAKEN
400041b4: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
400041b8: 92 07 bf ec add %fp, -20, %o1
400041bc: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
400041c0: 94 10 00 1c mov %i4, %o2
400041c4: 90 02 21 be add %o0, 0x1be, %o0
400041c8: 7f ff ff 20 call 40003e48 <rtems_bdpart_read_mbr_partition>
400041cc: 96 10 20 00 clr %o3
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
400041d0: 80 a2 20 00 cmp %o0, 0
400041d4: 12 80 00 34 bne 400042a4 <rtems_bdpart_read+0x28c> <== NEVER TAKEN
400041d8: c8 07 bf ec ld [ %fp + -20 ], %g4
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
400041dc: c2 01 00 00 ld [ %g4 ], %g1
400041e0: 84 07 40 01 add %i5, %g1, %g2
if (tmp > p->begin) {
400041e4: 80 a0 40 02 cmp %g1, %g2
400041e8: 3a bf ff ad bcc,a 4000409c <rtems_bdpart_read+0x84> <== NEVER TAKEN
400041ec: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
400041f0: c2 01 20 04 ld [ %g4 + 4 ], %g1
400041f4: ba 07 40 01 add %i5, %g1, %i5
if (tmp > p->end) {
400041f8: 80 a0 40 1d cmp %g1, %i5
400041fc: 1a 80 00 28 bcc 4000429c <rtems_bdpart_read+0x284> <== NEVER TAKEN
40004200: c4 21 00 00 st %g2, [ %g4 ]
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
40004204: c2 07 bf e8 ld [ %fp + -24 ], %g1
}
/* Adjust partition end */
tmp = p->end + ebr;
if (tmp > p->end) {
p->end = tmp;
40004208: fa 21 20 04 st %i5, [ %g4 + 4 ]
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
4000420c: f2 00 60 1c ld [ %g1 + 0x1c ], %i1
return value;
}
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
40004210: 84 10 20 00 clr %g2
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
40004214: 82 10 20 03 mov 3, %g1
}
static rtems_blkdev_bnum rtems_bdpart_next_ebr( const uint8_t *data)
{
rtems_blkdev_bnum begin =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
40004218: ba 06 61 d6 add %i1, 0x1d6, %i5
value = (value << 8) + data [i];
4000421c: c6 0f 40 01 ldub [ %i5 + %g1 ], %g3
40004220: 85 28 a0 08 sll %g2, 8, %g2
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
40004224: 82 00 7f ff add %g1, -1, %g1
40004228: 80 a0 7f ff cmp %g1, -1
4000422c: 12 bf ff fc bne 4000421c <rtems_bdpart_read+0x204>
40004230: 84 00 c0 02 add %g3, %g2, %g2
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EXTENDED) {
40004234: c2 0e 61 d2 ldub [ %i1 + 0x1d2 ], %g1
40004238: 80 a0 60 05 cmp %g1, 5
4000423c: 02 80 00 11 be 40004280 <rtems_bdpart_read+0x268>
40004240: 80 a0 a0 00 cmp %g2, 0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
40004244: 82 21 00 1a sub %g4, %i2, %g1
40004248: 83 38 60 04 sra %g1, 4, %g1
4000424c: 85 28 60 02 sll %g1, 2, %g2
40004250: 82 00 80 01 add %g2, %g1, %g1
40004254: 85 28 60 04 sll %g1, 4, %g2
40004258: 82 00 40 02 add %g1, %g2, %g1
4000425c: 85 28 60 08 sll %g1, 8, %g2
rtems_bdpart_partition *pt,
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
40004260: b0 10 20 00 clr %i0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
40004264: 82 00 40 02 add %g1, %g2, %g1
40004268: 85 28 60 10 sll %g1, 0x10, %g2
4000426c: 82 00 40 02 add %g1, %g2, %g1
40004270: 82 20 00 01 neg %g1
40004274: 82 00 60 01 inc %g1
40004278: 10 bf ff 89 b 4000409c <rtems_bdpart_read+0x84>
4000427c: c2 26 c0 00 st %g1, [ %i3 ]
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
);
if (ebr != 0) {
40004280: 02 bf ff f2 be 40004248 <rtems_bdpart_read+0x230> <== NEVER TAKEN
40004284: 82 21 00 1a sub %g4, %i2, %g1
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
40004288: fa 07 bf f0 ld [ %fp + -16 ], %i5
4000428c: ba 00 80 1d add %g2, %i5, %i5
if (tmp > ebr) {
40004290: 80 a7 40 02 cmp %i5, %g2
40004294: 18 bf ff c3 bgu 400041a0 <rtems_bdpart_read+0x188> <== ALWAYS TAKEN
40004298: d0 07 bf fc ld [ %fp + -4 ], %o0
/* Adjust partition begin */
tmp = p->begin + ebr;
if (tmp > p->begin) {
p->begin = tmp;
} else {
esc = RTEMS_IO_ERROR;
4000429c: 10 bf ff 80 b 4000409c <rtems_bdpart_read+0x84> <== NOT EXECUTED
400042a0: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
400042a4: 10 bf ff 7e b 4000409c <rtems_bdpart_read+0x84> <== NOT EXECUTED
400042a8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
40003e48 <rtems_bdpart_read_mbr_partition>:
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
40003e48: 9d e3 bf a0 save %sp, -96, %sp
return value;
}
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
40003e4c: ba 10 20 00 clr %i5
} else {
return 0;
}
}
static rtems_status_code rtems_bdpart_read_mbr_partition(
40003e50: 88 06 20 0b add %i0, 0xb, %g4
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
40003e54: b8 10 00 18 mov %i0, %i4
} else {
return 0;
}
}
static rtems_status_code rtems_bdpart_read_mbr_partition(
40003e58: 82 10 00 04 mov %g4, %g1
40003e5c: 86 06 20 07 add %i0, 7, %g3
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
value = (value << 8) + data [i];
40003e60: c4 08 40 00 ldub [ %g1 ], %g2
40003e64: bb 2f 60 08 sll %i5, 8, %i5
40003e68: 82 00 7f ff add %g1, -1, %g1
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
40003e6c: 80 a0 40 03 cmp %g1, %g3
40003e70: 12 bf ff fc bne 40003e60 <rtems_bdpart_read_mbr_partition+0x18>
40003e74: ba 00 80 1d add %g2, %i5, %i5
40003e78: 82 07 20 0f add %i4, 0xf, %g1
return value;
}
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
40003e7c: 84 10 20 00 clr %g2
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
value = (value << 8) + data [i];
40003e80: c6 08 40 00 ldub [ %g1 ], %g3
40003e84: 85 28 a0 08 sll %g2, 8, %g2
40003e88: 82 00 7f ff add %g1, -1, %g1
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
40003e8c: 80 a0 40 04 cmp %g1, %g4
40003e90: 12 bf ff fc bne 40003e80 <rtems_bdpart_read_mbr_partition+0x38>
40003e94: 84 00 c0 02 add %g3, %g2, %g2
rtems_blkdev_bnum size =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EMPTY) {
40003e98: e0 0f 20 04 ldub [ %i4 + 4 ], %l0
40003e9c: 80 a4 20 00 cmp %l0, 0
40003ea0: 02 80 00 0a be 40003ec8 <rtems_bdpart_read_mbr_partition+0x80><== NEVER TAKEN
40003ea4: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
40003ea8: c2 06 40 00 ld [ %i1 ], %g1
40003eac: 80 a0 40 1a cmp %g1, %i2
40003eb0: 02 80 00 06 be 40003ec8 <rtems_bdpart_read_mbr_partition+0x80><== NEVER TAKEN
40003eb4: b0 10 20 05 mov 5, %i0
{
rtems_blkdev_bnum begin =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
40003eb8: b4 00 80 1d add %g2, %i5, %i2
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
40003ebc: 80 a6 80 1d cmp %i2, %i5
40003ec0: 18 80 00 04 bgu 40003ed0 <rtems_bdpart_read_mbr_partition+0x88><== ALWAYS TAKEN
40003ec4: b0 10 20 1b mov 0x1b, %i0
rtems_bdpart_to_partition_type( type, (*p)->type);
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
}
return RTEMS_SUCCESSFUL;
}
40003ec8: 81 c7 e0 08 ret <== NOT EXECUTED
40003ecc: 81 e8 00 00 restore <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
40003ed0: 80 a4 20 05 cmp %l0, 5
40003ed4: 12 80 00 08 bne 40003ef4 <rtems_bdpart_read_mbr_partition+0xac>
40003ed8: 90 00 60 30 add %g1, 0x30, %o0
if (ep_begin != NULL) {
40003edc: 80 a6 e0 00 cmp %i3, 0
40003ee0: 02 80 00 15 be 40003f34 <rtems_bdpart_read_mbr_partition+0xec><== NEVER TAKEN
40003ee4: 01 00 00 00 nop
*ep_begin = begin;
40003ee8: fa 26 c0 00 st %i5, [ %i3 ]
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
}
return RTEMS_SUCCESSFUL;
40003eec: 81 c7 e0 08 ret
40003ef0: 91 e8 20 00 restore %g0, 0, %o0
} else {
/* Increment partition index */
++(*p);
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
40003ef4: 94 10 20 30 mov 0x30, %o2
40003ef8: 92 10 20 00 clr %o1
40003efc: 40 00 4c 52 call 40017044 <memset>
40003f00: d0 26 40 00 st %o0, [ %i1 ]
/* Set values */
(*p)->begin = begin;
40003f04: d2 06 40 00 ld [ %i1 ], %o1
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
40003f08: 90 10 00 10 mov %l0, %o0
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
/* Set values */
(*p)->begin = begin;
40003f0c: fa 22 40 00 st %i5, [ %o1 ]
(*p)->end = end;
40003f10: f4 22 60 04 st %i2, [ %o1 + 4 ]
rtems_bdpart_to_partition_type( type, (*p)->type);
40003f14: 7f ff ff c4 call 40003e24 <rtems_bdpart_to_partition_type>
40003f18: 92 02 60 08 add %o1, 8, %o1
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
40003f1c: c2 06 40 00 ld [ %i1 ], %g1
40003f20: c4 0f 00 00 ldub [ %i4 ], %g2
40003f24: c0 20 60 28 clr [ %g1 + 0x28 ]
40003f28: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
}
return RTEMS_SUCCESSFUL;
40003f2c: 81 c7 e0 08 ret
40003f30: 91 e8 20 00 restore %g0, 0, %o0
}
40003f34: 81 c7 e0 08 ret <== NOT EXECUTED
40003f38: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40003d98 <rtems_bdpart_read_record>:
static rtems_status_code rtems_bdpart_read_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
40003d98: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
40003d9c: d0 06 80 00 ld [ %i2 ], %o0
40003da0: 80 a2 20 00 cmp %o0, 0
40003da4: 22 80 00 08 be,a 40003dc4 <rtems_bdpart_read_record+0x2c>
40003da8: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release( *block);
40003dac: 40 00 35 91 call 400113f0 <rtems_bdbuf_release>
40003db0: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40003db4: 80 a2 20 00 cmp %o0, 0
40003db8: 12 80 00 13 bne 40003e04 <rtems_bdpart_read_record+0x6c> <== NEVER TAKEN
40003dbc: 01 00 00 00 nop
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( dd, index, block);
40003dc0: 90 10 00 18 mov %i0, %o0
40003dc4: 92 10 00 19 mov %i1, %o1
40003dc8: 40 00 35 05 call 400111dc <rtems_bdbuf_read>
40003dcc: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
40003dd0: 80 a2 20 00 cmp %o0, 0
40003dd4: 12 80 00 0c bne 40003e04 <rtems_bdpart_read_record+0x6c> <== NEVER TAKEN
40003dd8: 01 00 00 00 nop
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
40003ddc: c2 06 80 00 ld [ %i2 ], %g1
40003de0: 80 a0 60 00 cmp %g1, 0
40003de4: 22 80 00 0e be,a 40003e1c <rtems_bdpart_read_record+0x84><== NEVER TAKEN
40003de8: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
40003dec: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
static bool rtems_bdpart_is_valid_record( const uint8_t *data)
{
return data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0]
== RTEMS_BDPART_MBR_SIGNATURE_0
&& data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1]
40003df0: c4 08 61 fe ldub [ %g1 + 0x1fe ], %g2
40003df4: 80 a0 a0 55 cmp %g2, 0x55
40003df8: 22 80 00 05 be,a 40003e0c <rtems_bdpart_read_record+0x74><== ALWAYS TAKEN
40003dfc: c2 08 61 ff ldub [ %g1 + 0x1ff ], %g1
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
40003e00: 90 10 20 1b mov 0x1b, %o0 <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
40003e04: 81 c7 e0 08 ret
40003e08: 91 e8 00 08 restore %g0, %o0, %o0
static bool rtems_bdpart_is_valid_record( const uint8_t *data)
{
return data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0]
== RTEMS_BDPART_MBR_SIGNATURE_0
&& data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1]
40003e0c: 80 a0 60 aa cmp %g1, 0xaa
40003e10: 32 bf ff fd bne,a 40003e04 <rtems_bdpart_read_record+0x6c><== NEVER TAKEN
40003e14: 90 10 20 1b mov 0x1b, %o0 <== NOT EXECUTED
40003e18: 30 bf ff fb b,a 40003e04 <rtems_bdpart_read_record+0x6c>
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
40003e1c: 81 c7 e0 08 ret <== NOT EXECUTED
40003e20: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
400042ac <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
400042ac: 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);
400042b0: 90 10 00 18 mov %i0, %o0
400042b4: 40 00 4d 16 call 4001770c <strlen>
400042b8: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
int fd = -1;
400042bc: 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
)
{
400042c0: 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);
400042c4: a4 10 00 08 mov %o0, %l2
size_t i = 0;
int fd = -1;
400042c8: 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);
400042cc: 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;
400042d0: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
400042d4: 92 07 bf f8 add %fp, -8, %o1
400042d8: 94 07 bf fc add %fp, -4, %o2
400042dc: 7f ff ff 24 call 40003f6c <rtems_bdpart_get_disk_data>
400042e0: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
400042e4: b0 92 20 00 orcc %o0, 0, %i0
400042e8: 12 80 00 32 bne 400043b0 <rtems_bdpart_register+0x104> <== NEVER TAKEN
400042ec: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
400042f0: 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;
400042f4: e2 00 60 04 ld [ %g1 + 4 ], %l1
400042f8: 40 00 08 76 call 400064d0 <close>
400042fc: f6 00 40 00 ld [ %g1 ], %i3
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
40004300: 90 04 a0 04 add %l2, 4, %o0
40004304: 40 00 0a 32 call 40006bcc <malloc>
40004308: b8 10 00 11 mov %l1, %i4
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
4000430c: b0 10 20 1a mov 0x1a, %i0
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
40004310: 80 a2 20 00 cmp %o0, 0
40004314: 02 80 00 27 be 400043b0 <rtems_bdpart_register+0x104> <== NEVER TAKEN
40004318: a0 10 00 08 mov %o0, %l0
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
4000431c: 92 10 00 1d mov %i5, %o1
40004320: 40 00 4d 83 call 4001792c <strncpy>
40004324: 94 10 00 12 mov %l2, %o2
/* Create a new device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Set partition number for logical disk name */
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40004328: 31 10 00 99 sethi %hi(0x40026400), %i0
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
4000432c: a4 04 00 12 add %l0, %l2, %l2
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
40004330: ba 10 20 00 clr %i5
40004334: 80 a6 a0 00 cmp %i2, 0
40004338: 12 80 00 06 bne 40004350 <rtems_bdpart_register+0xa4> <== ALWAYS TAKEN
4000433c: b0 16 22 98 or %i0, 0x298, %i0
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
40004340: 10 80 00 1a b 400043a8 <rtems_bdpart_register+0xfc> <== NOT EXECUTED
40004344: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
40004348: 02 80 00 1c be 400043b8 <rtems_bdpart_register+0x10c>
4000434c: b2 06 60 30 add %i1, 0x30, %i1
/* Create a new device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Set partition number for logical disk name */
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40004350: 92 10 20 04 mov 4, %o1
40004354: 94 10 00 18 mov %i0, %o2
40004358: ba 07 60 01 inc %i5
4000435c: 90 10 00 12 mov %l2, %o0
40004360: 40 00 4b fc call 40017350 <snprintf>
40004364: 96 10 00 1d mov %i5, %o3
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
int rv = 0;
/* New minor number */
++minor;
40004368: b8 07 20 01 inc %i4
/* Create a new device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Set partition number for logical disk name */
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
4000436c: 80 a2 20 03 cmp %o0, 3
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
40004370: 92 10 00 1c mov %i4, %o1
40004374: 94 10 00 1b mov %i3, %o2
40004378: 96 10 00 11 mov %l1, %o3
/* Create a new device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Set partition number for logical disk name */
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
4000437c: 14 80 00 11 bg 400043c0 <rtems_bdpart_register+0x114> <== NEVER TAKEN
40004380: 90 10 00 1b mov %i3, %o0
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
40004384: da 06 60 04 ld [ %i1 + 4 ], %o5
logical_disk,
disk,
p->begin,
p->end - p->begin,
40004388: d8 06 40 00 ld [ %i1 ], %o4
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
4000438c: e0 23 a0 5c st %l0, [ %sp + 0x5c ]
40004390: 40 00 03 7d call 40005184 <rtems_disk_create_log>
40004394: 9a 23 40 0c sub %o5, %o4, %o5
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
40004398: 80 a2 20 00 cmp %o0, 0
4000439c: 02 bf ff eb be 40004348 <rtems_bdpart_register+0x9c> <== ALWAYS TAKEN
400043a0: 80 a7 40 1a cmp %i5, %i2
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
400043a4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
400043a8: 40 00 08 6c call 40006558 <free>
400043ac: 90 10 00 10 mov %l0, %o0
return esc;
}
400043b0: 81 c7 e0 08 ret
400043b4: 81 e8 00 00 restore
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
400043b8: 10 bf ff fc b 400043a8 <rtems_bdpart_register+0xfc>
400043bc: b0 10 20 00 clr %i0
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Set partition number for logical disk name */
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
esc = RTEMS_INVALID_NAME;
400043c0: 10 bf ff fa b 400043a8 <rtems_bdpart_register+0xfc> <== NOT EXECUTED
400043c4: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
400043c8 <rtems_bdpart_register_from_disk>:
return esc;
}
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
400043c8: 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;
400043cc: 82 10 20 10 mov 0x10, %g1
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
400043d0: 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;
400043d4: c2 27 bc e8 st %g1, [ %fp + -792 ]
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
400043d8: 92 07 bc ec add %fp, -788, %o1
400043dc: 94 07 bd 00 add %fp, -768, %o2
400043e0: 7f ff ff 0e call 40004018 <rtems_bdpart_read>
400043e4: 96 07 bc e8 add %fp, -792, %o3
if (sc != RTEMS_SUCCESSFUL) {
400043e8: 80 a2 20 00 cmp %o0, 0
400043ec: 12 80 00 05 bne 40004400 <rtems_bdpart_register_from_disk+0x38><== NEVER TAKEN
400043f0: d4 07 bc e8 ld [ %fp + -792 ], %o2
return sc;
}
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
400043f4: 90 10 00 18 mov %i0, %o0
400043f8: 7f ff ff ad call 400042ac <rtems_bdpart_register>
400043fc: 92 07 bd 00 add %fp, -768, %o1
}
40004400: 81 c7 e0 08 ret
40004404: 91 e8 00 08 restore %g0, %o0, %o0
400252b4 <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
400252b4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
400252b8: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
400252bc: 40 00 7d 1c call 4004472c <strrchr> <== NOT EXECUTED
400252c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400252c4: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
char *mount_point = NULL;
char *mount_marker = NULL;
size_t disk_file_name_size = 0;
size_t disk_name_size = strlen( disk_name);
400252c8: 40 00 78 f6 call 400436a0 <strlen> <== NOT EXECUTED
400252cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400252d0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
400252d4: 40 00 78 f3 call 400436a0 <strlen> <== NOT EXECUTED
400252d8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
400252dc: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
400252e0: 02 80 00 42 be 400253e8 <rtems_bdpart_unmount+0x134> <== NOT EXECUTED
400252e4: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
disk_file_name += 1;
400252e8: a2 07 20 01 add %i4, 1, %l1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
400252ec: 40 00 78 ed call 400436a0 <strlen> <== NOT EXECUTED
400252f0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
400252f4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
400252f8: b2 04 00 1d add %l0, %i5, %i1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
400252fc: 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);
40025300: 7f ff 7b 76 call 400040d8 <malloc> <== NOT EXECUTED
40025304: 90 06 60 05 add %i1, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
40025308: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4002530c: 02 80 00 2b be 400253b8 <rtems_bdpart_unmount+0x104> <== NOT EXECUTED
40025310: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
40025314: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40025318: 40 00 79 9e call 40043990 <strncpy> <== NOT EXECUTED
4002531c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
40025320: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40025324: 90 07 60 01 add %i5, 1, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
40025328: c2 2f 00 1d stb %g1, [ %i4 + %i5 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
4002532c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
40025330: 90 07 00 08 add %i4, %o0, %o0 <== NOT EXECUTED
40025334: 40 00 79 97 call 40043990 <strncpy> <== NOT EXECUTED
40025338: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
4002533c: b2 06 60 01 inc %i1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40025340: 37 10 01 86 sethi %hi(0x40061800), %i3 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
40025344: ba 10 20 00 clr %i5 <== NOT EXECUTED
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
40025348: b2 07 00 19 add %i4, %i1, %i1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
4002534c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40025350: 12 80 00 06 bne 40025368 <rtems_bdpart_unmount+0xb4> <== NOT EXECUTED
40025354: b6 16 e1 08 or %i3, 0x108, %i3 <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
40025358: 10 80 00 1c b 400253c8 <rtems_bdpart_unmount+0x114> <== NOT EXECUTED
4002535c: b0 10 20 00 clr %i0 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
40025360: 02 80 00 1a be 400253c8 <rtems_bdpart_unmount+0x114> <== NOT EXECUTED
40025364: b0 10 20 00 clr %i0 <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40025368: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4002536c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
40025370: ba 07 60 01 inc %i5 <== NOT EXECUTED
40025374: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40025378: 40 00 75 52 call 400428c0 <snprintf> <== NOT EXECUTED
4002537c: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
40025380: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
40025384: 14 80 00 15 bg 400253d8 <rtems_bdpart_unmount+0x124> <== NOT EXECUTED
40025388: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
4002538c: 40 00 11 15 call 400297e0 <unmount> <== NOT EXECUTED
40025390: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (rv == 0) {
40025394: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40025398: 12 bf ff f2 bne 40025360 <rtems_bdpart_unmount+0xac> <== NOT EXECUTED
4002539c: 80 a7 40 1a cmp %i5, %i2 <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
400253a0: 40 00 0f 5b call 4002910c <rmdir> <== NOT EXECUTED
400253a4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (rv != 0) {
400253a8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400253ac: 02 bf ff ed be 40025360 <rtems_bdpart_unmount+0xac> <== NOT EXECUTED
400253b0: 80 a7 40 1a cmp %i5, %i2 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
400253b4: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
400253b8: 7f ff 7a 6e call 40003d70 <free> <== NOT EXECUTED
400253bc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return esc;
}
400253c0: 81 c7 e0 08 ret <== NOT EXECUTED
400253c4: 81 e8 00 00 restore <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
400253c8: 7f ff 7a 6a call 40003d70 <free> <== NOT EXECUTED
400253cc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return esc;
}
400253d0: 81 c7 e0 08 ret <== NOT EXECUTED
400253d4: 81 e8 00 00 restore <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
400253d8: 7f ff 7a 66 call 40003d70 <free> <== NOT EXECUTED
400253dc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return esc;
}
400253e0: 81 c7 e0 08 ret <== NOT EXECUTED
400253e4: 81 e8 00 00 restore <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
disk_file_name += 1;
disk_file_name_size = strlen( disk_file_name);
} else {
disk_file_name = disk_name;
400253e8: 10 bf ff c4 b 400252f8 <rtems_bdpart_unmount+0x44> <== NOT EXECUTED
400253ec: a2 10 00 18 mov %i0, %l1 <== NOT EXECUTED
40004408 <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
40004408: 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;
4000440c: 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);
40004410: 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;
40004414: c0 27 bf f4 clr [ %fp + -12 ]
dev_t disk = 0;
dev_t logical_disk = 0;
size_t i = 0;
int fd = -1;
40004418: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
4000441c: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
40004420: 92 07 bf f8 add %fp, -8, %o1
40004424: 94 07 bf fc add %fp, -4, %o2
40004428: 7f ff fe d1 call 40003f6c <rtems_bdpart_get_disk_data>
4000442c: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
40004430: b0 92 20 00 orcc %o0, 0, %i0
40004434: 12 80 00 14 bne 40004484 <rtems_bdpart_unregister+0x7c> <== NEVER TAKEN
40004438: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
4000443c: d0 07 bf f8 ld [ %fp + -8 ], %o0
40004440: 40 00 08 24 call 400064d0 <close>
40004444: 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) {
40004448: 80 a6 a0 00 cmp %i2, 0
4000444c: 12 80 00 05 bne 40004460 <rtems_bdpart_unregister+0x58> <== ALWAYS TAKEN
40004450: b4 06 80 1d add %i2, %i5, %i2
40004454: 30 80 00 0c b,a 40004484 <rtems_bdpart_unregister+0x7c> <== NOT EXECUTED
40004458: 02 80 00 0b be 40004484 <rtems_bdpart_unregister+0x7c>
4000445c: 01 00 00 00 nop
/* New minor number */
++minor;
40004460: ba 07 60 01 inc %i5
/* Get the device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Delete logical disk */
sc = rtems_disk_delete( logical_disk);
40004464: 90 10 00 1c mov %i4, %o0
40004468: 40 00 02 cc call 40004f98 <rtems_disk_delete>
4000446c: 92 10 00 1d mov %i5, %o1
if (sc != RTEMS_SUCCESSFUL) {
40004470: 80 a2 20 00 cmp %o0, 0
40004474: 02 bf ff f9 be 40004458 <rtems_bdpart_unregister+0x50> <== ALWAYS TAKEN
40004478: 80 a7 40 1a cmp %i5, %i2
return sc;
}
}
return RTEMS_SUCCESSFUL;
}
4000447c: 81 c7 e0 08 ret <== NOT EXECUTED
40004480: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40004484: 81 c7 e0 08 ret
40004488: 81 e8 00 00 restore
4000451c <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
4000451c: 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;
40004520: 80 a6 60 00 cmp %i1, 0
40004524: 02 80 00 06 be 4000453c <rtems_bdpart_write+0x20> <== NEVER TAKEN
40004528: 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
4000452c: c2 06 40 00 ld [ %i1 ], %g1
40004530: 80 a0 60 00 cmp %g1, 0
40004534: 22 80 00 11 be,a 40004578 <rtems_bdpart_write+0x5c> <== ALWAYS TAKEN
40004538: c2 0e 60 08 ldub [ %i1 + 8 ], %g1
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
4000453c: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0;
40004540: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
40004544: ba 10 20 00 clr %i5 <== NOT EXECUTED
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
40004548: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
int fd = -1;
4000454c: 82 10 3f ff mov -1, %g1
rtems_disk_device *dd = NULL;
40004550: c0 27 bf fc clr [ %fp + -4 ]
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
int fd = -1;
40004554: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
40004558: 80 a6 e0 00 cmp %i3, 0
4000455c: 02 80 00 4e be 40004694 <rtems_bdpart_write+0x178> <== NEVER TAKEN
40004560: b0 10 20 00 clr %i0
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
40004564: 80 a6 a0 00 cmp %i2, 0
40004568: 12 80 00 0b bne 40004594 <rtems_bdpart_write+0x78> <== ALWAYS TAKEN
4000456c: 80 a6 60 00 cmp %i1, 0
return RTEMS_INVALID_ADDRESS;
40004570: 81 c7 e0 08 ret <== NOT EXECUTED
40004574: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
40004578: 80 a0 60 00 cmp %g1, 0
4000457c: 02 bf ff f1 be 40004540 <rtems_bdpart_write+0x24> <== NEVER TAKEN
40004580: c0 27 bf f0 clr [ %fp + -16 ]
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
40004584: c0 27 bf f4 clr [ %fp + -12 ]
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
40004588: ba 10 20 01 mov 1, %i5
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
4000458c: 10 bf ff f0 b 4000454c <rtems_bdpart_write+0x30>
40004590: b8 10 20 3f mov 0x3f, %i4
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
40004594: 02 bf ff f7 be 40004570 <rtems_bdpart_write+0x54> <== NEVER TAKEN
40004598: 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);
4000459c: 94 07 bf fc add %fp, -4, %o2
400045a0: 7f ff fe 73 call 40003f6c <rtems_bdpart_get_disk_data>
400045a4: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
400045a8: b0 92 20 00 orcc %o0, 0, %i0
400045ac: 12 80 00 3a bne 40004694 <rtems_bdpart_write+0x178> <== NEVER TAKEN
400045b0: ba 8f 60 ff andcc %i5, 0xff, %i5
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
400045b4: 32 80 00 25 bne,a 40004648 <rtems_bdpart_write+0x12c> <== ALWAYS TAKEN
400045b8: f0 07 bf f4 ld [ %fp + -12 ], %i0
400045bc: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Check that begin and end are proper within the disk */
if (p->begin >= disk_end || p->end > disk_end) {
400045c0: de 06 80 00 ld [ %i2 ], %o7
400045c4: 80 a3 c0 08 cmp %o7, %o0
400045c8: 3a 80 00 27 bcc,a 40004664 <rtems_bdpart_write+0x148> <== NEVER TAKEN
400045cc: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
400045d0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
400045d4: 80 a2 00 01 cmp %o0, %g1
400045d8: 0a 80 00 22 bcs 40004660 <rtems_bdpart_write+0x144> <== NEVER TAKEN
400045dc: 80 a3 c0 01 cmp %o7, %g1
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
400045e0: 1a 80 00 20 bcc 40004660 <rtems_bdpart_write+0x144> <== NEVER TAKEN
400045e4: a2 10 00 1a mov %i2, %l1
400045e8: 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) {
400045ec: 84 10 20 00 clr %g2
400045f0: 84 00 a0 01 inc %g2
400045f4: 80 a0 80 1b cmp %g2, %i3
400045f8: 22 80 00 29 be,a 4000469c <rtems_bdpart_write+0x180>
400045fc: c2 06 40 00 ld [ %i1 ], %g1
const rtems_bdpart_partition *p = pt + i;
/* Check that begin and end are proper within the disk */
if (p->begin >= disk_end || p->end > disk_end) {
40004600: c6 00 60 30 ld [ %g1 + 0x30 ], %g3
40004604: 80 a0 c0 08 cmp %g3, %o0
40004608: 3a 80 00 17 bcc,a 40004664 <rtems_bdpart_write+0x148> <== NEVER TAKEN
4000460c: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
40004610: c8 00 60 34 ld [ %g1 + 0x34 ], %g4
40004614: 80 a1 00 08 cmp %g4, %o0
40004618: 18 80 00 12 bgu 40004660 <rtems_bdpart_write+0x144> <== NEVER TAKEN
4000461c: 80 a0 c0 04 cmp %g3, %g4
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
40004620: 1a 80 00 10 bcc 40004660 <rtems_bdpart_write+0x144> <== NEVER TAKEN
40004624: 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) {
40004628: 22 bf ff f2 be,a 400045f0 <rtems_bdpart_write+0xd4> <== NEVER TAKEN
4000462c: 82 00 60 30 add %g1, 0x30, %g1 <== NOT EXECUTED
40004630: c8 00 60 04 ld [ %g1 + 4 ], %g4
40004634: 80 a0 c0 04 cmp %g3, %g4
40004638: 0a 80 00 0a bcs 40004660 <rtems_bdpart_write+0x144> <== NEVER TAKEN
4000463c: 82 00 60 30 add %g1, 0x30, %g1
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
}
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
40004640: 10 bf ff ed b 400045f4 <rtems_bdpart_write+0xd8>
40004644: 84 00 a0 01 inc %g2
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
40004648: 92 10 00 1c mov %i4, %o1
4000464c: 40 00 7a ad call 40023100 <.urem>
40004650: 90 10 00 18 mov %i0, %o0
40004654: 90 26 00 08 sub %i0, %o0, %o0
40004658: 10 bf ff da b 400045c0 <rtems_bdpart_write+0xa4>
4000465c: d0 27 bf f4 st %o0, [ %fp + -12 ]
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Check that begin and end are proper within the disk */
if (p->begin >= disk_end || p->end > disk_end) {
esc = RTEMS_INVALID_NUMBER;
40004660: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
40004664: d0 07 bf f8 ld [ %fp + -8 ], %o0
40004668: 80 a2 20 00 cmp %o0, 0
4000466c: 26 80 00 05 bl,a 40004680 <rtems_bdpart_write+0x164> <== NEVER TAKEN
40004670: d0 07 bf f0 ld [ %fp + -16 ], %o0 <== NOT EXECUTED
close( fd);
40004674: 40 00 07 97 call 400064d0 <close>
40004678: 01 00 00 00 nop
}
if (block != NULL) {
4000467c: d0 07 bf f0 ld [ %fp + -16 ], %o0
40004680: 80 a2 20 00 cmp %o0, 0
40004684: 02 80 00 04 be 40004694 <rtems_bdpart_write+0x178> <== NEVER TAKEN
40004688: 01 00 00 00 nop
rtems_bdbuf_sync( block);
4000468c: 40 00 33 b1 call 40011550 <rtems_bdbuf_sync>
40004690: 01 00 00 00 nop
40004694: 81 c7 e0 08 ret
40004698: 81 e8 00 00 restore
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
4000469c: 80 a0 60 00 cmp %g1, 0
400046a0: 12 bf ff f1 bne 40004664 <rtems_bdpart_write+0x148> <== NEVER TAKEN
400046a4: 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;
400046a8: 80 a6 e0 04 cmp %i3, 4
400046ac: 08 80 00 03 bleu 400046b8 <rtems_bdpart_write+0x19c> <== NEVER TAKEN
400046b0: a0 10 00 1b mov %i3, %l0
400046b4: a0 10 20 03 mov 3, %l0
/*
* Check that the first primary partition starts at head one and sector one
* under the virtual one head and 63 sectors geometry if necessary.
*/
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
400046b8: 80 a7 60 00 cmp %i5, 0
400046bc: 02 80 00 06 be 400046d4 <rtems_bdpart_write+0x1b8> <== NEVER TAKEN
400046c0: 80 a4 00 1b cmp %l0, %i3
400046c4: 80 a3 e0 3f cmp %o7, 0x3f
400046c8: 12 bf ff e7 bne 40004664 <rtems_bdpart_write+0x148> <== NEVER TAKEN
400046cc: b0 10 20 0a mov 0xa, %i0
* Each logical partition is described via one EBR preceding the partition.
* The space for the EBR and maybe some space which is needed for DOS
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
400046d0: 80 a4 00 1b cmp %l0, %i3
400046d4: 1a 80 00 1c bcc 40004744 <rtems_bdpart_write+0x228> <== NEVER TAKEN
400046d8: 84 04 3f ff add %l0, -1, %g2
if ((pt [i].begin - pt [i - 1].end) < record_space) {
400046dc: 89 2c 20 06 sll %l0, 6, %g4
400046e0: 87 28 a0 04 sll %g2, 4, %g3
400046e4: 83 2c 20 04 sll %l0, 4, %g1
400046e8: 85 28 a0 06 sll %g2, 6, %g2
400046ec: 82 21 00 01 sub %g4, %g1, %g1
400046f0: 84 20 80 03 sub %g2, %g3, %g2
400046f4: c8 06 80 01 ld [ %i2 + %g1 ], %g4
400046f8: 84 06 80 02 add %i2, %g2, %g2
400046fc: c6 00 a0 04 ld [ %g2 + 4 ], %g3
40004700: 84 06 80 01 add %i2, %g1, %g2
40004704: 82 21 00 03 sub %g4, %g3, %g1
40004708: 80 a7 00 01 cmp %i4, %g1
4000470c: 18 bf ff d5 bgu 40004660 <rtems_bdpart_write+0x144> <== NEVER TAKEN
40004710: 82 10 00 10 mov %l0, %g1
* Each logical partition is described via one EBR preceding the partition.
* The space for the EBR and maybe some space which is needed for DOS
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
40004714: 10 80 00 09 b 40004738 <rtems_bdpart_write+0x21c>
40004718: 82 00 60 01 inc %g1
if ((pt [i].begin - pt [i - 1].end) < record_space) {
4000471c: c8 00 e0 30 ld [ %g3 + 0x30 ], %g4
40004720: c6 00 e0 04 ld [ %g3 + 4 ], %g3
40004724: 86 21 00 03 sub %g4, %g3, %g3
40004728: 80 a7 00 03 cmp %i4, %g3
4000472c: 18 bf ff cd bgu 40004660 <rtems_bdpart_write+0x144> <== NEVER TAKEN
40004730: 84 00 a0 30 add %g2, 0x30, %g2
* Each logical partition is described via one EBR preceding the partition.
* The space for the EBR and maybe some space which is needed for DOS
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
40004734: 82 00 60 01 inc %g1
40004738: 80 a6 c0 01 cmp %i3, %g1
4000473c: 18 bf ff f8 bgu 4000471c <rtems_bdpart_write+0x200>
40004740: 86 10 00 02 mov %g2, %g3
40004744: ba 10 00 1a mov %i2, %i5
40004748: b0 10 20 00 clr %i0
4000474c: 10 80 00 0c b 4000477c <rtems_bdpart_write+0x260>
40004750: a4 07 bf ef add %fp, -17, %l2
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
40004754: 80 a0 60 00 cmp %g1, 0
40004758: 12 80 00 10 bne 40004798 <rtems_bdpart_write+0x27c> <== NEVER TAKEN
4000475c: b0 06 20 01 inc %i0
40004760: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40004764: 80 a0 60 ff cmp %g1, 0xff
40004768: 18 80 00 0c bgu 40004798 <rtems_bdpart_write+0x27c> <== NEVER TAKEN
4000476c: ba 07 60 30 add %i5, 0x30, %i5
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
40004770: 80 a6 00 1b cmp %i0, %i3
40004774: 02 80 00 0b be 400047a0 <rtems_bdpart_write+0x284>
40004778: d0 07 bf fc ld [ %fp + -4 ], %o0
uint8_t type = 0;
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
4000477c: 90 07 60 08 add %i5, 8, %o0
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
uint8_t type = 0;
40004780: 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)) {
40004784: 7f ff fd ee call 40003f3c <rtems_bdpart_to_mbr_partition_type>
40004788: 92 10 00 12 mov %l2, %o1
4000478c: 80 8a 20 ff btst 0xff, %o0
40004790: 32 bf ff f1 bne,a 40004754 <rtems_bdpart_write+0x238> <== ALWAYS TAKEN
40004794: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
40004798: 10 bf ff b3 b 40004664 <rtems_bdpart_write+0x148> <== NOT EXECUTED
4000479c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( dd, 0, &block);
400047a0: 92 10 20 00 clr %o1
400047a4: 7f ff ff 3a call 4000448c <rtems_bdpart_new_record>
400047a8: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
400047ac: b0 92 20 00 orcc %o0, 0, %i0
400047b0: 12 bf ff ae bne 40004668 <rtems_bdpart_write+0x14c> <== NEVER TAKEN
400047b4: 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
400047b8: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
400047bc: c4 06 60 04 ld [ %i1 + 4 ], %g2
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
400047c0: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
400047c4: 82 00 e1 b8 add %g3, 0x1b8, %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
400047c8: 86 00 e1 bc add %g3, 0x1bc, %g3
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
400047cc: c4 28 40 00 stb %g2, [ %g1 ]
400047d0: 82 00 60 01 inc %g1
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
400047d4: 80 a0 40 03 cmp %g1, %g3
400047d8: 12 bf ff fd bne 400047cc <rtems_bdpart_write+0x2b0>
400047dc: 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;
400047e0: c2 07 bf f0 ld [ %fp + -16 ], %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
400047e4: 9f 2c 20 04 sll %l0, 4, %o7
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
400047e8: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
400047ec: 99 2c 20 06 sll %l0, 6, %o4
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
400047f0: 9a 01 21 be add %g4, 0x1be, %o5
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
400047f4: 98 23 00 0f sub %o4, %o7, %o4
400047f8: 88 01 21 ca add %g4, 0x1ca, %g4
400047fc: b0 06 80 0c add %i2, %o4, %i0
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
data,
p->begin,
p->end - p->begin,
40004800: c4 04 40 00 ld [ %l1 ], %g2
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
40004804: c6 04 60 04 ld [ %l1 + 4 ], %g3
if (block != NULL) {
rtems_bdbuf_sync( block);
}
return esc;
}
40004808: f2 0c 60 08 ldub [ %l1 + 8 ], %i1
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
4000480c: fa 0c 60 2f ldub [ %l1 + 0x2f ], %i5
40004810: 86 20 c0 02 sub %g3, %g2, %g3
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
40004814: 82 01 3f fc add %g4, -4, %g1
data [i] = (uint8_t) value;
40004818: c4 28 40 00 stb %g2, [ %g1 ]
4000481c: 82 00 60 01 inc %g1
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
40004820: 80 a1 00 01 cmp %g4, %g1
40004824: 12 bf ff fd bne 40004818 <rtems_bdpart_write+0x2fc>
40004828: 85 30 a0 08 srl %g2, 8, %g2
4000482c: 84 01 20 04 add %g4, 4, %g2
40004830: 82 10 00 04 mov %g4, %g1
data [i] = (uint8_t) value;
40004834: c6 28 40 00 stb %g3, [ %g1 ]
40004838: 82 00 60 01 inc %g1
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
4000483c: 80 a0 40 02 cmp %g1, %g2
40004840: 12 bf ff fd bne 40004834 <rtems_bdpart_write+0x318>
40004844: 87 30 e0 08 srl %g3, 8, %g3
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
40004848: f2 29 3f f8 stb %i1, [ %g4 + -8 ]
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
4000484c: fa 29 3f f4 stb %i5, [ %g4 + -12 ]
40004850: a2 04 60 30 add %l1, 0x30, %l1
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
40004854: 80 a4 40 18 cmp %l1, %i0
40004858: 12 bf ff ea bne 40004800 <rtems_bdpart_write+0x2e4>
4000485c: 88 01 20 10 add %g4, 0x10, %g4
40004860: 84 03 40 0f add %o5, %o7, %g2
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
40004864: 80 a4 00 1b cmp %l0, %i3
40004868: 02 bf ff 7f be 40004664 <rtems_bdpart_write+0x148> <== NEVER TAKEN
4000486c: b0 10 20 00 clr %i0
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
40004870: fa 06 80 0c ld [ %i2 + %o4 ], %i5
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
40004874: c6 07 bf f4 ld [ %fp + -12 ], %g3
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
40004878: ba 27 40 1c sub %i5, %i4, %i5
uint32_t size,
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
4000487c: 82 00 a0 08 add %g2, 8, %g1
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
40004880: 86 20 c0 1d sub %g3, %i5, %g3
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
40004884: b2 00 a0 0c add %g2, 0xc, %i1
40004888: 88 10 00 1d mov %i5, %g4
data [i] = (uint8_t) value;
4000488c: c8 28 40 00 stb %g4, [ %g1 ]
40004890: 82 00 60 01 inc %g1
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
40004894: 80 a0 40 19 cmp %g1, %i1
40004898: 12 bf ff fd bne 4000488c <rtems_bdpart_write+0x370>
4000489c: 89 31 20 08 srl %g4, 8, %g4
400048a0: 88 00 a0 10 add %g2, 0x10, %g4
data [i] = (uint8_t) value;
400048a4: c6 28 40 00 stb %g3, [ %g1 ]
400048a8: 82 00 60 01 inc %g1
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
400048ac: 80 a0 40 04 cmp %g1, %g4
400048b0: 12 bf ff fd bne 400048a4 <rtems_bdpart_write+0x388>
400048b4: 87 30 e0 08 srl %g3, 8, %g3
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
400048b8: 82 10 20 05 mov 5, %g1
400048bc: c2 28 a0 04 stb %g1, [ %g2 + 4 ]
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
400048c0: 80 a4 00 1b cmp %l0, %i3
400048c4: 1a 80 00 44 bcc 400049d4 <rtems_bdpart_write+0x4b8> <== NEVER TAKEN
400048c8: c0 2b 40 0f clrb [ %o5 + %o7 ]
400048cc: a4 04 20 01 add %l0, 1, %l2
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
400048d0: b2 10 20 05 mov 5, %i1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
400048d4: 83 2c a0 04 sll %l2, 4, %g1
400048d8: 85 2c a0 06 sll %l2, 6, %g2
400048dc: 82 20 80 01 sub %g2, %g1, %g1
400048e0: b4 06 80 01 add %i2, %g1, %i2
0
);
}
/* New EBR */
ebr = p->begin - record_space;
400048e4: d2 04 40 00 ld [ %l1 ], %o1
sc = rtems_bdpart_new_record( dd, ebr, &block);
400048e8: d0 07 bf fc ld [ %fp + -4 ], %o0
400048ec: 92 22 40 1c sub %o1, %i4, %o1
400048f0: 7f ff fe e7 call 4000448c <rtems_bdpart_new_record>
400048f4: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
400048f8: 80 a2 20 00 cmp %o0, 0
400048fc: 12 80 00 34 bne 400049cc <rtems_bdpart_write+0x4b0> <== NEVER TAKEN
40004900: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
40004904: c4 04 60 04 ld [ %l1 + 4 ], %g2
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
40004908: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
4000490c: c2 04 40 00 ld [ %l1 ], %g1
if (block != NULL) {
rtems_bdbuf_sync( block);
}
return esc;
}
40004910: de 0c 60 08 ldub [ %l1 + 8 ], %o7
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
40004914: f0 0c 60 2f ldub [ %l1 + 0x2f ], %i0
40004918: 84 20 80 01 sub %g2, %g1, %g2
data [i] = (uint8_t) value;
4000491c: f8 28 e1 c6 stb %i4, [ %g3 + 0x1c6 ]
40004920: c0 28 e1 c7 clrb [ %g3 + 0x1c7 ]
40004924: c0 28 e1 c8 clrb [ %g3 + 0x1c8 ]
40004928: c0 28 e1 c9 clrb [ %g3 + 0x1c9 ]
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
4000492c: 88 00 e1 ca add %g3, 0x1ca, %g4
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
40004930: 82 10 20 00 clr %g1
data [i] = (uint8_t) value;
40004934: c4 29 00 01 stb %g2, [ %g4 + %g1 ]
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
40004938: 82 00 60 01 inc %g1
4000493c: 80 a0 60 04 cmp %g1, 4
40004940: 12 bf ff fd bne 40004934 <rtems_bdpart_write+0x418>
40004944: 85 30 a0 08 srl %g2, 8, %g2
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
40004948: de 28 e1 c2 stb %o7, [ %g3 + 0x1c2 ]
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
4000494c: 80 a4 80 1b cmp %l2, %i3
40004950: 02 80 00 21 be 400049d4 <rtems_bdpart_write+0x4b8>
40004954: f0 28 e1 be stb %i0, [ %g3 + 0x1be ]
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
40004958: 80 a4 00 12 cmp %l0, %l2
4000495c: 1a 80 00 19 bcc 400049c0 <rtems_bdpart_write+0x4a4> <== NEVER TAKEN
40004960: a2 10 00 1a mov %i2, %l1
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
40004964: 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;
40004968: c2 06 80 00 ld [ %i2 ], %g1
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
4000496c: f0 00 a0 1c ld [ %g2 + 0x1c ], %i0
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
40004970: c4 07 bf f4 ld [ %fp + -12 ], %g2
for (i = ppc; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
40004974: 82 20 40 1c sub %g1, %i4, %g1
uint32_t size,
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
40004978: 88 06 21 d6 add %i0, 0x1d6, %g4
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
4000497c: 86 20 40 1d sub %g1, %i5, %g3
40004980: 84 20 80 01 sub %g2, %g1, %g2
40004984: 82 10 20 00 clr %g1
data [i] = (uint8_t) value;
40004988: c6 29 00 01 stb %g3, [ %g4 + %g1 ]
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
4000498c: 82 00 60 01 inc %g1
40004990: 80 a0 60 04 cmp %g1, 4
40004994: 12 bf ff fd bne 40004988 <rtems_bdpart_write+0x46c>
40004998: 87 30 e0 08 srl %g3, 8, %g3
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
4000499c: 86 06 21 da add %i0, 0x1da, %g3
400049a0: 82 10 20 00 clr %g1
data [i] = (uint8_t) value;
400049a4: c4 28 c0 01 stb %g2, [ %g3 + %g1 ]
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
400049a8: 82 00 60 01 inc %g1
400049ac: 80 a0 60 04 cmp %g1, 4
400049b0: 12 bf ff fd bne 400049a4 <rtems_bdpart_write+0x488>
400049b4: 85 30 a0 08 srl %g2, 8, %g2
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
400049b8: f2 2e 21 d2 stb %i1, [ %i0 + 0x1d2 ]
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
400049bc: c0 2e 21 ce clrb [ %i0 + 0x1ce ]
400049c0: a4 04 a0 01 inc %l2
400049c4: 10 bf ff c8 b 400048e4 <rtems_bdpart_write+0x3c8>
400049c8: b4 06 a0 30 add %i2, 0x30, %i2
}
/* New EBR */
ebr = p->begin - record_space;
sc = rtems_bdpart_new_record( dd, ebr, &block);
if (sc != RTEMS_SUCCESSFUL) {
400049cc: 10 bf ff 26 b 40004664 <rtems_bdpart_write+0x148> <== NOT EXECUTED
400049d0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
400049d4: 10 bf ff 24 b 40004664 <rtems_bdpart_write+0x148>
400049d8: b0 10 20 00 clr %i0
40004608 <rtems_blkdev_create_partition>:
const char *partition,
const char *parent_block_device,
rtems_blkdev_bnum media_block_begin,
rtems_blkdev_bnum media_block_count
)
{
40004608: 9d e3 bf 50 save %sp, -176, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(parent_block_device, O_RDWR);
4000460c: 92 10 20 02 mov 2, %o1
40004610: 90 10 00 19 mov %i1, %o0
40004614: 40 00 09 a0 call 40006c94 <open>
40004618: b8 10 00 18 mov %i0, %i4
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
}
} else {
sc = RTEMS_INVALID_ID;
4000461c: b0 10 20 04 mov 4, %i0
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(parent_block_device, O_RDWR);
if (fd >= 0) {
40004620: 80 a2 20 00 cmp %o0, 0
40004624: 06 80 00 0a bl 4000464c <rtems_blkdev_create_partition+0x44>
40004628: ba 10 00 08 mov %o0, %i5
int rv;
struct stat st;
rv = fstat(fd, &st);
4000462c: 40 00 06 12 call 40005e74 <fstat>
40004630: 92 07 bf b8 add %fp, -72, %o1
if (rv == 0 && S_ISBLK(st.st_mode)) {
40004634: 80 a2 20 00 cmp %o0, 0
40004638: 02 80 00 07 be 40004654 <rtems_blkdev_create_partition+0x4c><== ALWAYS TAKEN
4000463c: f2 07 bf c4 ld [ %fp + -60 ], %i1
40004640: b0 10 20 15 mov 0x15, %i0 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NODE;
}
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
40004644: 40 00 05 c0 call 40005d44 <close>
40004648: 90 10 00 1d mov %i5, %o0
4000464c: 81 c7 e0 08 ret
40004650: 81 e8 00 00 restore
if (fd >= 0) {
int rv;
struct stat st;
rv = fstat(fd, &st);
if (rv == 0 && S_ISBLK(st.st_mode)) {
40004654: 03 00 00 3c sethi %hi(0xf000), %g1
40004658: b2 0e 40 01 and %i1, %g1, %i1
4000465c: 03 00 00 18 sethi %hi(0x6000), %g1
40004660: 80 a6 40 01 cmp %i1, %g1
40004664: 12 bf ff f8 bne 40004644 <rtems_blkdev_create_partition+0x3c>
40004668: b0 10 20 15 mov 0x15, %i0
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
4000466c: 90 10 00 1d mov %i5, %o0
40004670: 94 07 bf b4 add %fp, -76, %o2
40004674: 13 10 01 10 sethi %hi(0x40044000), %o1
}
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_NOT_IMPLEMENTED;
40004678: b0 10 20 18 mov 0x18, %i0
4000467c: 40 00 06 54 call 40005fcc <ioctl>
40004680: 92 12 62 09 or %o1, 0x209, %o1
rv = fstat(fd, &st);
if (rv == 0 && S_ISBLK(st.st_mode)) {
rtems_disk_device *phys_dd;
rv = rtems_disk_fd_get_disk_device(fd, &phys_dd);
if (rv == 0) {
40004684: 80 a2 20 00 cmp %o0, 0
40004688: 12 bf ff ef bne 40004644 <rtems_blkdev_create_partition+0x3c>
4000468c: 01 00 00 00 nop
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
40004690: 40 00 07 6c call 40006440 <malloc>
40004694: 90 10 20 80 mov 0x80, %o0 ! 80 <PROM_START+0x80>
if (ctx != NULL) {
40004698: a0 92 20 00 orcc %o0, 0, %l0
4000469c: 02 80 00 17 be 400046f8 <rtems_blkdev_create_partition+0xf0>
400046a0: d2 07 bf b4 ld [ %fp + -76 ], %o1
sc = rtems_disk_init_log(
400046a4: 94 10 00 1a mov %i2, %o2
400046a8: 40 00 00 96 call 40004900 <rtems_disk_init_log>
400046ac: 96 10 00 1b mov %i3, %o3
phys_dd,
media_block_begin,
media_block_count
);
if (sc == RTEMS_SUCCESSFUL) {
400046b0: b0 92 20 00 orcc %o0, 0, %i0
400046b4: 12 80 00 0e bne 400046ec <rtems_blkdev_create_partition+0xe4>
400046b8: 90 10 00 1c mov %i4, %o0
ctx->fd = fd;
400046bc: fa 24 20 78 st %i5, [ %l0 + 0x78 ]
rv = IMFS_make_generic_node(
400046c0: 92 16 61 ff or %i1, 0x1ff, %o1
400046c4: 96 10 00 10 mov %l0, %o3
400046c8: 15 10 00 6d sethi %hi(0x4001b400), %o2
400046cc: 40 00 03 cb call 400055f8 <IMFS_make_generic_node>
400046d0: 94 12 a0 78 or %o2, 0x78, %o2 ! 4001b478 <rtems_blkdev_imfs_control>
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
400046d4: 80 a2 20 00 cmp %o0, 0
400046d8: 02 bf ff dd be 4000464c <rtems_blkdev_create_partition+0x44>
400046dc: 90 10 00 10 mov %l0, %o0
free(ctx);
400046e0: 40 00 05 bb call 40005dcc <free>
400046e4: b0 10 20 0d mov 0xd, %i0
400046e8: 30 bf ff d7 b,a 40004644 <rtems_blkdev_create_partition+0x3c>
sc = RTEMS_UNSATISFIED;
}
} else {
free(ctx);
400046ec: 40 00 05 b8 call 40005dcc <free>
400046f0: 90 10 00 10 mov %l0, %o0
400046f4: 30 bf ff d4 b,a 40004644 <rtems_blkdev_create_partition+0x3c>
}
} else {
sc = RTEMS_NO_MEMORY;
400046f8: 10 bf ff d3 b 40004644 <rtems_blkdev_create_partition+0x3c>
400046fc: b0 10 20 1a mov 0x1a, %i0
40010ab8 <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)
{
40010ab8: 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;
40010abc: c2 06 80 00 ld [ %i2 ], %g1
if (args->command != RTEMS_BLKIO_REQUEST)
40010ac0: 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;
40010ac4: d0 00 60 30 ld [ %g1 + 0x30 ], %o0
if (args->command != RTEMS_BLKIO_REQUEST)
40010ac8: 03 30 06 10 sethi %hi(0xc0184000), %g1
40010acc: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
40010ad0: 80 a2 40 01 cmp %o1, %g1
40010ad4: 12 80 00 05 bne 40010ae8 <rtems_blkdev_generic_ioctl+0x30><== ALWAYS TAKEN
40010ad8: 82 10 3f ff mov -1, %g1
{
/*
* It is not allowed to directly access the driver circumventing the
* cache.
*/
args->ioctl_return = -1;
40010adc: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
40010ae0: 81 c7 e0 08 ret <== NOT EXECUTED
40010ae4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
if (args->command != RTEMS_BLKIO_REQUEST)
{
args->ioctl_return = dd->ioctl(dd,
40010ae8: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
40010aec: d4 06 a0 08 ld [ %i2 + 8 ], %o2
40010af0: 9f c0 40 00 call %g1
40010af4: b0 10 20 00 clr %i0
40010af8: d0 26 a0 0c st %o0, [ %i2 + 0xc ]
*/
args->ioctl_return = -1;
}
return RTEMS_SUCCESSFUL;
}
40010afc: 81 c7 e0 08 ret
40010b00: 81 e8 00 00 restore
40010874 <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)
{
40010874: 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;
40010878: 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);
4001087c: 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;
40010880: 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);
40010884: 94 10 20 00 clr %o2
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
40010888: e2 04 a0 24 ld [ %l2 + 0x24 ], %l1
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
4001088c: 90 10 00 1c mov %i4, %o0
40010890: 96 10 00 11 mov %l1, %o3
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
40010894: f6 06 a0 14 ld [ %i2 + 0x14 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
40010898: 40 00 21 e5 call 4001902c <__divdi3>
4001089c: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
400108a0: 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);
400108a4: b2 10 00 09 mov %o1, %i1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
400108a8: 94 10 20 00 clr %o2
400108ac: 92 10 00 1d mov %i5, %o1
400108b0: 40 00 22 ca call 400193d8 <__moddi3>
400108b4: 96 10 00 11 mov %l1, %o3
args->bytes_moved = 0;
400108b8: c0 26 a0 1c clr [ %i2 + 0x1c ]
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
400108bc: a0 10 00 09 mov %o1, %l0
args->bytes_moved = 0;
while (count > 0)
400108c0: 80 a6 e0 00 cmp %i3, 0
400108c4: 12 80 00 1a bne 4001092c <rtems_blkdev_generic_read+0xb8> <== ALWAYS TAKEN
400108c8: f8 06 a0 10 ld [ %i2 + 0x10 ], %i4
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
400108cc: 81 c7 e0 08 ret <== NOT EXECUTED
400108d0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
400108d4: ba 24 40 10 sub %l1, %l0, %i5
400108d8: 80 a7 40 1b cmp %i5, %i3
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
400108dc: 08 80 00 03 bleu 400108e8 <rtems_blkdev_generic_read+0x74><== ALWAYS TAKEN
400108e0: c2 07 bf fc ld [ %fp + -4 ], %g1
400108e4: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
400108e8: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
400108ec: 94 10 00 1d mov %i5, %o2
400108f0: 40 00 14 b9 call 40015bd4 <memcpy>
400108f4: 92 02 40 10 add %o1, %l0, %o1
rc = rtems_bdbuf_release(diskbuf);
400108f8: d0 07 bf fc ld [ %fp + -4 ], %o0
400108fc: 7f ff fd e9 call 400100a0 <rtems_bdbuf_release>
40010900: b8 07 00 1d add %i4, %i5, %i4
args->bytes_moved += copy;
40010904: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
40010908: b0 10 00 08 mov %o0, %i0
args->bytes_moved += copy;
4001090c: 82 00 40 1d add %g1, %i5, %g1
if (rc != RTEMS_SUCCESSFUL)
40010910: 80 a2 20 00 cmp %o0, 0
40010914: 12 80 00 0e bne 4001094c <rtems_blkdev_generic_read+0xd8> <== NEVER TAKEN
40010918: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
break;
count -= copy;
buf += copy;
blkofs = 0;
block++;
4001091c: b2 06 60 01 inc %i1
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
while (count > 0)
40010920: b6 a6 c0 1d subcc %i3, %i5, %i3
40010924: 02 80 00 0c be 40010954 <rtems_blkdev_generic_read+0xe0> <== ALWAYS TAKEN
40010928: a0 10 20 00 clr %l0
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
4001092c: 92 10 00 19 mov %i1, %o1
40010930: 94 07 bf fc add %fp, -4, %o2
40010934: 7f ff fd 56 call 4000fe8c <rtems_bdbuf_read>
40010938: 90 10 00 12 mov %l2, %o0
4001093c: b0 10 00 08 mov %o0, %i0
if (rc != RTEMS_SUCCESSFUL)
40010940: 80 a6 20 00 cmp %i0, 0
40010944: 02 bf ff e4 be 400108d4 <rtems_blkdev_generic_read+0x60> <== ALWAYS TAKEN
40010948: 90 10 00 1c mov %i4, %o0
blkofs = 0;
block++;
}
return rc;
}
4001094c: 81 c7 e0 08 ret <== NOT EXECUTED
40010950: 81 e8 00 00 restore <== NOT EXECUTED
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
40010954: b0 10 20 00 clr %i0
40010958: 81 c7 e0 08 ret
4001095c: 81 e8 00 00 restore
40010960 <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)
{
40010960: 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;
40010964: 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);
40010968: 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;
4001096c: 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);
40010970: 94 10 20 00 clr %o2
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
40010974: e0 04 60 24 ld [ %l1 + 0x24 ], %l0
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
40010978: 90 10 00 1c mov %i4, %o0
4001097c: 96 10 00 10 mov %l0, %o3
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
40010980: f6 06 a0 14 ld [ %i2 + 0x14 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
40010984: 40 00 21 aa call 4001902c <__divdi3>
40010988: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
4001098c: 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);
40010990: b0 10 00 09 mov %o1, %i0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
40010994: 94 10 20 00 clr %o2
40010998: 92 10 00 1d mov %i5, %o1
4001099c: 40 00 22 8f call 400193d8 <__moddi3>
400109a0: 96 10 00 10 mov %l0, %o3
args->bytes_moved = 0;
400109a4: c0 26 a0 1c clr [ %i2 + 0x1c ]
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
400109a8: b8 10 00 09 mov %o1, %i4
args->bytes_moved = 0;
while (count > 0)
400109ac: 80 a6 e0 00 cmp %i3, 0
400109b0: 12 80 00 21 bne 40010a34 <rtems_blkdev_generic_write+0xd4><== ALWAYS TAKEN
400109b4: f2 06 a0 10 ld [ %i2 + 0x10 ], %i1
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
400109b8: 10 80 00 2c b 40010a68 <rtems_blkdev_generic_write+0x108> <== NOT EXECUTED
400109bc: 90 10 20 00 clr %o0 <== NOT EXECUTED
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
400109c0: 12 80 00 21 bne 40010a44 <rtems_blkdev_generic_write+0xe4><== NEVER TAKEN
400109c4: 92 10 00 18 mov %i0, %o1
rc = rtems_bdbuf_get(dd, block, &diskbuf);
400109c8: 90 10 00 11 mov %l1, %o0
400109cc: 7f ff fc f0 call 4000fd8c <rtems_bdbuf_get>
400109d0: 94 07 bf fc add %fp, -4, %o2
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
400109d4: 80 a2 20 00 cmp %o0, 0
400109d8: 12 80 00 21 bne 40010a5c <rtems_blkdev_generic_write+0xfc><== NEVER TAKEN
400109dc: 92 10 00 19 mov %i1, %o1
break;
copy = block_size - blkofs;
400109e0: ba 24 00 1c sub %l0, %i4, %i5
400109e4: 80 a7 40 1b cmp %i5, %i3
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
400109e8: 08 80 00 03 bleu 400109f4 <rtems_blkdev_generic_write+0x94><== ALWAYS TAKEN
400109ec: c2 07 bf fc ld [ %fp + -4 ], %g1
400109f0: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
400109f4: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
400109f8: 94 10 00 1d mov %i5, %o2
400109fc: 40 00 14 76 call 40015bd4 <memcpy>
40010a00: 90 02 00 1c add %o0, %i4, %o0
args->bytes_moved += copy;
40010a04: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
rc = rtems_bdbuf_release_modified(diskbuf);
40010a08: 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;
40010a0c: 82 00 40 1d add %g1, %i5, %g1
rc = rtems_bdbuf_release_modified(diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
40010a10: b2 06 40 1d add %i1, %i5, %i1
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
args->bytes_moved += copy;
rc = rtems_bdbuf_release_modified(diskbuf);
40010a14: 7f ff fd db call 40010180 <rtems_bdbuf_release_modified>
40010a18: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
if (rc != RTEMS_SUCCESSFUL)
40010a1c: 80 a2 20 00 cmp %o0, 0
40010a20: 12 80 00 0f bne 40010a5c <rtems_blkdev_generic_write+0xfc><== NEVER TAKEN
40010a24: b6 a6 c0 1d subcc %i3, %i5, %i3
break;
count -= copy;
buf += copy;
blkofs = 0;
block++;
40010a28: b0 06 20 01 inc %i0
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
while (count > 0)
40010a2c: 02 80 00 0e be 40010a64 <rtems_blkdev_generic_write+0x104><== ALWAYS TAKEN
40010a30: b8 10 20 00 clr %i4
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
40010a34: 80 a6 c0 10 cmp %i3, %l0
40010a38: 1a bf ff e2 bcc 400109c0 <rtems_blkdev_generic_write+0x60><== ALWAYS TAKEN
40010a3c: 80 a7 20 00 cmp %i4, 0
rc = rtems_bdbuf_get(dd, block, &diskbuf);
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
40010a40: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40010a44: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
40010a48: 7f ff fd 11 call 4000fe8c <rtems_bdbuf_read> <== NOT EXECUTED
40010a4c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
40010a50: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40010a54: 02 bf ff e3 be 400109e0 <rtems_blkdev_generic_write+0x80> <== NOT EXECUTED
40010a58: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
blkofs = 0;
block++;
}
return rc;
}
40010a5c: 81 c7 e0 08 ret <== NOT EXECUTED
40010a60: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
40010a64: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
40010a68: 81 c7 e0 08 ret
40010a6c: 91 e8 00 08 restore %g0, %o0, %o0
400044e4 <rtems_blkdev_imfs_fsync_or_fdatasync>:
}
static int rtems_blkdev_imfs_fsync_or_fdatasync(
rtems_libio_t *iop
)
{
400044e4: 9d e3 bf a0 save %sp, -96, %sp
400044e8: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
int rv = 0;
400044ec: 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);
400044f0: 40 00 32 93 call 40010f3c <rtems_bdbuf_syncdev>
400044f4: d0 00 60 50 ld [ %g1 + 0x50 ], %o0
if (sc != RTEMS_SUCCESSFUL) {
400044f8: 80 a2 20 00 cmp %o0, 0
400044fc: 12 80 00 04 bne 4000450c <rtems_blkdev_imfs_fsync_or_fdatasync+0x28><== NEVER TAKEN
40004500: 01 00 00 00 nop
errno = EIO;
rv = -1;
}
return rv;
}
40004504: 81 c7 e0 08 ret
40004508: 81 e8 00 00 restore
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
rtems_status_code sc = rtems_bdbuf_syncdev(dd);
if (sc != RTEMS_SUCCESSFUL) {
errno = EIO;
4000450c: 40 00 45 16 call 40015964 <__errno> <== NOT EXECUTED
40004510: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40004514: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40004518: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
4000451c: 81 c7 e0 08 ret <== NOT EXECUTED
40004520: 81 e8 00 00 restore <== NOT EXECUTED
40004524 <rtems_blkdev_imfs_ioctl>:
static int rtems_blkdev_imfs_ioctl(
rtems_libio_t *iop,
uint32_t request,
void *buffer
)
{
40004524: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
40004528: 03 30 06 10 sethi %hi(0xc0184000), %g1
4000452c: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
40004530: 80 a6 40 01 cmp %i1, %g1
40004534: 02 80 00 09 be 40004558 <rtems_blkdev_imfs_ioctl+0x34> <== NEVER TAKEN
40004538: 92 10 00 19 mov %i1, %o1
4000453c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
40004540: 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);
40004544: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
40004548: 9f c0 40 00 call %g1
4000454c: 94 10 00 1a mov %i2, %o2
40004550: 81 c7 e0 08 ret
40004554: 91 e8 00 08 restore %g0, %o0, %o0
} else {
/*
* It is not allowed to directly access the driver circumventing the cache.
*/
errno = EINVAL;
40004558: 40 00 45 03 call 40015964 <__errno> <== NOT EXECUTED
4000455c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40004560: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40004564: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
40004568: 81 c7 e0 08 ret <== NOT EXECUTED
4000456c: 81 e8 00 00 restore <== NOT EXECUTED
40004358 <rtems_blkdev_imfs_read>:
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
40004358: 9d e3 bf 98 save %sp, -104, %sp
4000435c: 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;
40004360: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
40004364: e2 00 60 50 ld [ %g1 + 0x50 ], %l1
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40004368: 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);
4000436c: e4 04 60 24 ld [ %l1 + 0x24 ], %l2
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40004370: 90 10 00 1c mov %i4, %o0
40004374: a1 3c a0 1f sra %l2, 0x1f, %l0
40004378: 96 10 00 12 mov %l2, %o3
4000437c: 40 00 55 28 call 4001981c <__divdi3>
40004380: 94 10 00 10 mov %l0, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
40004384: 94 10 00 10 mov %l0, %o2
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40004388: b6 10 00 09 mov %o1, %i3
ssize_t block_offset = (ssize_t) (offset % block_size);
4000438c: 90 10 00 1c mov %i4, %o0
40004390: 92 10 00 1d mov %i5, %o1
40004394: 40 00 56 0d call 40019bc8 <__moddi3>
40004398: 96 10 00 12 mov %l2, %o3
char *dst = buffer;
while (remaining > 0) {
4000439c: ba 96 a0 00 orcc %i2, 0, %i5
400043a0: 04 80 00 23 ble 4000442c <rtems_blkdev_imfs_read+0xd4> <== NEVER TAKEN
400043a4: a0 10 00 09 mov %o1, %l0
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
400043a8: 92 10 00 1b mov %i3, %o1
400043ac: 94 07 bf fc add %fp, -4, %o2
400043b0: 40 00 31 b4 call 40010a80 <rtems_bdbuf_read>
400043b4: 90 10 00 11 mov %l1, %o0
if (sc == RTEMS_SUCCESSFUL) {
400043b8: 80 a2 20 00 cmp %o0, 0
400043bc: 02 80 00 09 be 400043e0 <rtems_blkdev_imfs_read+0x88> <== ALWAYS TAKEN
400043c0: 90 10 00 19 mov %i1, %o0
if (remaining >= 0) {
iop->offset += count;
rv = (ssize_t) count;
} else {
errno = EIO;
400043c4: 40 00 45 68 call 40015964 <__errno> <== NOT EXECUTED
400043c8: 01 00 00 00 nop <== NOT EXECUTED
rv = -1;
400043cc: 82 10 3f ff mov -1, %g1 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
if (remaining >= 0) {
iop->offset += count;
rv = (ssize_t) count;
} else {
errno = EIO;
400043d0: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
400043d4: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
400043d8: 81 c7 e0 08 ret <== NOT EXECUTED
400043dc: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
while (remaining > 0) {
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
if (sc == RTEMS_SUCCESSFUL) {
ssize_t copy = block_size - block_offset;
400043e0: b8 24 80 10 sub %l2, %l0, %i4
400043e4: 80 a7 00 1d cmp %i4, %i5
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
400043e8: 04 80 00 03 ble 400043f4 <rtems_blkdev_imfs_read+0x9c>
400043ec: c2 07 bf fc ld [ %fp + -4 ], %g1
400043f0: b8 10 00 1d mov %i5, %i4
400043f4: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
400043f8: 94 10 00 1c mov %i4, %o2
400043fc: 40 00 47 bb call 400162e8 <memcpy>
40004400: 92 02 40 10 add %o1, %l0, %o1
sc = rtems_bdbuf_release(bd);
40004404: d0 07 bf fc ld [ %fp + -4 ], %o0
40004408: 40 00 32 23 call 40010c94 <rtems_bdbuf_release>
4000440c: ba 27 40 1c sub %i5, %i4, %i5
if (sc == RTEMS_SUCCESSFUL) {
40004410: 80 a2 20 00 cmp %o0, 0
40004414: 12 bf ff ec bne 400043c4 <rtems_blkdev_imfs_read+0x6c> <== NEVER TAKEN
40004418: 80 a7 60 00 cmp %i5, 0
block_offset = 0;
remaining -= copy;
dst += copy;
4000441c: b2 06 40 1c add %i1, %i4, %i1
++block;
40004420: b6 06 e0 01 inc %i3
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
ssize_t block_offset = (ssize_t) (offset % block_size);
char *dst = buffer;
while (remaining > 0) {
40004424: 14 bf ff e1 bg 400043a8 <rtems_blkdev_imfs_read+0x50>
40004428: a0 10 20 00 clr %l0
} else {
remaining = -1;
}
}
if (remaining >= 0) {
4000442c: 80 a7 60 00 cmp %i5, 0
40004430: 12 bf ff e5 bne 400043c4 <rtems_blkdev_imfs_read+0x6c> <== NEVER TAKEN
40004434: 82 10 00 1a mov %i2, %g1
iop->offset += count;
40004438: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
4000443c: 86 80 c0 1a addcc %g3, %i2, %g3
40004440: 84 40 a0 00 addx %g2, 0, %g2
40004444: c4 3e 20 08 std %g2, [ %i0 + 8 ]
errno = EIO;
rv = -1;
}
return rv;
}
40004448: 81 c7 e0 08 ret
4000444c: 91 e8 00 01 restore %g0, %g1, %o0
40004224 <rtems_blkdev_imfs_write>:
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
40004224: 9d e3 bf 98 save %sp, -104, %sp
40004228: 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;
4000422c: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
40004230: e2 00 60 50 ld [ %g1 + 0x50 ], %l1
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40004234: 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);
40004238: f6 04 60 24 ld [ %l1 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
4000423c: 90 10 00 1c mov %i4, %o0
40004240: a1 3e e0 1f sra %i3, 0x1f, %l0
40004244: 96 10 00 1b mov %i3, %o3
40004248: 40 00 55 75 call 4001981c <__divdi3>
4000424c: 94 10 00 10 mov %l0, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
40004250: 94 10 00 10 mov %l0, %o2
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40004254: a4 10 00 09 mov %o1, %l2
ssize_t block_offset = (ssize_t) (offset % block_size);
40004258: 90 10 00 1c mov %i4, %o0
4000425c: 92 10 00 1d mov %i5, %o1
40004260: 40 00 56 5a call 40019bc8 <__moddi3>
40004264: 96 10 00 1b mov %i3, %o3
const char *src = buffer;
while (remaining > 0) {
40004268: ba 96 a0 00 orcc %i2, 0, %i5
4000426c: 04 80 00 2e ble 40004324 <rtems_blkdev_imfs_write+0x100> <== NEVER TAKEN
40004270: a0 10 00 09 mov %o1, %l0
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
40004274: 80 a7 40 1b cmp %i5, %i3
40004278: 16 80 00 03 bge 40004284 <rtems_blkdev_imfs_write+0x60>
4000427c: 82 10 20 01 mov 1, %g1
40004280: 82 10 20 00 clr %g1
sc = rtems_bdbuf_get(dd, block, &bd);
40004284: 90 10 00 11 mov %l1, %o0
40004288: 92 10 00 12 mov %l2, %o1
while (remaining > 0) {
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
4000428c: 80 88 60 ff btst 0xff, %g1
40004290: 02 80 00 2e be 40004348 <rtems_blkdev_imfs_write+0x124>
40004294: 94 07 bf fc add %fp, -4, %o2
40004298: 80 a4 20 00 cmp %l0, 0
4000429c: 12 80 00 2b bne 40004348 <rtems_blkdev_imfs_write+0x124>
400042a0: 01 00 00 00 nop
sc = rtems_bdbuf_get(dd, block, &bd);
400042a4: 40 00 31 b7 call 40010980 <rtems_bdbuf_get>
400042a8: 01 00 00 00 nop
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
400042ac: 80 a2 20 00 cmp %o0, 0
400042b0: 02 80 00 09 be 400042d4 <rtems_blkdev_imfs_write+0xb0> <== ALWAYS TAKEN
400042b4: b8 26 c0 10 sub %i3, %l0, %i4
if (remaining >= 0) {
iop->offset += count;
rv = (ssize_t) count;
} else {
errno = EIO;
400042b8: 40 00 45 ab call 40015964 <__errno> <== NOT EXECUTED
400042bc: 01 00 00 00 nop <== NOT EXECUTED
rv = -1;
400042c0: 82 10 3f ff mov -1, %g1 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
if (remaining >= 0) {
iop->offset += count;
rv = (ssize_t) count;
} else {
errno = EIO;
400042c4: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
400042c8: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
400042cc: 81 c7 e0 08 ret <== NOT EXECUTED
400042d0: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
400042d4: 80 a7 00 1d cmp %i4, %i5
400042d8: 34 80 00 02 bg,a 400042e0 <rtems_blkdev_imfs_write+0xbc>
400042dc: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
400042e0: c2 07 bf fc ld [ %fp + -4 ], %g1
400042e4: 92 10 00 19 mov %i1, %o1
400042e8: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
400042ec: 94 10 00 1c mov %i4, %o2
400042f0: 40 00 47 fe call 400162e8 <memcpy>
400042f4: 90 02 00 10 add %o0, %l0, %o0
sc = rtems_bdbuf_release_modified(bd);
400042f8: 40 00 32 9f call 40010d74 <rtems_bdbuf_release_modified>
400042fc: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
40004300: 80 a2 20 00 cmp %o0, 0
40004304: 12 bf ff ed bne 400042b8 <rtems_blkdev_imfs_write+0x94> <== NEVER TAKEN
40004308: 01 00 00 00 nop
block_offset = 0;
remaining -= copy;
4000430c: ba 27 40 1c sub %i5, %i4, %i5
src += copy;
40004310: b2 06 40 1c add %i1, %i4, %i1
++block;
40004314: a4 04 a0 01 inc %l2
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
ssize_t block_offset = (ssize_t) (offset % block_size);
const char *src = buffer;
while (remaining > 0) {
40004318: 80 a7 60 00 cmp %i5, 0
4000431c: 14 bf ff d6 bg 40004274 <rtems_blkdev_imfs_write+0x50>
40004320: a0 10 20 00 clr %l0
} else {
remaining = -1;
}
}
if (remaining >= 0) {
40004324: 80 a7 60 00 cmp %i5, 0
40004328: 12 bf ff e4 bne 400042b8 <rtems_blkdev_imfs_write+0x94> <== NEVER TAKEN
4000432c: 82 10 00 1a mov %i2, %g1
iop->offset += count;
40004330: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
40004334: 86 80 c0 1a addcc %g3, %i2, %g3
40004338: 84 40 a0 00 addx %g2, 0, %g2
4000433c: c4 3e 20 08 std %g2, [ %i0 + 8 ]
errno = EIO;
rv = -1;
}
return rv;
}
40004340: 81 c7 e0 08 ret
40004344: 91 e8 00 01 restore %g0, %g1, %o0
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
sc = rtems_bdbuf_get(dd, block, &bd);
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
40004348: 40 00 31 ce call 40010a80 <rtems_bdbuf_read>
4000434c: 01 00 00 00 nop
}
if (sc == RTEMS_SUCCESSFUL) {
40004350: 10 bf ff d8 b 400042b0 <rtems_blkdev_imfs_write+0x8c>
40004354: 80 a2 20 00 cmp %o0, 0
40010704 <rtems_blkdev_ioctl>:
#include <rtems/blkdev.h>
#include <rtems/bdbuf.h>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
40010704: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
switch (req)
40010708: 05 10 01 10 sethi %hi(0x40044000), %g2
4001070c: 82 10 a2 03 or %g2, 0x203, %g1 ! 40044203 <__end+0x26c33>
40010710: 80 a6 40 01 cmp %i1, %g1
40010714: 22 80 00 55 be,a 40010868 <rtems_blkdev_ioctl+0x164>
40010718: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4001071c: 08 80 00 1c bleu 4001078c <rtems_blkdev_ioctl+0x88>
40010720: 03 08 00 10 sethi %hi(0x20004000), %g1
40010724: 82 10 a2 09 or %g2, 0x209, %g1
40010728: 80 a6 40 01 cmp %i1, %g1
4001072c: 22 80 00 3c be,a 4001081c <rtems_blkdev_ioctl+0x118>
40010730: f0 26 80 00 st %i0, [ %i2 ]
40010734: 28 80 00 27 bleu,a 400107d0 <rtems_blkdev_ioctl+0xcc>
40010738: 84 10 a2 05 or %g2, 0x205, %g2
4001073c: 84 10 a2 0b or %g2, 0x20b, %g2
40010740: 80 a6 40 02 cmp %i1, %g2
40010744: 02 80 00 3f be 40010840 <rtems_blkdev_ioctl+0x13c>
40010748: 03 20 01 10 sethi %hi(0x80044000), %g1
4001074c: 82 10 62 04 or %g1, 0x204, %g1 ! 80044204 <LEON_REG+0x44204>
40010750: 80 a6 40 01 cmp %i1, %g1
40010754: 12 80 00 22 bne 400107dc <rtems_blkdev_ioctl+0xd8> <== NEVER TAKEN
40010758: 90 10 00 18 mov %i0, %o0
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
break;
case RTEMS_BLKIO_SETBLKSIZE:
sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp, true);
4001075c: d2 06 80 00 ld [ %i2 ], %o1
40010760: 7f ff ff 8f call 4001059c <rtems_bdbuf_set_block_size>
40010764: 94 10 20 01 mov 1, %o2
if (sc != RTEMS_SUCCESSFUL) {
40010768: 80 a2 20 00 cmp %o0, 0
4001076c: 02 80 00 2a be 40010814 <rtems_blkdev_ioctl+0x110> <== ALWAYS TAKEN
40010770: 01 00 00 00 nop
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
if (sc != RTEMS_SUCCESSFUL) {
errno = EIO;
40010774: 40 00 12 e1 call 400152f8 <__errno> <== NOT EXECUTED
40010778: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
4001077c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40010780: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40010784: 81 c7 e0 08 ret <== NOT EXECUTED
40010788: 81 e8 00 00 restore <== NOT EXECUTED
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
4001078c: 86 10 62 0a or %g1, 0x20a, %g3
40010790: 80 a6 40 03 cmp %i1, %g3
40010794: 02 80 00 31 be 40010858 <rtems_blkdev_ioctl+0x154>
40010798: 90 10 00 18 mov %i0, %o0
4001079c: 28 80 00 16 bleu,a 400107f4 <rtems_blkdev_ioctl+0xf0>
400107a0: 82 10 62 06 or %g1, 0x206, %g1
400107a4: 82 10 62 0c or %g1, 0x20c, %g1
400107a8: 80 a6 40 01 cmp %i1, %g1
400107ac: 02 80 00 21 be 40010830 <rtems_blkdev_ioctl+0x12c>
400107b0: 84 10 a2 02 or %g2, 0x202, %g2
400107b4: 80 a6 40 02 cmp %i1, %g2
400107b8: 12 80 00 09 bne 400107dc <rtems_blkdev_ioctl+0xd8> <== NEVER TAKEN
400107bc: 01 00 00 00 nop
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
400107c0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
400107c4: c2 26 80 00 st %g1, [ %i2 ]
break;
400107c8: 81 c7 e0 08 ret
400107cc: 91 e8 20 00 restore %g0, 0, %o0
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
400107d0: 80 a6 40 02 cmp %i1, %g2
400107d4: 22 80 00 14 be,a 40010824 <rtems_blkdev_ioctl+0x120> <== ALWAYS TAKEN
400107d8: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
case RTEMS_BLKIO_RESETDEVSTATS:
rtems_bdbuf_reset_device_stats(dd);
break;
default:
errno = EINVAL;
400107dc: 40 00 12 c7 call 400152f8 <__errno>
400107e0: b0 10 3f ff mov -1, %i0
400107e4: 82 10 20 16 mov 0x16, %g1
400107e8: c2 22 00 00 st %g1, [ %o0 ]
rc = -1;
break;
}
return rc;
}
400107ec: 81 c7 e0 08 ret
400107f0: 81 e8 00 00 restore
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
400107f4: 80 a6 40 01 cmp %i1, %g1
400107f8: 12 bf ff f9 bne 400107dc <rtems_blkdev_ioctl+0xd8>
400107fc: 01 00 00 00 nop
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
40010800: 7f ff fe d2 call 40010348 <rtems_bdbuf_syncdev>
40010804: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL) {
40010808: 80 a2 20 00 cmp %o0, 0
4001080c: 12 bf ff da bne 40010774 <rtems_blkdev_ioctl+0x70> <== NEVER TAKEN
40010810: 01 00 00 00 nop
}
break;
case RTEMS_BLKIO_GETDISKDEV:
*(rtems_disk_device **) argp = dd;
break;
40010814: 81 c7 e0 08 ret
40010818: 91 e8 20 00 restore %g0, 0, %o0
4001081c: 81 c7 e0 08 ret
40010820: 91 e8 20 00 restore %g0, 0, %o0
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
40010824: c2 26 80 00 st %g1, [ %i2 ]
break;
40010828: 81 c7 e0 08 ret
4001082c: 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);
40010830: 7f ff ff ac call 400106e0 <rtems_bdbuf_reset_device_stats>
40010834: b0 10 20 00 clr %i0
break;
40010838: 81 c7 e0 08 ret
4001083c: 81 e8 00 00 restore
case RTEMS_BLKIO_PURGEDEV:
rtems_bdbuf_purge_dev(dd);
break;
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
40010840: 90 10 00 18 mov %i0, %o0
40010844: 92 10 00 1a mov %i2, %o1
40010848: 7f ff ff 9d call 400106bc <rtems_bdbuf_get_device_stats>
4001084c: b0 10 20 00 clr %i0
break;
40010850: 81 c7 e0 08 ret
40010854: 81 e8 00 00 restore
case RTEMS_BLKIO_GETDISKDEV:
*(rtems_disk_device **) argp = dd;
break;
case RTEMS_BLKIO_PURGEDEV:
rtems_bdbuf_purge_dev(dd);
40010858: 7f ff fe d3 call 400103a4 <rtems_bdbuf_purge_dev>
4001085c: b0 10 20 00 clr %i0
break;
40010860: 81 c7 e0 08 ret
40010864: 81 e8 00 00 restore
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
40010868: c2 26 80 00 st %g1, [ %i2 ]
break;
4001086c: 81 c7 e0 08 ret
40010870: 91 e8 20 00 restore %g0, 0, %o0
40026034 <rtems_blkstats>:
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
void rtems_blkstats(FILE *output, const char *device, bool reset)
{
40026034: 9d e3 bf 38 save %sp, -200, %sp <== NOT EXECUTED
int fd = open(device, O_RDONLY);
40026038: 92 10 20 00 clr %o1 <== NOT EXECUTED
4002603c: 7f ff 7a 3c call 4000492c <open> <== NOT EXECUTED
40026040: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if (fd >= 0) {
40026044: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40026048: 06 80 00 33 bl 40026114 <rtems_blkstats+0xe0> <== NOT EXECUTED
4002604c: 01 00 00 00 nop <== NOT EXECUTED
struct stat st;
int rv;
rv = fstat(fd, &st);
40026050: 40 00 07 60 call 40027dd0 <fstat> <== NOT EXECUTED
40026054: 92 07 bf b8 add %fp, -72, %o1 <== NOT EXECUTED
if (rv == 0) {
40026058: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4002605c: 12 80 00 39 bne 40026140 <rtems_blkstats+0x10c> <== NOT EXECUTED
40026060: c4 07 bf c4 ld [ %fp + -60 ], %g2 <== NOT EXECUTED
if (S_ISBLK(st.st_mode)) {
40026064: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
40026068: 84 08 80 01 and %g2, %g1, %g2 <== NOT EXECUTED
4002606c: 03 00 00 18 sethi %hi(0x6000), %g1 <== NOT EXECUTED
40026070: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40026074: 02 80 00 19 be 400260d8 <rtems_blkstats+0xa4> <== NOT EXECUTED
40026078: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
}
}
} else {
fprintf(output, "error: not a block device\n");
4002607c: 11 10 01 7e sethi %hi(0x4005f800), %o0 <== NOT EXECUTED
40026080: 90 12 22 68 or %o0, 0x268, %o0 ! 4005fa68 <RTEMS_BDPART_MBR_MASTER_TYPE+0x40><== NOT EXECUTED
40026084: 94 10 20 1a mov 0x1a, %o2 <== NOT EXECUTED
40026088: 40 00 61 37 call 4003e564 <fwrite> <== NOT EXECUTED
4002608c: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
}
rv = close(fd);
40026090: 40 00 06 2f call 4002794c <close> <== NOT EXECUTED
40026094: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
40026098: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4002609c: 12 80 00 04 bne 400260ac <rtems_blkstats+0x78> <== NOT EXECUTED
400260a0: 01 00 00 00 nop <== NOT EXECUTED
400260a4: 81 c7 e0 08 ret <== NOT EXECUTED
400260a8: 81 e8 00 00 restore <== NOT EXECUTED
fprintf(output, "error: close device: %s\n", strerror(errno));
400260ac: 40 00 59 af call 4003c768 <__errno> <== NOT EXECUTED
400260b0: 01 00 00 00 nop <== NOT EXECUTED
400260b4: 40 00 75 54 call 40043604 <strerror> <== NOT EXECUTED
400260b8: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
400260bc: 13 10 01 7e sethi %hi(0x4005f800), %o1 <== NOT EXECUTED
400260c0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400260c4: 92 12 62 a8 or %o1, 0x2a8, %o1 <== NOT EXECUTED
400260c8: 40 00 5c 6b call 4003d274 <fprintf> <== NOT EXECUTED
400260cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400260d0: 81 c7 e0 08 ret <== NOT EXECUTED
400260d4: 81 e8 00 00 restore <== NOT EXECUTED
int rv;
rv = fstat(fd, &st);
if (rv == 0) {
if (S_ISBLK(st.st_mode)) {
if (reset) {
400260d8: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
400260dc: 12 80 00 23 bne 40026168 <rtems_blkstats+0x134> <== NOT EXECUTED
400260e0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
static inline int rtems_disk_fd_get_device_stats(
int fd,
rtems_blkdev_stats *stats
)
{
return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
400260e4: 94 07 bf 98 add %fp, -104, %o2 <== NOT EXECUTED
400260e8: 13 10 01 10 sethi %hi(0x40044000), %o1 <== NOT EXECUTED
400260ec: 40 00 0a 1d call 40028960 <ioctl> <== NOT EXECUTED
400260f0: 92 12 62 0b or %o1, 0x20b, %o1 ! 4004420b <strptime+0x467><== NOT EXECUTED
}
} else {
rtems_blkdev_stats stats;
rv = rtems_disk_fd_get_device_stats(fd, &stats);
if (rv == 0) {
400260f4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400260f8: 12 80 00 2c bne 400261a8 <rtems_blkstats+0x174> <== NOT EXECUTED
400260fc: 13 10 00 f4 sethi %hi(0x4003d000), %o1 <== NOT EXECUTED
rtems_blkdev_print_stats(
40026100: 90 07 bf 98 add %fp, -104, %o0 <== NOT EXECUTED
40026104: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
40026108: 40 00 00 32 call 400261d0 <rtems_blkdev_print_stats> <== NOT EXECUTED
4002610c: 92 12 62 74 or %o1, 0x274, %o1 <== NOT EXECUTED
40026110: 30 bf ff e0 b,a 40026090 <rtems_blkstats+0x5c> <== NOT EXECUTED
rv = close(fd);
if (rv != 0) {
fprintf(output, "error: close device: %s\n", strerror(errno));
}
} else {
fprintf(output, "error: open device: %s\n", strerror(errno));
40026114: 40 00 59 95 call 4003c768 <__errno> <== NOT EXECUTED
40026118: 01 00 00 00 nop <== NOT EXECUTED
4002611c: 40 00 75 3a call 40043604 <strerror> <== NOT EXECUTED
40026120: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40026124: 13 10 01 7e sethi %hi(0x4005f800), %o1 <== NOT EXECUTED
40026128: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4002612c: 92 12 62 c8 or %o1, 0x2c8, %o1 <== NOT EXECUTED
40026130: 40 00 5c 51 call 4003d274 <fprintf> <== NOT EXECUTED
40026134: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40026138: 81 c7 e0 08 ret <== NOT EXECUTED
4002613c: 81 e8 00 00 restore <== NOT EXECUTED
}
} else {
fprintf(output, "error: not a block device\n");
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
40026140: 40 00 59 8a call 4003c768 <__errno> <== NOT EXECUTED
40026144: 01 00 00 00 nop <== NOT EXECUTED
40026148: 40 00 75 2f call 40043604 <strerror> <== NOT EXECUTED
4002614c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40026150: 13 10 01 7e sethi %hi(0x4005f800), %o1 <== NOT EXECUTED
40026154: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40026158: 92 12 62 88 or %o1, 0x288, %o1 <== NOT EXECUTED
4002615c: 40 00 5c 46 call 4003d274 <fprintf> <== NOT EXECUTED
40026160: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40026164: 30 bf ff cb b,a 40026090 <rtems_blkstats+0x5c> <== NOT EXECUTED
}
static inline int rtems_disk_fd_reset_device_stats(int fd)
{
return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);
40026168: 13 08 00 10 sethi %hi(0x20004000), %o1 <== NOT EXECUTED
4002616c: 40 00 09 fd call 40028960 <ioctl> <== NOT EXECUTED
40026170: 92 12 62 0c or %o1, 0x20c, %o1 ! 2000420c <RAM_SIZE+0x1fc0420c><== NOT EXECUTED
rv = fstat(fd, &st);
if (rv == 0) {
if (S_ISBLK(st.st_mode)) {
if (reset) {
rv = rtems_disk_fd_reset_device_stats(fd);
if (rv != 0) {
40026174: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40026178: 02 bf ff c6 be 40026090 <rtems_blkstats+0x5c> <== NOT EXECUTED
4002617c: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: reset stats: %s\n", strerror(errno));
40026180: 40 00 59 7a call 4003c768 <__errno> <== NOT EXECUTED
40026184: 01 00 00 00 nop <== NOT EXECUTED
40026188: 40 00 75 1f call 40043604 <strerror> <== NOT EXECUTED
4002618c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40026190: 13 10 01 7e sethi %hi(0x4005f800), %o1 <== NOT EXECUTED
40026194: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40026198: 92 12 62 38 or %o1, 0x238, %o1 <== NOT EXECUTED
4002619c: 40 00 5c 36 call 4003d274 <fprintf> <== NOT EXECUTED
400261a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400261a4: 30 bf ff bb b,a 40026090 <rtems_blkstats+0x5c> <== NOT EXECUTED
&stats,
(rtems_printk_plugin_t) fprintf,
output
);
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
400261a8: 40 00 59 70 call 4003c768 <__errno> <== NOT EXECUTED
400261ac: 01 00 00 00 nop <== NOT EXECUTED
400261b0: 40 00 75 15 call 40043604 <strerror> <== NOT EXECUTED
400261b4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
400261b8: 13 10 01 7e sethi %hi(0x4005f800), %o1 <== NOT EXECUTED
400261bc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400261c0: 92 12 62 50 or %o1, 0x250, %o1 <== NOT EXECUTED
400261c4: 40 00 5c 2c call 4003d274 <fprintf> <== NOT EXECUTED
400261c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400261cc: 30 bf ff b1 b,a 40026090 <rtems_blkstats+0x5c> <== NOT EXECUTED
40003b2c <rtems_bsp_cmdline_get_param>:
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
40003b2c: 9d e3 bf a0 save %sp, -96, %sp
const char *p;
if ( !name )
40003b30: 80 a6 20 00 cmp %i0, 0
40003b34: 02 80 00 36 be 40003c0c <rtems_bsp_cmdline_get_param+0xe0>
40003b38: 80 a6 60 00 cmp %i1, 0
return NULL;
if ( !value )
40003b3c: 02 80 00 34 be 40003c0c <rtems_bsp_cmdline_get_param+0xe0>
40003b40: 80 a6 a0 00 cmp %i2, 0
return NULL;
if ( !length )
40003b44: 22 80 00 33 be,a 40003c10 <rtems_bsp_cmdline_get_param+0xe4>
40003b48: b2 10 20 00 clr %i1
return NULL;
value[0] = '\0';
40003b4c: c0 2e 40 00 clrb [ %i1 ]
p = rtems_bsp_cmdline_get_param_raw( name );
40003b50: 40 00 00 32 call 40003c18 <rtems_bsp_cmdline_get_param_raw>
40003b54: 90 10 00 18 mov %i0, %o0
if ( !p )
40003b58: 80 a2 20 00 cmp %o0, 0
40003b5c: 22 80 00 2d be,a 40003c10 <rtems_bsp_cmdline_get_param+0xe4>
40003b60: b2 10 20 00 clr %i1
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
40003b64: c6 0a 00 00 ldub [ %o0 ], %g3
40003b68: 85 28 e0 18 sll %g3, 0x18, %g2
40003b6c: 80 a0 a0 00 cmp %g2, 0
40003b70: 02 80 00 25 be 40003c04 <rtems_bsp_cmdline_get_param+0xd8><== NEVER TAKEN
40003b74: 80 a6 a0 01 cmp %i2, 1
40003b78: 02 80 00 23 be 40003c04 <rtems_bsp_cmdline_get_param+0xd8><== NEVER TAKEN
40003b7c: b4 06 bf ff add %i2, -1, %i2
value[i] = '\0';
}
}
const char *rtems_bsp_cmdline_get_param(
40003b80: 82 10 20 00 clr %g1
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
40003b84: 88 10 20 00 clr %g4
value[i] = '\0';
}
}
const char *rtems_bsp_cmdline_get_param(
40003b88: 10 80 00 12 b 40003bd0 <rtems_bsp_cmdline_get_param+0xa4>
40003b8c: ba 10 20 00 clr %i5
quotes=0;
for (i=0 ; *p && i<length-1; ) {
if ( *p == '\"' ) {
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
40003b90: 32 80 00 06 bne,a 40003ba8 <rtems_bsp_cmdline_get_param+0x7c>
40003b94: c6 2e 40 04 stb %g3, [ %i1 + %g4 ]
40003b98: 80 a0 a0 20 cmp %g2, 0x20
40003b9c: 02 80 00 1a be 40003c04 <rtems_bsp_cmdline_get_param+0xd8>
40003ba0: 01 00 00 00 nop
break;
value[i++] = *p++;
40003ba4: c6 2e 40 04 stb %g3, [ %i1 + %g4 ]
40003ba8: 82 00 60 01 inc %g1
value[i] = '\0';
40003bac: c0 2e 40 01 clrb [ %i1 + %g1 ]
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
40003bb0: c6 0a 00 01 ldub [ %o0 + %g1 ], %g3
40003bb4: 85 28 e0 18 sll %g3, 0x18, %g2
40003bb8: 80 a0 a0 00 cmp %g2, 0
40003bbc: 02 80 00 12 be 40003c04 <rtems_bsp_cmdline_get_param+0xd8>
40003bc0: 88 10 00 01 mov %g1, %g4
40003bc4: 80 a0 40 1a cmp %g1, %i2
40003bc8: 02 80 00 0f be 40003c04 <rtems_bsp_cmdline_get_param+0xd8>
40003bcc: 01 00 00 00 nop
if ( *p == '\"' ) {
40003bd0: 85 38 a0 18 sra %g2, 0x18, %g2
40003bd4: 80 a0 a0 22 cmp %g2, 0x22
40003bd8: 12 bf ff ee bne 40003b90 <rtems_bsp_cmdline_get_param+0x64>
40003bdc: 80 8f 60 01 btst 1, %i5
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
break;
value[i++] = *p++;
40003be0: c6 2e 40 04 stb %g3, [ %i1 + %g4 ]
40003be4: 82 00 60 01 inc %g1
value[i] = '\0';
40003be8: c0 2e 40 01 clrb [ %i1 + %g1 ]
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
40003bec: c6 0a 00 01 ldub [ %o0 + %g1 ], %g3
if ( *p == '\"' ) {
quotes++;
40003bf0: ba 07 60 01 inc %i5
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
40003bf4: 85 28 e0 18 sll %g3, 0x18, %g2
40003bf8: 80 a0 a0 00 cmp %g2, 0
40003bfc: 12 bf ff f2 bne 40003bc4 <rtems_bsp_cmdline_get_param+0x98><== ALWAYS TAKEN
40003c00: 88 10 00 01 mov %g1, %g4
return NULL;
copy_string( p, value, length );
return value;
}
40003c04: 81 c7 e0 08 ret
40003c08: 91 e8 00 19 restore %g0, %i1, %o0
)
{
const char *p;
if ( !name )
return NULL;
40003c0c: b2 10 20 00 clr %i1
return NULL;
copy_string( p, value, length );
return value;
}
40003c10: 81 c7 e0 08 ret
40003c14: 91 e8 00 19 restore %g0, %i1, %o0
40008f10 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
40008f10: 9d e3 bf 98 save %sp, -104, %sp
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
40008f14: 40 00 01 a1 call 40009598 <_Chain_Get>
40008f18: 90 10 00 18 mov %i0, %o0
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
40008f1c: 92 10 20 00 clr %o1
40008f20: ba 10 00 08 mov %o0, %i5
40008f24: 94 10 00 1a mov %i2, %o2
40008f28: 90 10 00 19 mov %i1, %o0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
40008f2c: 80 a7 60 00 cmp %i5, 0
40008f30: 12 80 00 0a bne 40008f58 <rtems_chain_get_with_wait+0x48>
40008f34: 96 07 bf fc add %fp, -4, %o3
) {
rtems_event_set out;
sc = rtems_event_receive(
40008f38: 7f ff fc df call 400082b4 <rtems_event_receive>
40008f3c: 01 00 00 00 nop
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
40008f40: 80 a2 20 00 cmp %o0, 0
40008f44: 02 bf ff f4 be 40008f14 <rtems_chain_get_with_wait+0x4> <== NEVER TAKEN
40008f48: 01 00 00 00 nop
timeout,
&out
);
}
*node_ptr = node;
40008f4c: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
40008f50: 81 c7 e0 08 ret
40008f54: 91 e8 00 08 restore %g0, %o0, %o0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
40008f58: 90 10 20 00 clr %o0
timeout,
&out
);
}
*node_ptr = node;
40008f5c: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
40008f60: 81 c7 e0 08 ret
40008f64: 91 e8 00 08 restore %g0, %o0, %o0
400044e4 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
400044e4: 9d e3 bf 70 save %sp, -144, %sp
uint32_t seconds, nanoseconds;
#else
uint32_t total_units = 0;
#endif
if ( !print )
400044e8: 80 a6 60 00 cmp %i1, 0
400044ec: 02 80 00 85 be 40004700 <rtems_cpu_usage_report_with_plugin+0x21c><== NEVER TAKEN
400044f0: 03 10 00 8d sethi %hi(0x40023400), %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
400044f4: c0 27 bf e0 clr [ %fp + -32 ]
400044f8: c0 27 bf e4 clr [ %fp + -28 ]
}
}
}
#endif
(*print)(
400044fc: 90 10 00 18 mov %i0, %o0
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
40004500: f8 18 60 90 ldd [ %g1 + 0x90 ], %i4
}
}
}
#endif
(*print)(
40004504: 13 10 00 7f sethi %hi(0x4001fc00), %o1
40004508: 2b 10 00 8b sethi %hi(0x40022c00), %l5
4000450c: 92 12 62 08 or %o1, 0x208, %o1
40004510: aa 15 62 48 or %l5, 0x248, %l5
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
40004514: 25 10 00 7f sethi %hi(0x4001fc00), %l2
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
40004518: 29 10 00 8b sethi %hi(0x40022c00), %l4
}
}
}
#endif
(*print)(
4000451c: 9f c6 40 00 call %i1
40004520: 27 10 00 7f sethi %hi(0x4001fc00), %l3
#endif
/*
* rtems_cpu_usage_report
*/
void rtems_cpu_usage_report_with_plugin(
40004524: ac 05 60 0c add %l5, 0xc, %l6
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
40004528: a4 14 a3 80 or %l2, 0x380, %l2
4000452c: a8 15 22 30 or %l4, 0x230, %l4
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
40004530: a6 14 e3 98 or %l3, 0x398, %l3
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
40004534: c2 05 40 00 ld [ %l5 ], %g1
40004538: e2 00 60 04 ld [ %g1 + 4 ], %l1
if ( information ) {
4000453c: 80 a4 60 00 cmp %l1, 0
40004540: 22 80 00 56 be,a 40004698 <rtems_cpu_usage_report_with_plugin+0x1b4><== NEVER TAKEN
40004544: aa 05 60 04 add %l5, 4, %l5 <== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
40004548: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1
4000454c: 86 90 60 00 orcc %g1, 0, %g3
40004550: 02 80 00 51 be 40004694 <rtems_cpu_usage_report_with_plugin+0x1b0>
40004554: a0 10 20 01 mov 1, %l0
the_thread = (Thread_Control *)information->local_table[ i ];
40004558: 10 80 00 2d b 4000460c <rtems_cpu_usage_report_with_plugin+0x128>
4000455c: c4 04 60 1c ld [ %l1 + 0x1c ], %g2
40004560: 90 07 bf d8 add %fp, -40, %o0
40004564: 40 00 19 d2 call 4000acac <_TOD_Get_with_nanoseconds>
40004568: 92 10 00 14 mov %l4, %o1
4000456c: c4 1f bf d8 ldd [ %fp + -40 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
40004570: 86 a0 c0 1d subcc %g3, %i5, %g3
40004574: 84 60 80 1c subx %g2, %i4, %g2
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
_Timestamp_Divide( &ran, &total, &ival, &fval );
40004578: 90 07 bf e8 add %fp, -24, %o0
4000457c: c4 3f bf e0 std %g2, [ %fp + -32 ]
40004580: 92 07 bf e0 add %fp, -32, %o1
40004584: 94 07 bf d0 add %fp, -48, %o2
40004588: 40 00 23 aa call 4000d430 <_Timestamp64_Divide>
4000458c: 96 07 bf d4 add %fp, -44, %o3
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
40004590: 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);
40004594: 94 10 20 00 clr %o2
40004598: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
4000459c: 90 10 00 1a mov %i2, %o0
400045a0: 96 12 e2 00 or %o3, 0x200, %o3
400045a4: 40 00 5e f7 call 4001c180 <__divdi3>
400045a8: 92 10 00 1b mov %i3, %o1
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
400045ac: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
400045b0: ae 10 00 09 mov %o1, %l7
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
400045b4: 90 10 00 1a mov %i2, %o0
400045b8: 92 10 00 1b mov %i3, %o1
400045bc: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400045c0: 40 00 5f db call 4001c52c <__moddi3>
400045c4: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
400045c8: 90 10 00 09 mov %o1, %o0
400045cc: 40 00 5d 95 call 4001bc20 <.udiv>
400045d0: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
400045d4: d8 1f bf d0 ldd [ %fp + -48 ], %o4
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
400045d8: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
400045dc: 92 10 00 13 mov %l3, %o1
400045e0: 90 10 00 18 mov %i0, %o0
400045e4: 9f c6 40 00 call %i1
400045e8: 94 10 00 17 mov %l7, %o2
400045ec: c6 14 60 10 lduh [ %l1 + 0x10 ], %g3
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
400045f0: a0 04 20 01 inc %l0
400045f4: 83 28 e0 10 sll %g3, 0x10, %g1
400045f8: 83 30 60 10 srl %g1, 0x10, %g1
400045fc: 80 a0 40 10 cmp %g1, %l0
40004600: 2a 80 00 26 bcs,a 40004698 <rtems_cpu_usage_report_with_plugin+0x1b4>
40004604: aa 05 60 04 add %l5, 4, %l5
the_thread = (Thread_Control *)information->local_table[ i ];
40004608: c4 04 60 1c ld [ %l1 + 0x1c ], %g2
4000460c: 83 2c 20 02 sll %l0, 2, %g1
40004610: f6 00 80 01 ld [ %g2 + %g1 ], %i3
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
40004614: 94 07 bf f0 add %fp, -16, %o2
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
40004618: 80 a6 e0 00 cmp %i3, 0
4000461c: 02 bf ff f5 be 400045f0 <rtems_cpu_usage_report_with_plugin+0x10c><== NEVER TAKEN
40004620: 92 10 20 0d mov 0xd, %o1
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
40004624: 40 00 14 35 call 400096f8 <rtems_object_get_name>
40004628: d0 06 e0 08 ld [ %i3 + 8 ], %o0
(*print)(
4000462c: d4 06 e0 08 ld [ %i3 + 8 ], %o2
40004630: 90 10 00 18 mov %i0, %o0
40004634: 92 10 00 12 mov %l2, %o1
40004638: 9f c6 40 00 call %i1
4000463c: 96 07 bf f0 add %fp, -16, %o3
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
40004640: 03 10 00 8d sethi %hi(0x40023400), %g1
40004644: 82 10 60 30 or %g1, 0x30, %g1 ! 40023430 <_Per_CPU_Information>
40004648: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
4000464c: 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 ) {
40004650: f4 01 20 08 ld [ %g4 + 8 ], %i2
40004654: c8 06 e0 08 ld [ %i3 + 8 ], %g4
40004658: 80 a6 80 04 cmp %i2, %g4
4000465c: 12 bf ff c1 bne 40004560 <rtems_cpu_usage_report_with_plugin+0x7c>
40004660: c4 3f bf e8 std %g2, [ %fp + -24 ]
*time_of_context_switch = _Thread_Time_of_last_context_switch;
40004664: f4 18 60 20 ldd [ %g1 + 0x20 ], %i2
40004668: 92 10 00 14 mov %l4, %o1
4000466c: 40 00 19 90 call 4000acac <_TOD_Get_with_nanoseconds>
40004670: 90 07 bf d8 add %fp, -40, %o0
*/
ran = the_thread->cpu_time_used;
if ( is_executing_on_a_core( the_thread, &last ) ) {
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
40004674: c4 1f bf d8 ldd [ %fp + -40 ], %g2
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
40004678: 96 a0 c0 1b subcc %g3, %i3, %o3
4000467c: 94 60 80 1a subx %g2, %i2, %o2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
40004680: f4 1f bf e8 ldd [ %fp + -24 ], %i2
40004684: 9a 86 c0 0b addcc %i3, %o3, %o5
40004688: 98 46 80 0a addx %i2, %o2, %o4
4000468c: 10 bf ff b9 b 40004570 <rtems_cpu_usage_report_with_plugin+0x8c>
40004690: d8 3f bf e8 std %o4, [ %fp + -24 ]
40004694: aa 05 60 04 add %l5, 4, %l5
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
40004698: 80 a5 40 16 cmp %l5, %l6
4000469c: 32 bf ff a7 bne,a 40004538 <rtems_cpu_usage_report_with_plugin+0x54>
400046a0: c2 05 40 00 ld [ %l5 ], %g1
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
400046a4: f8 1f bf e0 ldd [ %fp + -32 ], %i4
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
400046a8: 94 10 20 00 clr %o2
400046ac: 90 10 00 1c mov %i4, %o0
400046b0: 92 10 00 1d mov %i5, %o1
400046b4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400046b8: 40 00 5e b2 call 4001c180 <__divdi3>
400046bc: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
400046c0: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
400046c4: b6 10 00 09 mov %o1, %i3
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
400046c8: 90 10 00 1c mov %i4, %o0
400046cc: 92 10 00 1d mov %i5, %o1
400046d0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400046d4: 40 00 5f 96 call 4001c52c <__moddi3>
400046d8: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
400046dc: 90 10 00 09 mov %o1, %o0
400046e0: 40 00 5d 50 call 4001bc20 <.udiv>
400046e4: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
400046e8: 94 10 00 1b mov %i3, %o2
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
400046ec: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
400046f0: 13 10 00 7f sethi %hi(0x4001fc00), %o1
400046f4: 90 10 00 18 mov %i0, %o0
400046f8: 9f c6 40 00 call %i1
400046fc: 92 12 63 b0 or %o1, 0x3b0, %o1
40004700: 81 c7 e0 08 ret
40004704: 81 e8 00 00 restore
40010854 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
40010854: 9d e3 bf a0 save %sp, -96, %sp
40010858: 82 10 00 18 mov %i0, %g1
if (sc == RTEMS_SUCCESSFUL) {
4001085c: 80 a0 60 00 cmp %g1, 0
40010860: 02 80 00 0c be 40010890 <rtems_deviceio_errno+0x3c>
40010864: b0 10 20 00 clr %i0
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
40010868: 80 a0 60 1c cmp %g1, 0x1c
4001086c: 18 80 00 06 bgu 40010884 <rtems_deviceio_errno+0x30> <== NEVER TAKEN
40010870: ba 10 20 16 mov 0x16, %i5
eno = status_code_to_errno [sc];
40010874: 83 28 60 02 sll %g1, 2, %g1
40010878: 05 10 00 79 sethi %hi(0x4001e400), %g2
4001087c: 84 10 a3 ac or %g2, 0x3ac, %g2 ! 4001e7ac <status_code_to_errno>
40010880: fa 00 80 01 ld [ %g2 + %g1 ], %i5
}
errno = eno;
40010884: 40 00 00 2f call 40010940 <__errno>
40010888: b0 10 3f ff mov -1, %i0
4001088c: fa 22 00 00 st %i5, [ %o0 ]
return -1;
}
}
40010890: 81 c7 e0 08 ret
40010894: 81 e8 00 00 restore
40004610 <rtems_disk_create_log>:
dev_t phys,
rtems_blkdev_bnum block_begin,
rtems_blkdev_bnum block_count,
const char *name
)
{
40004610: 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;
40004614: c0 27 bf f8 clr [ %fp + -8 ]
char *alloc_name = NULL;
sc = disk_lock();
40004618: 7f ff fe f5 call 400041ec <disk_lock>
4000461c: c0 27 bf fc clr [ %fp + -4 ]
if (sc != RTEMS_SUCCESSFUL) {
40004620: a0 92 20 00 orcc %o0, 0, %l0
40004624: 02 80 00 04 be 40004634 <rtems_disk_create_log+0x24> <== ALWAYS TAKEN
40004628: 92 10 00 1b mov %i3, %o1
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
4000462c: 81 c7 e0 08 ret <== NOT EXECUTED
40004630: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
phys_dd = get_disk_entry(phys, true);
40004634: 90 10 00 1a mov %i2, %o0
40004638: 7f ff fe b0 call 400040f8 <get_disk_entry>
4000463c: 94 10 20 01 mov 1, %o2
if (phys_dd == NULL) {
40004640: b6 92 20 00 orcc %o0, 0, %i3
40004644: 02 80 00 25 be 400046d8 <rtems_disk_create_log+0xc8>
40004648: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
disk_unlock();
return RTEMS_INVALID_ID;
}
sc = create_disk(dev, name, &dd, &alloc_name);
4000464c: 90 10 00 18 mov %i0, %o0
40004650: 92 10 00 19 mov %i1, %o1
40004654: 96 07 bf f8 add %fp, -8, %o3
40004658: 7f ff ff 03 call 40004264 <create_disk>
4000465c: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
40004660: a0 92 20 00 orcc %o0, 0, %l0
40004664: 12 80 00 19 bne 400046c8 <rtems_disk_create_log+0xb8>
40004668: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_log(
4000466c: 92 10 00 1b mov %i3, %o1
40004670: 94 10 00 1c mov %i4, %o2
40004674: 40 00 31 91 call 40010cb8 <rtems_disk_init_log>
40004678: 96 10 00 1d mov %i5, %o3
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
4000467c: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
++phys_dd->uses;
40004680: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
block_begin,
block_count
);
dd->dev = dev;
dd->name = alloc_name;
40004684: c6 07 bf fc ld [ %fp + -4 ], %g3
++phys_dd->uses;
40004688: 84 00 a0 01 inc %g2
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
4000468c: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
40004690: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
++phys_dd->uses;
40004694: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
if (sc != RTEMS_SUCCESSFUL) {
40004698: 80 a2 20 00 cmp %o0, 0
4000469c: 02 80 00 0b be 400046c8 <rtems_disk_create_log+0xb8>
400046a0: a0 10 00 08 mov %o0, %l0
dd->ioctl = null_handler;
400046a4: 05 10 00 10 sethi %hi(0x40004000), %g2
400046a8: 84 10 a1 8c or %g2, 0x18c, %g2 ! 4000418c <null_handler>
rtems_disk_delete(dev);
400046ac: 92 10 00 19 mov %i1, %o1
dd->name = alloc_name;
++phys_dd->uses;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
400046b0: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
400046b4: 7f ff ff 5c call 40004424 <rtems_disk_delete>
400046b8: 90 10 00 18 mov %i0, %o0
disk_unlock();
400046bc: 7f ff fe db call 40004228 <disk_unlock>
400046c0: b0 10 00 10 mov %l0, %i0
400046c4: 30 80 00 03 b,a 400046d0 <rtems_disk_create_log+0xc0>
return sc;
}
disk_unlock();
400046c8: 7f ff fe d8 call 40004228 <disk_unlock>
400046cc: b0 10 00 10 mov %l0, %i0
return RTEMS_SUCCESSFUL;
}
400046d0: 81 c7 e0 08 ret
400046d4: 81 e8 00 00 restore
return sc;
}
phys_dd = get_disk_entry(phys, true);
if (phys_dd == NULL) {
disk_unlock();
400046d8: 7f ff fe d4 call 40004228 <disk_unlock>
400046dc: a0 10 20 04 mov 4, %l0
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
400046e0: 81 c7 e0 08 ret
400046e4: 91 e8 00 10 restore %g0, %l0, %o0
400046e8 <rtems_disk_create_phys>:
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
400046e8: 9d e3 bf 98 save %sp, -104, %sp
rtems_disk_device *dd = NULL;
400046ec: c0 27 bf f8 clr [ %fp + -8 ]
rtems_status_code sc = RTEMS_SUCCESSFUL;
char *alloc_name = NULL;
400046f0: c0 27 bf fc clr [ %fp + -4 ]
if (handler == NULL) {
400046f4: 80 a7 20 00 cmp %i4, 0
400046f8: 02 80 00 07 be 40004714 <rtems_disk_create_phys+0x2c>
400046fc: a0 10 20 09 mov 9, %l0
return RTEMS_INVALID_ADDRESS;
}
sc = disk_lock();
40004700: 7f ff fe bb call 400041ec <disk_lock>
40004704: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40004708: a0 92 20 00 orcc %o0, 0, %l0
4000470c: 02 80 00 04 be 4000471c <rtems_disk_create_phys+0x34> <== ALWAYS TAKEN
40004710: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
40004714: 81 c7 e0 08 ret
40004718: 91 e8 00 10 restore %g0, %l0, %o0
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
sc = create_disk(dev, name, &dd, &alloc_name);
4000471c: 90 10 00 18 mov %i0, %o0
40004720: 92 10 00 19 mov %i1, %o1
40004724: 96 07 bf f8 add %fp, -8, %o3
40004728: 7f ff fe cf call 40004264 <create_disk>
4000472c: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
40004730: a0 92 20 00 orcc %o0, 0, %l0
40004734: 12 80 00 0e bne 4000476c <rtems_disk_create_phys+0x84>
40004738: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_phys(
4000473c: 92 10 00 1a mov %i2, %o1
40004740: 94 10 00 1b mov %i3, %o2
40004744: 96 10 00 1c mov %i4, %o3
40004748: 40 00 31 42 call 40010c50 <rtems_disk_init_phys>
4000474c: 98 10 00 1d mov %i5, %o4
block_count,
handler,
driver_data
);
dd->dev = dev;
40004750: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
40004754: c4 07 bf fc ld [ %fp + -4 ], %g2
block_count,
handler,
driver_data
);
dd->dev = dev;
40004758: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
4000475c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if (sc != RTEMS_SUCCESSFUL) {
40004760: 80 a2 20 00 cmp %o0, 0
40004764: 12 80 00 06 bne 4000477c <rtems_disk_create_phys+0x94>
40004768: a0 10 00 08 mov %o0, %l0
disk_unlock();
return sc;
}
disk_unlock();
4000476c: 7f ff fe af call 40004228 <disk_unlock>
40004770: b0 10 00 10 mov %l0, %i0
return RTEMS_SUCCESSFUL;
}
40004774: 81 c7 e0 08 ret
40004778: 81 e8 00 00 restore
dd->dev = dev;
dd->name = alloc_name;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
4000477c: 05 10 00 10 sethi %hi(0x40004000), %g2
40004780: 84 10 a1 8c or %g2, 0x18c, %g2 ! 4000418c <null_handler>
rtems_disk_delete(dev);
40004784: 92 10 00 19 mov %i1, %o1
dd->dev = dev;
dd->name = alloc_name;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
40004788: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
4000478c: 7f ff ff 26 call 40004424 <rtems_disk_delete>
40004790: 90 10 00 18 mov %i0, %o0
disk_unlock();
40004794: 7f ff fe a5 call 40004228 <disk_unlock>
40004798: b0 10 00 10 mov %l0, %i0
4000479c: 30 bf ff f6 b,a 40004774 <rtems_disk_create_phys+0x8c>
40004424 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
40004424: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
40004428: 7f ff ff 71 call 400041ec <disk_lock>
4000442c: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40004430: a0 92 20 00 orcc %o0, 0, %l0
40004434: 02 80 00 04 be 40004444 <rtems_disk_delete+0x20> <== ALWAYS TAKEN
40004438: 90 10 00 18 mov %i0, %o0
rtems_disk_cleanup(dd);
disk_unlock();
return RTEMS_SUCCESSFUL;
}
4000443c: 81 c7 e0 08 ret <== NOT EXECUTED
40004440: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
dd = get_disk_entry(dev, true);
40004444: 92 10 00 19 mov %i1, %o1
40004448: 7f ff ff 2c call 400040f8 <get_disk_entry>
4000444c: 94 10 20 01 mov 1, %o2
if (dd == NULL) {
40004450: 82 92 20 00 orcc %o0, 0, %g1
40004454: 02 80 00 5e be 400045cc <rtems_disk_delete+0x1a8> <== NEVER TAKEN
40004458: 84 10 20 01 mov 1, %g2
}
static void
rtems_disk_cleanup(rtems_disk_device *disk_to_remove)
{
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
4000445c: e2 00 60 08 ld [ %g1 + 8 ], %l1
disk_unlock();
return RTEMS_INVALID_ID;
}
dd->deleted = true;
40004460: 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) {
40004464: c4 0c 60 40 ldub [ %l1 + 0x40 ], %g2
40004468: 80 a0 a0 00 cmp %g2, 0
4000446c: 22 80 00 43 be,a 40004578 <rtems_disk_delete+0x154>
40004470: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
40004474: 2b 10 00 71 sethi %hi(0x4001c400), %l5
40004478: c2 05 60 70 ld [ %l5 + 0x70 ], %g1 ! 4001c470 <disktab_size>
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
4000447c: f2 04 40 00 ld [ %l1 ], %i1
40004480: e4 04 60 04 ld [ %l1 + 4 ], %l2
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
40004484: 80 a0 60 00 cmp %g1, 0
40004488: 02 80 00 33 be 40004554 <rtems_disk_delete+0x130> <== NEVER TAKEN
4000448c: a8 10 20 00 clr %l4
40004490: 2d 10 00 71 sethi %hi(0x4001c400), %l6
40004494: b0 10 20 00 clr %i0
40004498: ac 15 a0 74 or %l6, 0x74, %l6
4000449c: aa 15 60 70 or %l5, 0x70, %l5
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
400044a0: a6 10 20 01 mov 1, %l3
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
400044a4: f6 05 80 00 ld [ %l6 ], %i3
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
400044a8: 83 2e 20 03 sll %i0, 3, %g1
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
400044ac: b6 06 c0 01 add %i3, %g1, %i3
for (minor = 0; minor < dtab->size; ++minor) {
400044b0: f4 06 e0 04 ld [ %i3 + 4 ], %i2
400044b4: 80 a6 a0 00 cmp %i2, 0
400044b8: 22 80 00 23 be,a 40004544 <rtems_disk_delete+0x120>
400044bc: c2 05 40 00 ld [ %l5 ], %g1
400044c0: 10 80 00 06 b 400044d8 <rtems_disk_delete+0xb4>
400044c4: ba 10 20 00 clr %i5
400044c8: ba 07 60 01 inc %i5
400044cc: 80 a7 40 1a cmp %i5, %i2
400044d0: 3a 80 00 1d bcc,a 40004544 <rtems_disk_delete+0x120>
400044d4: c2 05 40 00 ld [ %l5 ], %g1
rtems_disk_device *dd = dtab->minor [minor];
400044d8: c6 06 c0 00 ld [ %i3 ], %g3
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
400044dc: 85 2f 60 02 sll %i5, 2, %g2
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
400044e0: d0 00 c0 02 ld [ %g3 + %g2 ], %o0
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
400044e4: 80 a2 20 00 cmp %o0, 0
400044e8: 22 bf ff f9 be,a 400044cc <rtems_disk_delete+0xa8>
400044ec: ba 07 60 01 inc %i5
400044f0: c8 02 20 08 ld [ %o0 + 8 ], %g4
400044f4: f8 01 00 00 ld [ %g4 ], %i4
400044f8: 80 a7 00 19 cmp %i4, %i1
400044fc: 32 bf ff f4 bne,a 400044cc <rtems_disk_delete+0xa8> <== NEVER TAKEN
40004500: ba 07 60 01 inc %i5 <== NOT EXECUTED
40004504: c8 01 20 04 ld [ %g4 + 4 ], %g4
40004508: 80 a1 00 12 cmp %g4, %l2
4000450c: 32 bf ff f0 bne,a 400044cc <rtems_disk_delete+0xa8> <== NEVER TAKEN
40004510: ba 07 60 01 inc %i5 <== NOT EXECUTED
40004514: 80 a4 40 08 cmp %l1, %o0
40004518: 22 bf ff ed be,a 400044cc <rtems_disk_delete+0xa8>
4000451c: ba 07 60 01 inc %i5
if (dd->uses == 0) {
40004520: c8 02 20 14 ld [ %o0 + 0x14 ], %g4
40004524: 80 a1 20 00 cmp %g4, 0
40004528: 22 80 00 25 be,a 400045bc <rtems_disk_delete+0x198>
4000452c: 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) {
40004530: ba 07 60 01 inc %i5
40004534: 80 a7 40 1a cmp %i5, %i2
40004538: 0a bf ff e8 bcs 400044d8 <rtems_disk_delete+0xb4> <== ALWAYS TAKEN
4000453c: e6 2a 20 40 stb %l3, [ %o0 + 0x40 ]
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
40004540: c2 05 40 00 ld [ %l5 ], %g1 <== NOT EXECUTED
40004544: b0 06 20 01 inc %i0
40004548: 80 a6 00 01 cmp %i0, %g1
4000454c: 2a bf ff d7 bcs,a 400044a8 <rtems_disk_delete+0x84>
40004550: f6 05 80 00 ld [ %l6 ], %i3
}
}
}
}
physical_disk->uses -= deleted_count;
40004554: c2 04 60 14 ld [ %l1 + 0x14 ], %g1
40004558: a8 20 40 14 sub %g1, %l4, %l4
if (physical_disk->uses == 0) {
4000455c: 80 a5 20 00 cmp %l4, 0
40004560: 02 80 00 1f be 400045dc <rtems_disk_delete+0x1b8>
40004564: e8 24 60 14 st %l4, [ %l1 + 0x14 ]
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
40004568: 7f ff ff 30 call 40004228 <disk_unlock>
4000456c: b0 10 00 10 mov %l0, %i0
return RTEMS_SUCCESSFUL;
}
40004570: 81 c7 e0 08 ret
40004574: 81 e8 00 00 restore
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
40004578: 80 a0 a0 00 cmp %g2, 0
4000457c: 12 bf ff fb bne 40004568 <rtems_disk_delete+0x144> <== NEVER TAKEN
40004580: 07 10 00 71 sethi %hi(0x4001c400), %g3
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
40004584: c4 00 40 00 ld [ %g1 ], %g2
disktab [major].minor [minor] = NULL;
40004588: c8 00 e0 74 ld [ %g3 + 0x74 ], %g4
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
4000458c: c2 00 60 04 ld [ %g1 + 4 ], %g1
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
40004590: c6 04 60 14 ld [ %l1 + 0x14 ], %g3
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
40004594: 85 28 a0 03 sll %g2, 3, %g2
40004598: c4 01 00 02 ld [ %g4 + %g2 ], %g2
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
4000459c: 86 00 ff ff add %g3, -1, %g3
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
400045a0: 83 28 60 02 sll %g1, 2, %g1
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
400045a4: c6 24 60 14 st %g3, [ %l1 + 0x14 ]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
free_disk_device(disk_to_remove);
400045a8: 7f ff fe fb call 40004194 <free_disk_device>
400045ac: c0 20 80 01 clr [ %g2 + %g1 ]
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
400045b0: 7f ff ff 1e call 40004228 <disk_unlock>
400045b4: b0 10 00 10 mov %l0, %i0
400045b8: 30 bf ff ee b,a 40004570 <rtems_disk_delete+0x14c>
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
400045bc: 7f ff fe f6 call 40004194 <free_disk_device>
400045c0: a8 05 20 01 inc %l4
400045c4: 10 bf ff c1 b 400044c8 <rtems_disk_delete+0xa4>
400045c8: f4 06 e0 04 ld [ %i3 + 4 ], %i2
return sc;
}
dd = get_disk_entry(dev, true);
if (dd == NULL) {
disk_unlock();
400045cc: 7f ff ff 17 call 40004228 <disk_unlock> <== NOT EXECUTED
400045d0: a0 10 20 04 mov 4, %l0 <== NOT EXECUTED
rtems_disk_cleanup(dd);
disk_unlock();
return RTEMS_SUCCESSFUL;
}
400045d4: 81 c7 e0 08 ret <== NOT EXECUTED
400045d8: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
400045dc: c4 04 40 00 ld [ %l1 ], %g2
disktab [major].minor [minor] = NULL;
400045e0: 03 10 00 71 sethi %hi(0x4001c400), %g1
400045e4: c6 00 60 74 ld [ %g1 + 0x74 ], %g3 ! 4001c474 <disktab>
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
400045e8: c2 04 60 04 ld [ %l1 + 4 ], %g1
disktab [major].minor [minor] = NULL;
400045ec: 85 28 a0 03 sll %g2, 3, %g2
400045f0: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
400045f4: 83 28 60 02 sll %g1, 2, %g1
free_disk_device(physical_disk);
400045f8: 90 10 00 11 mov %l1, %o0
400045fc: 7f ff fe e6 call 40004194 <free_disk_device>
40004600: c0 20 80 01 clr [ %g2 + %g1 ]
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
40004604: 7f ff ff 09 call 40004228 <disk_unlock>
40004608: b0 10 00 10 mov %l0, %i0
4000460c: 30 bf ff d9 b,a 40004570 <rtems_disk_delete+0x14c>
40004a14 <rtems_disk_io_done>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_disk_io_done(void)
{
40004a14: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
40004a18: 21 10 00 71 sethi %hi(0x4001c400), %l0
40004a1c: c2 04 20 70 ld [ %l0 + 0x70 ], %g1 ! 4001c470 <disktab_size>
40004a20: 35 10 00 71 sethi %hi(0x4001c400), %i2
40004a24: b6 10 20 00 clr %i3
40004a28: fa 06 a0 74 ld [ %i2 + 0x74 ], %i5
40004a2c: 80 a0 60 00 cmp %g1, 0
40004a30: 02 80 00 1d be 40004aa4 <rtems_disk_io_done+0x90> <== NEVER TAKEN
40004a34: b2 14 20 70 or %l0, 0x70, %i1
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_disk_io_done(void)
40004a38: 83 2e e0 03 sll %i3, 3, %g1
{
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
40004a3c: b8 07 40 01 add %i5, %g1, %i4
for (minor = 0; minor < dtab->size; ++minor) {
40004a40: c4 07 20 04 ld [ %i4 + 4 ], %g2
40004a44: 80 a0 a0 00 cmp %g2, 0
40004a48: 02 80 00 10 be 40004a88 <rtems_disk_io_done+0x74>
40004a4c: c6 07 40 01 ld [ %i5 + %g1 ], %g3
40004a50: ba 10 20 00 clr %i5
rtems_disk_device *dd = dtab->minor [minor];
40004a54: 83 2f 60 02 sll %i5, 2, %g1
40004a58: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
if (dd != NULL) {
40004a5c: 90 90 60 00 orcc %g1, 0, %o0
40004a60: 02 80 00 06 be 40004a78 <rtems_disk_io_done+0x64>
40004a64: ba 07 60 01 inc %i5
free_disk_device(dd);
40004a68: 7f ff fd cb call 40004194 <free_disk_device>
40004a6c: 01 00 00 00 nop
40004a70: c4 07 20 04 ld [ %i4 + 4 ], %g2
40004a74: c6 07 00 00 ld [ %i4 ], %g3
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
40004a78: 80 a0 80 1d cmp %g2, %i5
40004a7c: 18 bf ff f7 bgu 40004a58 <rtems_disk_io_done+0x44>
40004a80: 83 2f 60 02 sll %i5, 2, %g1
40004a84: fa 06 a0 74 ld [ %i2 + 0x74 ], %i5
if (dd != NULL) {
free_disk_device(dd);
}
}
free(dtab->minor);
40004a88: 40 00 02 31 call 4000534c <free>
40004a8c: 90 10 00 03 mov %g3, %o0
rtems_disk_io_done(void)
{
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
40004a90: c2 06 40 00 ld [ %i1 ], %g1
40004a94: b6 06 e0 01 inc %i3
40004a98: 80 a0 40 1b cmp %g1, %i3
40004a9c: 18 bf ff e8 bgu 40004a3c <rtems_disk_io_done+0x28>
40004aa0: 83 2e e0 03 sll %i3, 3, %g1
free_disk_device(dd);
}
}
free(dtab->minor);
}
free(disktab);
40004aa4: 40 00 02 2a call 4000534c <free>
40004aa8: 90 10 00 1d mov %i5, %o0
rtems_semaphore_delete(diskdevs_mutex);
40004aac: 3b 10 00 71 sethi %hi(0x4001c400), %i5
40004ab0: d0 07 60 6c ld [ %i5 + 0x6c ], %o0 ! 4001c46c <diskdevs_mutex>
40004ab4: 40 00 13 94 call 40009904 <rtems_semaphore_delete>
40004ab8: b0 10 20 00 clr %i0
diskdevs_mutex = RTEMS_ID_NONE;
40004abc: c0 27 60 6c clr [ %i5 + 0x6c ]
disktab = NULL;
40004ac0: c0 26 a0 74 clr [ %i2 + 0x74 ]
disktab_size = 0;
40004ac4: c0 24 20 70 clr [ %l0 + 0x70 ]
return RTEMS_SUCCESSFUL;
}
40004ac8: 81 c7 e0 08 ret
40004acc: 81 e8 00 00 restore
40004968 <rtems_disk_io_initialize>:
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
40004968: 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) {
4000496c: 3b 10 00 71 sethi %hi(0x4001c400), %i5
40004970: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 ! 4001c470 <disktab_size>
40004974: 80 a0 60 00 cmp %g1, 0
40004978: 12 80 00 19 bne 400049dc <rtems_disk_io_initialize+0x74>
4000497c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
40004980: 90 10 20 08 mov 8, %o0
40004984: 92 10 20 08 mov 8, %o1
40004988: 40 00 02 3a call 40005270 <calloc>
4000498c: 39 10 00 71 sethi %hi(0x4001c400), %i4
40004990: d0 27 20 74 st %o0, [ %i4 + 0x74 ] ! 4001c474 <disktab>
if (disktab == NULL) {
40004994: 80 a2 20 00 cmp %o0, 0
40004998: 02 80 00 11 be 400049dc <rtems_disk_io_initialize+0x74> <== NEVER TAKEN
4000499c: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
400049a0: 03 10 00 71 sethi %hi(0x4001c400), %g1
sc = rtems_semaphore_create(
400049a4: 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;
400049a8: c0 28 60 68 clrb [ %g1 + 0x68 ]
sc = rtems_semaphore_create(
400049ac: 90 12 21 56 or %o0, 0x156, %o0
400049b0: 92 10 20 01 mov 1, %o1
400049b4: 94 10 20 10 mov 0x10, %o2
400049b8: 96 10 20 00 clr %o3
400049bc: 37 10 00 71 sethi %hi(0x4001c400), %i3
400049c0: 40 00 13 60 call 40009740 <rtems_semaphore_create>
400049c4: 98 16 e0 6c or %i3, 0x6c, %o4 ! 4001c46c <diskdevs_mutex>
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
400049c8: 80 a2 20 00 cmp %o0, 0
400049cc: 02 80 00 06 be 400049e4 <rtems_disk_io_initialize+0x7c> <== ALWAYS TAKEN
400049d0: 01 00 00 00 nop
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(diskdevs_mutex);
free(disktab);
400049d4: 40 00 02 5e call 4000534c <free> <== NOT EXECUTED
400049d8: d0 07 20 74 ld [ %i4 + 0x74 ], %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
400049dc: 81 c7 e0 08 ret
400049e0: 81 e8 00 00 restore
free(disktab);
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
400049e4: 40 00 2b df call 4000f960 <rtems_bdbuf_init>
400049e8: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
400049ec: 80 a2 20 00 cmp %o0, 0
400049f0: 12 80 00 05 bne 40004a04 <rtems_disk_io_initialize+0x9c> <== NEVER TAKEN
400049f4: 82 10 20 08 mov 8, %g1
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
400049f8: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
return RTEMS_SUCCESSFUL;
}
400049fc: 81 c7 e0 08 ret
40004a00: 91 e8 20 00 restore %g0, 0, %o0
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(diskdevs_mutex);
40004a04: d0 06 e0 6c ld [ %i3 + 0x6c ], %o0 <== NOT EXECUTED
40004a08: 40 00 13 bf call 40009904 <rtems_semaphore_delete> <== NOT EXECUTED
40004a0c: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
40004a10: 30 bf ff f1 b,a 400049d4 <rtems_disk_io_initialize+0x6c> <== NOT EXECUTED
40004870 <rtems_disk_next>:
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
40004870: 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) {
40004874: 80 a6 3f ff cmp %i0, -1
40004878: 02 80 00 37 be 40004954 <rtems_disk_next+0xe4>
4000487c: 80 a6 7f ff cmp %i1, -1
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
40004880: ba 06 60 01 add %i1, 1, %i5
40004884: 80 a7 40 19 cmp %i5, %i1
40004888: 0a 80 00 2e bcs 40004940 <rtems_disk_next+0xd0> <== NEVER TAKEN
4000488c: b8 10 00 18 mov %i0, %i4
} else {
++minor;
}
}
sc = disk_lock();
40004890: 7f ff fe 57 call 400041ec <disk_lock>
40004894: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
40004898: 80 a2 20 00 cmp %o0, 0
4000489c: 12 80 00 27 bne 40004938 <rtems_disk_next+0xc8> <== NEVER TAKEN
400048a0: 03 10 00 71 sethi %hi(0x4001c400), %g1
return NULL;
}
if (major >= disktab_size) {
400048a4: c8 00 60 70 ld [ %g1 + 0x70 ], %g4 ! 4001c470 <disktab_size>
400048a8: 80 a7 00 04 cmp %i4, %g4
400048ac: 1a 80 00 21 bcc 40004930 <rtems_disk_next+0xc0> <== NEVER TAKEN
400048b0: 03 10 00 71 sethi %hi(0x4001c400), %g1
disk_unlock();
return NULL;
}
dtab = disktab + major;
400048b4: c6 00 60 74 ld [ %g1 + 0x74 ], %g3 ! 4001c474 <disktab>
400048b8: b7 2f 20 03 sll %i4, 3, %i3
400048bc: c2 00 c0 1b ld [ %g3 + %i3 ], %g1
400048c0: b6 00 c0 1b add %g3, %i3, %i3
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
400048c4: 80 a0 60 00 cmp %g1, 0
400048c8: 02 80 00 12 be 40004910 <rtems_disk_next+0xa0>
400048cc: b5 2f 60 02 sll %i5, 2, %i2
400048d0: c4 06 e0 04 ld [ %i3 + 4 ], %g2
400048d4: 80 a7 40 02 cmp %i5, %g2
400048d8: 3a 80 00 0f bcc,a 40004914 <rtems_disk_next+0xa4>
400048dc: b8 07 20 01 inc %i4
disk_unlock();
return NULL;
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
400048e0: c4 00 40 1a ld [ %g1 + %i2 ], %g2
400048e4: 80 a0 a0 00 cmp %g2, 0
400048e8: 02 bf ff f7 be 400048c4 <rtems_disk_next+0x54>
400048ec: ba 07 60 01 inc %i5
++minor;
} else {
++dtab->minor [minor]->uses;
400048f0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
400048f4: 82 00 60 01 inc %g1
disk_unlock();
400048f8: 7f ff fe 4c call 40004228 <disk_unlock>
400048fc: c2 20 a0 14 st %g1, [ %g2 + 0x14 ]
return dtab->minor [minor];
40004900: c2 06 c0 00 ld [ %i3 ], %g1
40004904: f0 00 40 1a ld [ %g1 + %i2 ], %i0
}
}
}
40004908: 81 c7 e0 08 ret
4000490c: 81 e8 00 00 restore
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
++major;
40004910: b8 07 20 01 inc %i4
if (major >= disktab_size) {
40004914: 80 a1 00 1c cmp %g4, %i4
40004918: 08 80 00 06 bleu 40004930 <rtems_disk_next+0xc0>
4000491c: 83 2f 20 03 sll %i4, 3, %g1
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
40004920: ba 10 20 00 clr %i5
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
40004924: b6 00 c0 01 add %g3, %g1, %i3
40004928: 10 bf ff e7 b 400048c4 <rtems_disk_next+0x54>
4000492c: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
}
if (major >= disktab_size) {
disk_unlock();
40004930: 7f ff fe 3e call 40004228 <disk_unlock>
40004934: 01 00 00 00 nop
return NULL;
40004938: 81 c7 e0 08 ret
4000493c: 91 e8 20 00 restore %g0, 0, %o0
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
/* If major wraps around */
if ((major + 1) < major) {
40004940: b8 06 20 01 add %i0, 1, %i4 <== NOT EXECUTED
40004944: 80 a7 00 18 cmp %i4, %i0 <== NOT EXECUTED
40004948: 1a bf ff d2 bcc 40004890 <rtems_disk_next+0x20> <== NOT EXECUTED
4000494c: ba 10 20 00 clr %i5 <== NOT EXECUTED
40004950: 30 bf ff fa b,a 40004938 <rtems_disk_next+0xc8> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (dev != (dev_t) -1) {
40004954: 32 bf ff cc bne,a 40004884 <rtems_disk_next+0x14> <== NEVER TAKEN
40004958: ba 06 60 01 add %i1, 1, %i5 <== NOT EXECUTED
rtems_disk_next(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
4000495c: ba 10 20 00 clr %i5
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
40004960: 10 bf ff cc b 40004890 <rtems_disk_next+0x20>
40004964: b8 10 20 00 clr %i4
400047a0 <rtems_disk_obtain>:
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
400047a0: 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);
400047a4: 7f ff f9 05 call 40002bb8 <sparc_disable_interrupts>
400047a8: b8 10 00 18 mov %i0, %i4
400047ac: b6 10 00 08 mov %o0, %i3
if (!diskdevs_protected) {
400047b0: 03 10 00 71 sethi %hi(0x4001c400), %g1
400047b4: c2 08 60 68 ldub [ %g1 + 0x68 ], %g1 ! 4001c468 <diskdevs_protected>
400047b8: 80 a0 60 00 cmp %g1, 0
400047bc: 22 80 00 10 be,a 400047fc <rtems_disk_obtain+0x5c> <== ALWAYS TAKEN
400047c0: 90 10 00 18 mov %i0, %o0
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
rtems_interrupt_enable(level);
} else {
rtems_interrupt_enable(level);
400047c4: 7f ff f9 01 call 40002bc8 <sparc_enable_interrupts> <== NOT EXECUTED
400047c8: b0 10 20 00 clr %i0 <== NOT EXECUTED
sc = disk_lock();
400047cc: 7f ff fe 88 call 400041ec <disk_lock> <== NOT EXECUTED
400047d0: 01 00 00 00 nop <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
400047d4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400047d8: 12 80 00 07 bne 400047f4 <rtems_disk_obtain+0x54> <== NOT EXECUTED
400047dc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
400047e0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400047e4: 7f ff fe 45 call 400040f8 <get_disk_entry> <== NOT EXECUTED
400047e8: 94 10 20 00 clr %o2 <== NOT EXECUTED
disk_unlock();
400047ec: 7f ff fe 8f call 40004228 <disk_unlock> <== NOT EXECUTED
400047f0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
return dd;
}
400047f4: 81 c7 e0 08 ret <== NOT EXECUTED
400047f8: 81 e8 00 00 restore <== NOT EXECUTED
rtems_interrupt_level level;
rtems_interrupt_disable(level);
if (!diskdevs_protected) {
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
400047fc: 92 10 00 19 mov %i1, %o1
40004800: 7f ff fe 3e call 400040f8 <get_disk_entry>
40004804: 94 10 20 00 clr %o2
40004808: b0 10 00 08 mov %o0, %i0
rtems_interrupt_enable(level);
4000480c: 7f ff f8 ef call 40002bc8 <sparc_enable_interrupts>
40004810: 90 10 00 1b mov %i3, %o0
40004814: 81 c7 e0 08 ret
40004818: 81 e8 00 00 restore
40012900 <rtems_event_system_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
40012900: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc;
if ( event_out != NULL ) {
40012904: 80 a6 e0 00 cmp %i3, 0
40012908: 02 80 00 0a be 40012930 <rtems_event_system_receive+0x30> <== NEVER TAKEN
4001290c: 82 10 20 09 mov 9, %g1
Thread_Control *executing = _Thread_Executing;
40012910: 03 10 00 73 sethi %hi(0x4001cc00), %g1
40012914: fa 00 63 c0 ld [ %g1 + 0x3c0 ], %i5 ! 4001cfc0 <_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 ) ) {
40012918: 80 a6 20 00 cmp %i0, 0
4001291c: 12 80 00 07 bne 40012938 <rtems_event_system_receive+0x38><== ALWAYS TAKEN
40012920: da 07 61 4c ld [ %i5 + 0x14c ], %o5
);
_Thread_Enable_dispatch();
sc = executing->Wait.return_code;
} else {
*event_out = event->pending_events;
40012924: c4 03 60 04 ld [ %o5 + 4 ], %g2 <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
40012928: 82 10 20 00 clr %g1 <== NOT EXECUTED
);
_Thread_Enable_dispatch();
sc = executing->Wait.return_code;
} else {
*event_out = event->pending_events;
4001292c: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
40012930: 81 c7 e0 08 ret <== NOT EXECUTED
40012934: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
40012938: 03 10 00 72 sethi %hi(0x4001c800), %g1
4001293c: c4 00 62 a0 ld [ %g1 + 0x2a0 ], %g2 ! 4001caa0 <_Thread_Dispatch_disable_level>
++level;
40012940: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40012944: c4 20 62 a0 st %g2, [ %g1 + 0x2a0 ]
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
Event_Control *event = &api->System_event;
if ( !_Event_sets_Is_empty( event_in ) ) {
_Thread_Disable_dispatch();
_Event_Seize(
40012948: 03 00 01 00 sethi %hi(0x40000), %g1
4001294c: 90 10 00 18 mov %i0, %o0
40012950: 92 10 00 19 mov %i1, %o1
40012954: 94 10 00 1a mov %i2, %o2
40012958: 96 10 00 1b mov %i3, %o3
4001295c: 98 10 00 1d mov %i5, %o4
40012960: 9a 03 60 04 add %o5, 4, %o5
40012964: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
40012968: 03 10 00 74 sethi %hi(0x4001d000), %g1
4001296c: 82 10 63 b0 or %g1, 0x3b0, %g1 ! 4001d3b0 <_System_event_Sync_state>
40012970: 7f ff da a1 call 400093f4 <_Event_Seize>
40012974: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
executing,
event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
40012978: 7f ff e7 34 call 4000c648 <_Thread_Enable_dispatch>
4001297c: 01 00 00 00 nop
sc = executing->Wait.return_code;
40012980: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
40012984: 81 c7 e0 08 ret
40012988: 91 e8 00 01 restore %g0, %g1, %o0
40008774 <rtems_event_system_send>:
rtems_status_code rtems_event_system_send(
rtems_id id,
rtems_event_set event_in
)
{
40008774: 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 );
40008778: 90 10 00 18 mov %i0, %o0
4000877c: 40 00 0a 5f call 4000b0f8 <_Thread_Get>
40008780: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
40008784: c2 07 bf fc ld [ %fp + -4 ], %g1
40008788: 80 a0 60 00 cmp %g1, 0
4000878c: 12 80 00 0d bne 400087c0 <rtems_event_system_send+0x4c> <== NEVER TAKEN
40008790: 92 10 00 19 mov %i1, %o1
case OBJECTS_LOCAL:
api = thread->API_Extensions[ THREAD_API_RTEMS ];
_Event_Surrender(
40008794: d4 02 21 4c ld [ %o0 + 0x14c ], %o2
40008798: 94 02 a0 04 add %o2, 4, %o2
4000879c: 19 00 01 00 sethi %hi(0x40000), %o4
400087a0: 17 10 00 82 sethi %hi(0x40020800), %o3
400087a4: 96 12 e3 c0 or %o3, 0x3c0, %o3 ! 40020bc0 <_System_event_Sync_state>
400087a8: 7f ff fe 54 call 400080f8 <_Event_Surrender>
400087ac: b0 10 20 00 clr %i0
event_in,
&api->System_event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
400087b0: 40 00 0a 46 call 4000b0c8 <_Thread_Enable_dispatch>
400087b4: 01 00 00 00 nop
sc = RTEMS_SUCCESSFUL;
break;
400087b8: 81 c7 e0 08 ret
400087bc: 81 e8 00 00 restore
sc = RTEMS_INVALID_ID;
break;
}
return sc;
}
400087c0: 81 c7 e0 08 ret <== NOT EXECUTED
400087c4: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED
40008780 <rtems_fdisk_abort.constprop.1>:
*
* @param format The format string. See printf for details.
* @param ... The arguments for the format text.
*/
static void
rtems_fdisk_abort (const char *format, ...)
40008780: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
{
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:abort:");
40008784: 31 10 00 e9 sethi %hi(0x4003a400), %i0 <== NOT EXECUTED
40008788: c2 06 21 78 ld [ %i0 + 0x178 ], %g1 ! 4003a578 <_impure_ptr><== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
4000878c: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
40008790: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40008794: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
40008798: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
4000879c: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
400087a0: d6 00 60 0c ld [ %g1 + 0xc ], %o3 <== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
400087a4: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
400087a8: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
400087ac: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
400087b0: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
400087b4: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
400087b8: 40 00 70 dc call 40024b28 <fwrite> <== NOT EXECUTED
400087bc: 90 12 23 30 or %o0, 0x330, %o0 ! 40035730 <Callbacks.6428+0x4e8><== NOT EXECUTED
vfprintf (stderr, format, args);
400087c0: c2 06 21 78 ld [ %i0 + 0x178 ], %g1 <== NOT EXECUTED
400087c4: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
400087c8: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
400087cc: 40 00 6f 2a call 40024474 <fputs> <== NOT EXECUTED
400087d0: 90 12 23 40 or %o0, 0x340, %o0 <== NOT EXECUTED
fprintf (stderr, "\n");
400087d4: c2 06 21 78 ld [ %i0 + 0x178 ], %g1 <== NOT EXECUTED
400087d8: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
400087dc: 40 00 6e f2 call 400243a4 <fputc> <== NOT EXECUTED
400087e0: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
fflush (stderr);
400087e4: c2 06 21 78 ld [ %i0 + 0x178 ], %g1 <== NOT EXECUTED
400087e8: 40 00 6d d7 call 40023f44 <fflush> <== NOT EXECUTED
400087ec: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
exit (1);
400087f0: 40 00 6c d5 call 40023b44 <exit> <== NOT EXECUTED
400087f4: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
40006788 <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)
{
40006788: 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)
4000678c: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
40006790: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40006794: 80 a0 80 01 cmp %g2, %g1
40006798: 1a 80 00 20 bcc 40006818 <rtems_fdisk_compact+0x90>
4000679c: a6 10 00 18 mov %i0, %l3
fd->starvations++;
400067a0: 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");
400067a4: 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++;
400067a8: 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");
400067ac: 13 10 00 d5 sethi %hi(0x40035400), %o1
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
fd->starvations++;
400067b0: 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");
400067b4: 7f ff fc a7 call 40005a50 <rtems_fdisk_printf>
400067b8: 92 12 62 38 or %o1, 0x238, %o1
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
400067bc: fa 06 20 40 ld [ %i0 + 0x40 ], %i5
400067c0: 80 a7 60 00 cmp %i5, 0
400067c4: 22 80 00 83 be,a 400069d0 <rtems_fdisk_compact+0x248> <== NEVER TAKEN
400067c8: fa 06 20 34 ld [ %i0 + 0x34 ], %i5 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
400067cc: c2 07 40 00 ld [ %i5 ], %g1
if (!queue->head)
400067d0: 80 a0 60 00 cmp %g1, 0
400067d4: 02 80 00 9f be 40006a50 <rtems_fdisk_compact+0x2c8> <== NEVER TAKEN
400067d8: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
queue->tail = 0;
queue->count--;
400067dc: c2 04 e0 48 ld [ %l3 + 0x48 ], %g1
400067e0: 82 00 7f ff add %g1, -1, %g1
400067e4: c2 24 e0 48 st %g1, [ %l3 + 0x48 ]
sc->next = 0;
400067e8: c0 27 40 00 clr [ %i5 ]
if (!ssc)
ssc = rtems_fdisk_segment_queue_pop_head (&fd->available);
if (ssc)
{
dsc = rtems_fdisk_seg_most_available (&fd->available);
400067ec: 7f ff fc 59 call 40005950 <rtems_fdisk_seg_most_available>
400067f0: 90 04 e0 34 add %l3, 0x34, %o0
if (dsc)
400067f4: 94 92 20 00 orcc %o0, 0, %o2
400067f8: 02 80 00 8b be 40006a24 <rtems_fdisk_compact+0x29c> <== NEVER TAKEN
400067fc: 92 10 00 1d mov %i5, %o1
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
40006800: 90 10 00 13 mov %l3, %o0
40006804: 7f ff fe d1 call 40006348 <rtems_fdisk_recycle_segment>
40006808: 96 07 bf fc add %fp, -4, %o3
if (ret)
4000680c: b0 92 20 00 orcc %o0, 0, %i0
40006810: 12 80 00 8e bne 40006a48 <rtems_fdisk_compact+0x2c0> <== NEVER TAKEN
40006814: 01 00 00 00 nop
40006818: d2 04 e0 40 ld [ %l3 + 0x40 ], %o1
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
4000681c: 21 10 00 d5 sethi %hi(0x40035400), %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",
40006820: 23 10 00 d5 sethi %hi(0x40035400), %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
40006824: 25 10 00 d5 sethi %hi(0x40035400), %l2
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
40006828: b8 10 20 00 clr %i4
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
4000682c: a0 14 22 68 or %l0, 0x268, %l0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
40006830: b2 04 e0 34 add %l3, 0x34, %i1
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
40006834: a2 14 62 b0 or %l1, 0x2b0, %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
40006838: a4 14 a2 e8 or %l2, 0x2e8, %l2
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
4000683c: 80 a2 60 00 cmp %o1, 0
40006840: 02 80 00 70 be 40006a00 <rtems_fdisk_compact+0x278>
40006844: 92 10 00 10 mov %l0, %o1
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
40006848: 7f ff fc 82 call 40005a50 <rtems_fdisk_printf>
4000684c: 90 10 00 13 mov %l3, %o0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
40006850: 7f ff fc 40 call 40005950 <rtems_fdisk_seg_most_available>
40006854: 90 10 00 19 mov %i1, %o0
if (dsc == 0)
40006858: b4 92 20 00 orcc %o0, 0, %i2
4000685c: 02 80 00 6b be 40006a08 <rtems_fdisk_compact+0x280> <== NEVER TAKEN
40006860: 11 10 00 d5 sethi %hi(0x40035400), %o0
* with the most available number of pages and see if we have
* used segments that will fit. The used queue is sorted on the least
* number of active pages.
*/
static int
rtems_fdisk_compact (rtems_flashdisk* fd)
40006864: f6 06 a0 24 ld [ %i2 + 0x24 ], %i3
40006868: c6 06 a0 20 ld [ %i2 + 0x20 ], %g3
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
4000686c: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2
40006870: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
40006874: d4 06 a0 08 ld [ %i2 + 8 ], %o2
40006878: d6 06 a0 0c ld [ %i2 + 0xc ], %o3
{
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
}
ssc = fd->used.head;
4000687c: fa 04 e0 40 ld [ %l3 + 0x40 ], %i5
* with the most available number of pages and see if we have
* used segments that will fit. The used queue is sorted on the least
* number of active pages.
*/
static int
rtems_fdisk_compact (rtems_flashdisk* fd)
40006880: b6 06 c0 03 add %i3, %g3, %i3
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
40006884: c0 27 bf fc clr [ %fp + -4 ]
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
40006888: b6 20 80 1b sub %g2, %i3, %i3
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
4000688c: 90 10 00 13 mov %l3, %o0
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
40006890: b6 26 c0 01 sub %i3, %g1, %i3
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
40006894: 7f ff fc 6f call 40005a50 <rtems_fdisk_printf>
40006898: 92 10 00 11 mov %l1, %o1
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
4000689c: 80 a7 60 00 cmp %i5, 0
400068a0: 02 80 00 1b be 4000690c <rtems_fdisk_compact+0x184> <== NEVER TAKEN
400068a4: c2 07 bf fc ld [ %fp + -4 ], %g1
((pages + ssc->pages_active) < dst_pages) &&
400068a8: d8 07 60 1c ld [ %i5 + 0x1c ], %o4
400068ac: 98 00 40 0c add %g1, %o4, %o4
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
400068b0: 80 a6 c0 0c cmp %i3, %o4
400068b4: 28 80 00 45 bleu,a 400069c8 <rtems_fdisk_compact+0x240>
400068b8: 98 10 00 01 mov %g1, %o4
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
400068bc: c6 04 e0 0c ld [ %l3 + 0xc ], %g3
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
400068c0: 80 a7 00 03 cmp %i4, %g3
400068c4: 3a 80 00 41 bcc,a 400069c8 <rtems_fdisk_compact+0x240> <== NEVER TAKEN
400068c8: 98 10 00 01 mov %g1, %o4 <== NOT EXECUTED
400068cc: 10 80 00 0b b 400068f8 <rtems_fdisk_compact+0x170>
400068d0: 9a 10 20 00 clr %o5
400068d4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
400068d8: 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 &&
400068dc: 80 a0 40 1b cmp %g1, %i3
400068e0: 1a 80 00 12 bcc 40006928 <rtems_fdisk_compact+0x1a0>
400068e4: 84 07 00 0d add %i4, %o5, %g2
((pages + ssc->pages_active) < dst_pages) &&
400068e8: 80 a0 80 03 cmp %g2, %g3
400068ec: 3a 80 00 10 bcc,a 4000692c <rtems_fdisk_compact+0x1a4> <== NEVER TAKEN
400068f0: d8 27 bf fc st %o4, [ %fp + -4 ] <== NOT EXECUTED
400068f4: 98 10 00 01 mov %g1, %o4
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
segments++;
ssc = ssc->next;
400068f8: fa 07 40 00 ld [ %i5 ], %i5
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
400068fc: 80 a7 60 00 cmp %i5, 0
40006900: 12 bf ff f5 bne 400068d4 <rtems_fdisk_compact+0x14c>
40006904: 9a 03 60 01 inc %o5
40006908: 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");
4000690c: 90 10 00 13 mov %l3, %o0
40006910: 13 10 00 d5 sethi %hi(0x40035400), %o1
}
compacted_segs += segments;
}
return 0;
40006914: b0 10 20 00 clr %i0
*/
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " nothing to compact");
40006918: 7f ff fc 4e call 40005a50 <rtems_fdisk_printf>
4000691c: 92 12 62 d0 or %o1, 0x2d0, %o1
#endif
break;
40006920: 81 c7 e0 08 ret
40006924: 81 e8 00 00 restore
40006928: 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))
4000692c: 80 a3 20 00 cmp %o4, 0
40006930: 02 bf ff f8 be 40006910 <rtems_fdisk_compact+0x188>
40006934: 90 10 00 13 mov %l3, %o0
40006938: b8 07 00 0d add %i4, %o5, %i4
4000693c: 80 a7 20 01 cmp %i4, 1
40006940: 22 bf ff f5 be,a 40006914 <rtems_fdisk_compact+0x18c>
40006944: 13 10 00 d5 sethi %hi(0x40035400), %o1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
40006948: d4 07 60 08 ld [ %i5 + 8 ], %o2
4000694c: d6 07 60 0c ld [ %i5 + 0xc ], %o3
40006950: 92 10 00 12 mov %l2, %o1
40006954: 7f ff fc 3f call 40005a50 <rtems_fdisk_printf>
40006958: 90 10 00 13 mov %l3, %o0
ssc->device, ssc->segment,
pages, segments);
#endif
rtems_fdisk_segment_queue_remove (&fd->available, dsc);
4000695c: 90 10 00 19 mov %i1, %o0
40006960: 7f ff fb 9b call 400057cc <rtems_fdisk_segment_queue_remove>
40006964: 92 10 00 1a mov %i2, %o1
40006968: c2 07 bf fc ld [ %fp + -4 ], %g1
4000696c: d2 04 e0 40 ld [ %l3 + 0x40 ], %o1
/*
* We now copy the pages to the new segment.
*/
while (pages)
40006970: 80 a0 60 00 cmp %g1, 0
40006974: 02 bf ff b3 be 40006840 <rtems_fdisk_compact+0xb8>
40006978: 80 a2 60 00 cmp %o1, 0
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
4000697c: 02 bf ff fe be 40006974 <rtems_fdisk_compact+0x1ec> <== NEVER TAKEN
40006980: 80 a0 60 00 cmp %g1, 0
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
40006984: c2 02 40 00 ld [ %o1 ], %g1
if (!queue->head)
40006988: 80 a0 60 00 cmp %g1, 0
4000698c: 02 80 00 24 be 40006a1c <rtems_fdisk_compact+0x294> <== NEVER TAKEN
40006990: c2 24 e0 40 st %g1, [ %l3 + 0x40 ]
queue->tail = 0;
queue->count--;
40006994: c2 04 e0 48 ld [ %l3 + 0x48 ], %g1
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
if (ssc)
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
40006998: 90 10 00 13 mov %l3, %o0
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
queue->count--;
4000699c: 82 00 7f ff add %g1, -1, %g1
400069a0: c2 24 e0 48 st %g1, [ %l3 + 0x48 ]
sc->next = 0;
400069a4: c0 22 40 00 clr [ %o1 ]
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
if (ssc)
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
400069a8: 94 10 00 1a mov %i2, %o2
400069ac: 7f ff fe 67 call 40006348 <rtems_fdisk_recycle_segment>
400069b0: 96 07 bf fc add %fp, -4, %o3
if (ret)
400069b4: b0 92 20 00 orcc %o0, 0, %i0
400069b8: 02 bf ff ed be 4000696c <rtems_fdisk_compact+0x1e4> <== ALWAYS TAKEN
400069bc: c2 07 bf fc ld [ %fp + -4 ], %g1
compacted_segs += segments;
}
return 0;
}
400069c0: 81 c7 e0 08 ret <== NOT EXECUTED
400069c4: 81 e8 00 00 restore <== NOT EXECUTED
return EIO;
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
400069c8: 10 bf ff d9 b 4000692c <rtems_fdisk_compact+0x1a4>
400069cc: 9a 10 20 00 clr %o5
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
400069d0: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
400069d4: 02 80 00 1a be 40006a3c <rtems_fdisk_compact+0x2b4> <== NOT EXECUTED
400069d8: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
400069dc: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
if (!queue->head)
400069e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400069e4: 02 80 00 1d be 40006a58 <rtems_fdisk_compact+0x2d0> <== NOT EXECUTED
400069e8: c2 24 e0 34 st %g1, [ %l3 + 0x34 ] <== NOT EXECUTED
queue->tail = 0;
queue->count--;
400069ec: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 <== NOT EXECUTED
400069f0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
400069f4: c2 24 e0 3c st %g1, [ %l3 + 0x3c ] <== NOT EXECUTED
sc->next = 0;
400069f8: 10 bf ff 7d b 400067ec <rtems_fdisk_compact+0x64> <== NOT EXECUTED
400069fc: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
}
compacted_segs += segments;
}
return 0;
40006a00: 81 c7 e0 08 ret
40006a04: 91 e8 20 00 restore %g0, 0, %o0
dsc = rtems_fdisk_seg_most_available (&fd->available);
if (dsc == 0)
{
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
40006a08: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
dsc = rtems_fdisk_seg_most_available (&fd->available);
if (dsc == 0)
{
rtems_fdisk_error ("compacting: no available segments to compact too");
40006a0c: 7f ff fc eb call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40006a10: 90 12 22 78 or %o0, 0x278, %o0 <== NOT EXECUTED
40006a14: 81 c7 e0 08 ret <== NOT EXECUTED
40006a18: 81 e8 00 00 restore <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
40006a1c: 10 bf ff de b 40006994 <rtems_fdisk_compact+0x20c> <== NOT EXECUTED
40006a20: c0 24 e0 44 clr [ %l3 + 0x44 ] <== NOT EXECUTED
if (ret)
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
40006a24: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
return EIO;
40006a28: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
if (ret)
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
40006a2c: 7f ff fc e3 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40006a30: 90 12 22 50 or %o0, 0x250, %o0 <== NOT EXECUTED
40006a34: 81 c7 e0 08 ret <== NOT EXECUTED
40006a38: 81 e8 00 00 restore <== NOT EXECUTED
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
40006a3c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
return EIO;
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
40006a40: 7f ff fc de call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40006a44: 90 12 23 10 or %o0, 0x310, %o0 <== NOT EXECUTED
40006a48: 81 c7 e0 08 ret <== NOT EXECUTED
40006a4c: 81 e8 00 00 restore <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
40006a50: 10 bf ff 63 b 400067dc <rtems_fdisk_compact+0x54> <== NOT EXECUTED
40006a54: c0 26 20 44 clr [ %i0 + 0x44 ] <== NOT EXECUTED
40006a58: 10 bf ff e5 b 400069ec <rtems_fdisk_compact+0x264> <== NOT EXECUTED
40006a5c: c0 24 e0 38 clr [ %l3 + 0x38 ] <== NOT EXECUTED
40005e34 <rtems_fdisk_erase_segment>:
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
40005e34: 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;
40005e38: d2 06 60 08 ld [ %i1 + 8 ], %o1
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
40005e3c: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
40005e40: 87 2a 60 04 sll %o1, 4, %g3
40005e44: 83 2a 60 02 sll %o1, 2, %g1
40005e48: 82 20 c0 01 sub %g3, %g1, %g1
40005e4c: 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;
40005e50: c6 00 e0 08 ld [ %g3 + 8 ], %g3
uint32_t device;
uint32_t segment;
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
40005e54: d4 06 60 0c ld [ %i1 + 0xc ], %o2
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
ret = ops->erase (sd, device, segment);
40005e58: f8 00 e0 08 ld [ %g3 + 8 ], %i4
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
40005e5c: c6 00 80 01 ld [ %g2 + %g1 ], %g3
40005e60: 89 2a a0 06 sll %o2, 6, %g4
40005e64: 85 2a a0 04 sll %o2, 4, %g2
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
ret = ops->erase (sd, device, segment);
40005e68: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
40005e6c: 84 21 00 02 sub %g4, %g2, %g2
40005e70: 84 00 c0 02 add %g3, %g2, %g2
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
ret = ops->erase (sd, device, segment);
40005e74: d0 00 a0 04 ld [ %g2 + 4 ], %o0
40005e78: 9f c0 40 00 call %g1
40005e7c: ba 10 00 18 mov %i0, %i5
if (ret)
40005e80: b0 92 20 00 orcc %o0, 0, %i0
40005e84: 22 80 00 24 be,a 40005f14 <rtems_fdisk_erase_segment+0xe0><== ALWAYS TAKEN
40005e88: c6 07 60 28 ld [ %i5 + 0x28 ], %g3
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
40005e8c: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
40005e90: 40 00 81 05 call 400262a4 <strerror> <== NOT EXECUTED
40005e94: f8 06 60 0c ld [ %i1 + 0xc ], %i4 <== NOT EXECUTED
40005e98: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40005e9c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40005ea0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40005ea4: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40005ea8: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
40005eac: 7f ff ff c3 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40005eb0: 90 12 20 20 or %o0, 0x20, %o0 <== NOT EXECUTED
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
40005eb4: c2 07 60 58 ld [ %i5 + 0x58 ], %g1 <== NOT EXECUTED
if (ret)
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
40005eb8: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
40005ebc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005ec0: 02 80 00 36 be 40005f98 <rtems_fdisk_erase_segment+0x164> <== NOT EXECUTED
40005ec4: c4 26 60 28 st %g2, [ %i1 + 0x28 ] <== NOT EXECUTED
{
if (it == sc)
40005ec8: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
40005ecc: 32 80 00 06 bne,a 40005ee4 <rtems_fdisk_erase_segment+0xb0><== NOT EXECUTED
40005ed0: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40005ed4: 30 80 00 35 b,a 40005fa8 <rtems_fdisk_erase_segment+0x174><== NOT EXECUTED
40005ed8: 02 80 00 34 be 40005fa8 <rtems_fdisk_erase_segment+0x174> <== NOT EXECUTED
40005edc: 01 00 00 00 nop <== NOT EXECUTED
return true;
it = it->next;
40005ee0: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
40005ee4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005ee8: 12 bf ff fc bne 40005ed8 <rtems_fdisk_erase_segment+0xa4> <== NOT EXECUTED
40005eec: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
40005ef0: c2 07 60 5c ld [ %i5 + 0x5c ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
40005ef4: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
if (queue->head)
{
queue->tail->next = sc;
40005ef8: f2 20 40 00 st %i1, [ %g1 ] <== NOT EXECUTED
queue->tail = sc;
40005efc: f2 27 60 5c st %i1, [ %i5 + 0x5c ] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
40005f00: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 <== NOT EXECUTED
40005f04: 82 00 60 01 inc %g1 <== NOT EXECUTED
40005f08: c2 27 60 60 st %g1, [ %i5 + 0x60 ] <== NOT EXECUTED
40005f0c: 81 c7 e0 08 ret <== NOT EXECUTED
40005f10: 81 e8 00 00 restore <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
sc->erased++;
40005f14: c2 06 60 2c ld [ %i1 + 0x2c ], %g1
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
40005f18: c4 06 60 14 ld [ %i1 + 0x14 ], %g2
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40005f1c: d2 06 60 18 ld [ %i1 + 0x18 ], %o1
40005f20: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
sc->erased++;
40005f24: 82 00 60 01 inc %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40005f28: f8 06 60 10 ld [ %i1 + 0x10 ], %i4
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
40005f2c: 84 00 c0 02 add %g3, %g2, %g2
40005f30: c4 27 60 28 st %g2, [ %i5 + 0x28 ]
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40005f34: 7f ff f1 a1 call 400025b8 <.umul>
40005f38: c2 26 60 2c st %g1, [ %i1 + 0x2c ]
40005f3c: 92 10 20 ff mov 0xff, %o1
40005f40: 94 10 00 08 mov %o0, %o2
40005f44: 40 00 7c 10 call 40024f84 <memset>
40005f48: 90 10 00 1c mov %i4, %o0
{
if (sc)
{
sc->next = 0;
if (queue->head)
40005f4c: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
fd->erased_blocks += sc->pages;
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
sc->pages_active = 0;
40005f50: c0 26 60 1c clr [ %i1 + 0x1c ]
sc->pages_used = 0;
40005f54: c0 26 60 20 clr [ %i1 + 0x20 ]
sc->pages_bad = 0;
40005f58: c0 26 60 24 clr [ %i1 + 0x24 ]
sc->failed = false;
40005f5c: c0 26 60 28 clr [ %i1 + 0x28 ]
{
if (sc)
{
sc->next = 0;
if (queue->head)
40005f60: 80 a0 60 00 cmp %g1, 0
40005f64: 02 80 00 0a be 40005f8c <rtems_fdisk_erase_segment+0x158>
40005f68: c0 26 40 00 clr [ %i1 ]
{
queue->tail->next = sc;
40005f6c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
40005f70: f2 20 40 00 st %i1, [ %g1 ]
queue->tail = sc;
40005f74: f2 27 60 38 st %i1, [ %i5 + 0x38 ]
else
{
queue->head = queue->tail = sc;
}
queue->count++;
40005f78: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
40005f7c: 82 00 60 01 inc %g1
40005f80: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
40005f84: 81 c7 e0 08 ret
40005f88: 81 e8 00 00 restore
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
40005f8c: f2 27 60 38 st %i1, [ %i5 + 0x38 ]
40005f90: 10 bf ff fa b 40005f78 <rtems_fdisk_erase_segment+0x144>
40005f94: f2 27 60 34 st %i1, [ %i5 + 0x34 ]
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
40005f98: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
40005f9c: f2 27 60 5c st %i1, [ %i5 + 0x5c ] <== NOT EXECUTED
40005fa0: 10 bf ff d8 b 40005f00 <rtems_fdisk_erase_segment+0xcc> <== NOT EXECUTED
40005fa4: f2 27 60 58 st %i1, [ %i5 + 0x58 ] <== NOT EXECUTED
40005fa8: 81 c7 e0 08 ret <== NOT EXECUTED
40005fac: 81 e8 00 00 restore <== NOT EXECUTED
40005db8 <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, ...)
{
40005db8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
40005dbc: 21 10 00 e9 sethi %hi(0x4003a400), %l0 <== NOT EXECUTED
40005dc0: c2 04 21 78 ld [ %l0 + 0x178 ], %g1 ! 4003a578 <_impure_ptr><== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
40005dc4: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
40005dc8: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40005dcc: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
40005dd0: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
40005dd4: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
40005dd8: d6 00 60 0c ld [ %g1 + 0xc ], %o3 <== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
40005ddc: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
40005de0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
40005de4: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
40005de8: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
40005dec: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40005df0: 40 00 7b 4e call 40024b28 <fwrite> <== NOT EXECUTED
40005df4: 90 12 20 10 or %o0, 0x10, %o0 ! 40035410 <Callbacks.6428+0x1c8><== NOT EXECUTED
ret = vfprintf (stderr, format, args);
40005df8: c2 04 21 78 ld [ %l0 + 0x178 ], %g1 <== NOT EXECUTED
40005dfc: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
40005e00: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
40005e04: 40 00 9c ae call 4002d0bc <vfprintf> <== NOT EXECUTED
40005e08: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
fprintf (stderr, "\n");
40005e0c: c2 04 21 78 ld [ %l0 + 0x178 ], %g1 <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
ret = vfprintf (stderr, format, args);
40005e10: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stderr, "\n");
40005e14: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
40005e18: 40 00 79 63 call 400243a4 <fputc> <== NOT EXECUTED
40005e1c: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stderr);
40005e20: c2 04 21 78 ld [ %l0 + 0x178 ], %g1 <== NOT EXECUTED
40005e24: 40 00 78 48 call 40023f44 <fflush> <== NOT EXECUTED
40005e28: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
return ret;
}
40005e2c: 81 c7 e0 08 ret <== NOT EXECUTED
40005e30: 81 e8 00 00 restore <== NOT EXECUTED
400059c8 <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, ...)
{
400059c8: 9d e3 bf 98 save %sp, -104, %sp
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
400059cc: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
400059d0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
400059d4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
400059d8: 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)
400059dc: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
400059e0: 80 a0 60 01 cmp %g1, 1
400059e4: 08 80 00 19 bleu 40005a48 <rtems_fdisk_info+0x80> <== ALWAYS TAKEN
400059e8: b0 10 20 00 clr %i0
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
400059ec: 3b 10 00 e9 sethi %hi(0x4003a400), %i5 <== NOT EXECUTED
400059f0: c2 07 61 78 ld [ %i5 + 0x178 ], %g1 ! 4003a578 <_impure_ptr><== NOT EXECUTED
400059f4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
400059f8: d6 00 60 08 ld [ %g1 + 8 ], %o3 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
400059fc: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:");
40005a00: 94 10 20 06 mov 6, %o2 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
40005a04: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:");
40005a08: 11 10 00 d4 sethi %hi(0x40035000), %o0 <== NOT EXECUTED
40005a0c: 40 00 7c 47 call 40024b28 <fwrite> <== NOT EXECUTED
40005a10: 90 12 23 80 or %o0, 0x380, %o0 ! 40035380 <Callbacks.6428+0x138><== NOT EXECUTED
ret = vfprintf (stdout, format, args);
40005a14: c2 07 61 78 ld [ %i5 + 0x178 ], %g1 <== NOT EXECUTED
40005a18: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
40005a1c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
40005a20: 40 00 9d a7 call 4002d0bc <vfprintf> <== NOT EXECUTED
40005a24: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
40005a28: c2 07 61 78 ld [ %i5 + 0x178 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
ret = vfprintf (stdout, format, args);
40005a2c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
40005a30: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
40005a34: 40 00 7a 5c call 400243a4 <fputc> <== NOT EXECUTED
40005a38: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
40005a3c: c2 07 61 78 ld [ %i5 + 0x178 ], %g1 <== NOT EXECUTED
40005a40: 40 00 79 41 call 40023f44 <fflush> <== NOT EXECUTED
40005a44: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
40005a48: 81 c7 e0 08 ret
40005a4c: 81 e8 00 00 restore
4000824c <rtems_fdisk_initialize>:
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
4000824c: 9d e3 bf 80 save %sp, -128, %sp
const rtems_flashdisk_config* c = rtems_flashdisk_configuration;
rtems_flashdisk* fd;
rtems_status_code sc;
sc = rtems_disk_io_initialize ();
40008250: 7f ff f5 05 call 40005664 <rtems_disk_io_initialize>
40008254: a4 10 00 18 mov %i0, %l2
if (sc != RTEMS_SUCCESSFUL)
40008258: b0 92 20 00 orcc %o0, 0, %i0
4000825c: 02 80 00 04 be 4000826c <rtems_fdisk_initialize+0x20> <== ALWAYS TAKEN
40008260: 01 00 00 00 nop
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
40008264: 81 c7 e0 08 ret <== NOT EXECUTED
40008268: 81 e8 00 00 restore <== NOT EXECUTED
static rtems_status_code
rtems_fdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
4000826c: 40 00 05 4c call 4000979c <malloc>
40008270: 90 10 22 00 mov 0x200, %o0
40008274: 03 10 01 2a sethi %hi(0x4004a800), %g1
40008278: d0 20 63 78 st %o0, [ %g1 + 0x378 ] ! 4004ab78 <rtems_fdisk_crc16_factor>
if (!rtems_fdisk_crc16_factor)
4000827c: 80 a2 20 00 cmp %o0, 0
40008280: 02 bf ff f9 be 40008264 <rtems_fdisk_initialize+0x18> <== NEVER TAKEN
40008284: b0 10 20 1a mov 0x1a, %i0
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
40008288: 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)
4000828c: 86 10 20 00 clr %g3
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
40008290: 88 11 20 08 or %g4, 8, %g4
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
40008294: 82 10 00 03 mov %g3, %g1
40008298: 84 10 20 08 mov 8, %g2
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
4000829c: 80 88 60 01 btst 1, %g1
400082a0: 83 28 60 10 sll %g1, 0x10, %g1
400082a4: 02 80 00 03 be 400082b0 <rtems_fdisk_initialize+0x64>
400082a8: 83 30 60 11 srl %g1, 0x11, %g1
400082ac: 82 18 40 04 xor %g1, %g4, %g1
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
400082b0: 84 80 bf ff addcc %g2, -1, %g2
400082b4: 12 bf ff fb bne 400082a0 <rtems_fdisk_initialize+0x54>
400082b8: 80 88 60 01 btst 1, %g1
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
400082bc: 85 28 e0 01 sll %g3, 1, %g2
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_fdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
400082c0: 86 00 e0 01 inc %g3
400082c4: 80 a0 e1 00 cmp %g3, 0x100
400082c8: 12 bf ff f3 bne 40008294 <rtems_fdisk_initialize+0x48>
400082cc: c2 32 00 02 sth %g1, [ %o0 + %g2 ]
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
400082d0: 03 10 00 e8 sethi %hi(0x4003a000), %g1
400082d4: fa 00 63 bc ld [ %g1 + 0x3bc ], %i5 ! 4003a3bc <rtems_flashdisk_configuration_size>
400082d8: 92 10 20 74 mov 0x74, %o1
400082dc: 90 10 00 1d mov %i5, %o0
400082e0: 40 00 03 2f call 40008f9c <calloc>
400082e4: 35 10 01 2a sethi %hi(0x4004a800), %i2
400082e8: d0 26 a3 70 st %o0, [ %i2 + 0x370 ] ! 4004ab70 <rtems_flashdisks>
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
400082ec: 80 a2 20 00 cmp %o0, 0
400082f0: 02 bf ff dd be 40008264 <rtems_fdisk_initialize+0x18> <== NEVER TAKEN
400082f4: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
400082f8: 80 a7 60 00 cmp %i5, 0
400082fc: 02 80 00 f6 be 400086d4 <rtems_fdisk_initialize+0x488> <== NEVER TAKEN
40008300: 21 10 00 d3 sethi %hi(0x40034c00), %l0
40008304: a6 10 20 00 clr %l3
40008308: a0 14 21 50 or %l0, 0x150, %l0
4000830c: a2 10 20 00 clr %l1
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
40008310: f8 04 20 0c ld [ %l0 + 0xc ], %i4
fd->compact_segs = c->compact_segs;
40008314: c8 04 20 14 ld [ %l0 + 0x14 ], %g4
fd->avail_compact_segs = c->avail_compact_segs;
40008318: c6 04 20 18 ld [ %l0 + 0x18 ], %g3
fd->block_size = c->block_size;
4000831c: fa 04 00 00 ld [ %l0 ], %i5
fd->unavail_blocks = c->unavail_blocks;
40008320: c4 04 20 10 ld [ %l0 + 0x10 ], %g2
fd->info_level = c->info_level;
40008324: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
40008328: 35 00 00 18 sethi %hi(0x6000), %i2
4000832c: b4 16 a1 00 or %i2, 0x100, %i2 ! 6100 <PROM_START+0x6100>
40008330: f4 37 bf f8 sth %i2, [ %fp + -8 ]
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
40008334: e8 04 20 04 ld [ %l0 + 4 ], %l4
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
40008338: e2 2f bf f9 stb %l1, [ %fp + -7 ]
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
4000833c: 35 0b d9 19 sethi %hi(0x2f646400), %i2
40008340: 37 0b d9 99 sethi %hi(0x2f666400), %i3
40008344: b4 16 a1 76 or %i2, 0x176, %i2
40008348: b6 16 e0 64 or %i3, 0x64, %i3
4000834c: f4 3f bf f0 std %i2, [ %fp + -16 ]
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
40008350: e4 22 00 13 st %l2, [ %o0 + %l3 ]
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
40008354: b6 02 00 13 add %o0, %l3, %i3
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
40008358: e2 26 e0 04 st %l1, [ %i3 + 4 ]
fd->flags = c->flags;
4000835c: f8 26 e0 08 st %i4, [ %i3 + 8 ]
fd->compact_segs = c->compact_segs;
40008360: c8 26 e0 0c st %g4, [ %i3 + 0xc ]
fd->avail_compact_segs = c->avail_compact_segs;
40008364: c6 26 e0 10 st %g3, [ %i3 + 0x10 ]
fd->block_size = c->block_size;
40008368: fa 26 e0 14 st %i5, [ %i3 + 0x14 ]
fd->unavail_blocks = c->unavail_blocks;
4000836c: c4 26 e0 20 st %g2, [ %i3 + 0x20 ]
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
40008370: 80 a5 20 00 cmp %l4, 0
40008374: 02 80 00 a3 be 40008600 <rtems_fdisk_initialize+0x3b4> <== NEVER TAKEN
40008378: c2 26 e0 6c st %g1, [ %i3 + 0x6c ]
4000837c: f4 04 20 08 ld [ %l0 + 8 ], %i2
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
40008380: 83 2d 20 02 sll %l4, 2, %g1
40008384: b1 2d 20 04 sll %l4, 4, %i0
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
40008388: b2 10 20 00 clr %i1
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
4000838c: b0 26 00 01 sub %i0, %g1, %i0
40008390: b0 06 80 18 add %i2, %i0, %i0
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
40008394: c4 06 80 00 ld [ %i2 ], %g2
40008398: 80 a0 a0 00 cmp %g2, 0
4000839c: 02 80 00 93 be 400085e8 <rtems_fdisk_initialize+0x39c> <== NEVER TAKEN
400083a0: 87 28 a0 02 sll %g2, 2, %g3
400083a4: ea 06 a0 04 ld [ %i2 + 4 ], %l5
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
400083a8: b9 28 a0 04 sll %g2, 4, %i4
*/
static uint32_t
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
400083ac: ae 10 20 00 clr %l7
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
400083b0: b8 27 00 03 sub %i4, %g3, %i4
400083b4: b8 05 40 1c add %l5, %i4, %i4
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
400083b8: d0 05 60 08 ld [ %l5 + 8 ], %o0
400083bc: 7f ff e8 b9 call 400026a0 <.udiv>
400083c0: 92 10 00 1d mov %i5, %o1
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
return ((bytes - 1) / page_size) + 1;
400083c4: 92 10 00 1d mov %i5, %o1
400083c8: ac 02 3f ff add %o0, -1, %l6
static uint32_t
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
400083cc: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
400083d0: 7f ff e8 b4 call 400026a0 <.udiv>
400083d4: 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;
400083d8: d2 15 40 00 lduh [ %l5 ], %o1
400083dc: 7f ff e8 77 call 400025b8 <.umul>
400083e0: 90 25 80 08 sub %l6, %o0, %o0
400083e4: aa 05 60 0c add %l5, 0xc, %l5
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
400083e8: 80 a5 40 1c cmp %l5, %i4
400083ec: 12 bf ff f3 bne 400083b8 <rtems_fdisk_initialize+0x16c> <== NEVER TAKEN
400083f0: ae 05 c0 08 add %l7, %o0, %l7
400083f4: b4 06 a0 0c add %i2, 0xc, %i2
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
400083f8: 80 a6 80 18 cmp %i2, %i0
400083fc: 12 bf ff e6 bne 40008394 <rtems_fdisk_initialize+0x148> <== NEVER TAKEN
40008400: b2 06 40 17 add %i1, %l7, %i1
c->block_size);
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
40008404: 40 00 04 e6 call 4000979c <malloc>
40008408: 90 10 00 1d mov %i5, %o0
if (!fd->copy_buffer)
4000840c: 80 a2 20 00 cmp %o0, 0
40008410: 02 80 00 af be 400086cc <rtems_fdisk_initialize+0x480> <== NEVER TAKEN
40008414: d0 26 e0 68 st %o0, [ %i3 + 0x68 ]
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
40008418: 90 10 00 19 mov %i1, %o0
4000841c: 40 00 02 e0 call 40008f9c <calloc>
40008420: 92 10 20 08 mov 8, %o1
if (!fd->blocks)
40008424: 80 a2 20 00 cmp %o0, 0
40008428: 02 80 00 a9 be 400086cc <rtems_fdisk_initialize+0x480> <== NEVER TAKEN
4000842c: d0 26 e0 18 st %o0, [ %i3 + 0x18 ]
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
40008430: f2 26 e0 1c st %i1, [ %i3 + 0x1c ]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
40008434: 90 10 00 14 mov %l4, %o0
40008438: 40 00 02 d9 call 40008f9c <calloc>
4000843c: 92 10 20 0c mov 0xc, %o1
if (!fd->devices)
40008440: 80 a2 20 00 cmp %o0, 0
40008444: 02 80 00 a2 be 400086cc <rtems_fdisk_initialize+0x480> <== NEVER TAKEN
40008448: d0 26 e0 2c st %o0, [ %i3 + 0x2c ]
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
4000844c: 03 10 00 d7 sethi %hi(0x40035c00), %g1
40008450: d0 00 63 28 ld [ %g1 + 0x328 ], %o0 ! 40035f28 <Callbacks.6428+0xce0>
40008454: 92 10 20 01 mov 1, %o1
40008458: 94 10 20 54 mov 0x54, %o2
4000845c: 96 10 20 00 clr %o3
40008460: 40 00 15 fa call 4000dc48 <rtems_semaphore_create>
40008464: 98 06 e0 64 add %i3, 0x64, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
40008468: b0 92 20 00 orcc %o0, 0, %i0
4000846c: 12 80 00 8d bne 400086a0 <rtems_fdisk_initialize+0x454> <== NEVER TAKEN
40008470: b4 07 bf f0 add %fp, -16, %i2
free (fd->blocks);
free (fd->devices);
return sc;
}
sc = rtems_disk_create_phys(dev, c->block_size,
40008474: d6 06 e0 20 ld [ %i3 + 0x20 ], %o3
40008478: d4 04 00 00 ld [ %l0 ], %o2
4000847c: 90 10 00 12 mov %l2, %o0
40008480: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
40008484: 92 10 00 11 mov %l1, %o1
40008488: 96 26 40 0b sub %i1, %o3, %o3
4000848c: 19 10 00 1b sethi %hi(0x40006c00), %o4
40008490: 9a 10 20 00 clr %o5
40008494: 7f ff f3 d4 call 400053e4 <rtems_disk_create_phys>
40008498: 98 13 22 34 or %o4, 0x234, %o4
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
4000849c: b0 92 20 00 orcc %o0, 0, %i0
400084a0: 12 80 00 70 bne 40008660 <rtems_fdisk_initialize+0x414> <== NEVER TAKEN
400084a4: 01 00 00 00 nop
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
400084a8: f0 04 20 04 ld [ %l0 + 4 ], %i0
400084ac: 80 a6 20 00 cmp %i0, 0
400084b0: 22 80 00 3b be,a 4000859c <rtems_fdisk_initialize+0x350> <== NEVER TAKEN
400084b4: f0 26 e0 30 st %i0, [ %i3 + 0x30 ] <== NOT EXECUTED
400084b8: f4 04 20 08 ld [ %l0 + 8 ], %i2
400084bc: f2 06 e0 2c ld [ %i3 + 0x2c ], %i1
400084c0: ba 10 20 00 clr %i5
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
400084c4: c4 06 80 00 ld [ %i2 ], %g2
400084c8: 80 a0 a0 00 cmp %g2, 0
400084cc: 02 80 00 5d be 40008640 <rtems_fdisk_initialize+0x3f4> <== NEVER TAKEN
400084d0: a9 28 a0 02 sll %g2, 2, %l4
400084d4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
* Count the segments for a device.
*/
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
400084d8: b8 10 20 00 clr %i4
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
400084dc: 85 28 a0 04 sll %g2, 4, %g2
400084e0: 88 20 80 14 sub %g2, %l4, %g4
400084e4: 88 00 40 04 add %g1, %g4, %g4
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
count += dd->segments[segment].count;
400084e8: c6 10 40 00 lduh [ %g1 ], %g3
400084ec: 82 00 60 0c add %g1, 0xc, %g1
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
400084f0: 80 a0 40 04 cmp %g1, %g4
400084f4: 12 bf ff fd bne 400084e8 <rtems_fdisk_initialize+0x29c> <== NEVER TAKEN
400084f8: b8 07 00 03 add %i4, %g3, %i4
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
400084fc: c4 27 bf ec st %g2, [ %fp + -20 ]
40008500: 90 10 00 1c mov %i4, %o0
40008504: 40 00 02 a6 call 40008f9c <calloc>
40008508: 92 10 20 30 mov 0x30, %o1
4000850c: d0 26 40 00 st %o0, [ %i1 ]
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
40008510: 80 a2 20 00 cmp %o0, 0
40008514: 02 80 00 3d be 40008608 <rtems_fdisk_initialize+0x3bc> <== NEVER TAKEN
40008518: c4 07 bf ec ld [ %fp + -20 ], %g2
4000851c: c6 06 a0 04 ld [ %i2 + 4 ], %g3
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
40008520: 84 20 80 14 sub %g2, %l4, %g2
40008524: 9e 00 c0 02 add %g3, %g2, %o7
const rtems_fdisk_segment_desc* sd;
uint32_t seg_segment;
sd = &c->devices[device].segments[segment];
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
40008528: c8 10 c0 00 lduh [ %g3 ], %g4
4000852c: 80 a1 20 00 cmp %g4, 0
40008530: 02 80 00 0f be 4000856c <rtems_fdisk_initialize+0x320> <== NEVER TAKEN
40008534: 82 10 00 08 mov %o0, %g1
40008538: 84 10 20 00 clr %g2
{
sc->descriptor = sd;
sc->device = device;
sc->segment = seg_segment;
4000853c: c4 20 60 0c st %g2, [ %g1 + 0xc ]
sd = &c->devices[device].segments[segment];
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
{
sc->descriptor = sd;
40008540: c6 20 60 04 st %g3, [ %g1 + 4 ]
sc->device = device;
40008544: fa 20 60 08 st %i5, [ %g1 + 8 ]
sc->segment = seg_segment;
sc->erased = 0;
40008548: 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++)
4000854c: 84 00 a0 01 inc %g2
40008550: 80 a0 80 04 cmp %g2, %g4
40008554: 0a bf ff fa bcs 4000853c <rtems_fdisk_initialize+0x2f0>
40008558: 82 00 60 30 add %g1, 0x30, %g1
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
4000855c: 83 29 20 04 sll %g4, 4, %g1
40008560: 89 29 20 06 sll %g4, 6, %g4
40008564: 88 21 00 01 sub %g4, %g1, %g4
40008568: 90 02 00 04 add %o0, %g4, %o0
4000856c: 86 00 e0 0c add %g3, 0xc, %g3
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
40008570: 80 a0 c0 0f cmp %g3, %o7
40008574: 32 bf ff ee bne,a 4000852c <rtems_fdisk_initialize+0x2e0><== NEVER TAKEN
40008578: c8 10 c0 00 lduh [ %g3 ], %g4 <== NOT EXECUTED
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
fd->devices[device].descriptor = &c->devices[device];
4000857c: f4 26 60 08 st %i2, [ %i1 + 8 ]
sc->segment = seg_segment;
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
40008580: f8 26 60 04 st %i4, [ %i1 + 4 ]
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
40008584: ba 07 60 01 inc %i5
40008588: b4 06 a0 0c add %i2, 0xc, %i2
4000858c: 80 a7 40 18 cmp %i5, %i0
40008590: 12 bf ff cd bne 400084c4 <rtems_fdisk_initialize+0x278> <== NEVER TAKEN
40008594: b2 06 60 0c add %i1, 0xc, %i1
fd->devices[device].segment_count = segment_count;
fd->devices[device].descriptor = &c->devices[device];
}
fd->device_count = c->device_count;
40008598: f0 26 e0 30 st %i0, [ %i3 + 0x30 ]
ret = rtems_fdisk_recover_block_mappings (fd);
4000859c: 7f ff f9 31 call 40006a60 <rtems_fdisk_recover_block_mappings>
400085a0: 90 10 00 1b mov %i3, %o0
if (ret)
400085a4: b0 92 20 00 orcc %o0, 0, %i0
400085a8: 12 80 00 63 bne 40008734 <rtems_fdisk_initialize+0x4e8> <== NEVER TAKEN
400085ac: 92 10 00 11 mov %l1, %o1
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
strerror (ret), ret);
return ret;
}
ret = rtems_fdisk_compact (fd);
400085b0: 7f ff f8 76 call 40006788 <rtems_fdisk_compact>
400085b4: 90 10 00 1b mov %i3, %o0
if (ret)
400085b8: b0 92 20 00 orcc %o0, 0, %i0
400085bc: 12 80 00 4a bne 400086e4 <rtems_fdisk_initialize+0x498> <== NEVER TAKEN
400085c0: a0 04 20 20 add %l0, 0x20, %l0
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
400085c4: 37 10 00 e8 sethi %hi(0x4003a000), %i3
400085c8: fa 06 e3 bc ld [ %i3 + 0x3bc ], %i5 ! 4003a3bc <rtems_flashdisk_configuration_size>
400085cc: a2 04 60 01 inc %l1
400085d0: 80 a7 40 11 cmp %i5, %l1
400085d4: 08 80 00 40 bleu 400086d4 <rtems_fdisk_initialize+0x488> <== ALWAYS TAKEN
400085d8: a6 04 e0 74 add %l3, 0x74, %l3
400085dc: 03 10 01 2a sethi %hi(0x4004a800), %g1 <== NOT EXECUTED
400085e0: 10 bf ff 4c b 40008310 <rtems_fdisk_initialize+0xc4> <== NOT EXECUTED
400085e4: d0 00 63 70 ld [ %g1 + 0x370 ], %o0 ! 4004ab70 <rtems_flashdisks><== NOT EXECUTED
*/
static uint32_t
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
400085e8: ae 10 20 00 clr %l7 <== NOT EXECUTED
400085ec: b4 06 a0 0c add %i2, 0xc, %i2 <== NOT EXECUTED
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
400085f0: 80 a6 80 18 cmp %i2, %i0 <== NOT EXECUTED
400085f4: 12 bf ff 68 bne 40008394 <rtems_fdisk_initialize+0x148> <== NOT EXECUTED
400085f8: b2 06 40 17 add %i1, %l7, %i1 <== NOT EXECUTED
400085fc: 30 bf ff 82 b,a 40008404 <rtems_fdisk_initialize+0x1b8> <== NOT EXECUTED
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
40008600: 10 bf ff 81 b 40008404 <rtems_fdisk_initialize+0x1b8> <== NOT EXECUTED
40008604: b2 10 20 00 clr %i1 <== NOT EXECUTED
fd->devices[device].segments = calloc (segment_count,
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
{
rtems_disk_delete (dev);
40008608: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4000860c: 7f ff f2 c5 call 40005120 <rtems_disk_delete> <== NOT EXECUTED
40008610: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
40008614: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
40008618: 40 00 15 fd call 4000de0c <rtems_semaphore_delete> <== NOT EXECUTED
4000861c: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED
free (fd->copy_buffer);
40008620: 40 00 02 c2 call 40009128 <free> <== NOT EXECUTED
40008624: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40008628: 40 00 02 c0 call 40009128 <free> <== NOT EXECUTED
4000862c: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40008630: 40 00 02 be call 40009128 <free> <== NOT EXECUTED
40008634: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
40008638: 81 c7 e0 08 ret <== NOT EXECUTED
4000863c: 81 e8 00 00 restore <== NOT EXECUTED
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
40008640: 90 10 20 00 clr %o0 <== NOT EXECUTED
40008644: 40 00 02 56 call 40008f9c <calloc> <== NOT EXECUTED
40008648: 92 10 20 30 mov 0x30, %o1 <== NOT EXECUTED
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
4000864c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40008650: 02 bf ff ee be 40008608 <rtems_fdisk_initialize+0x3bc> <== NOT EXECUTED
40008654: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED
* Count the segments for a device.
*/
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
40008658: 10 bf ff c9 b 4000857c <rtems_fdisk_initialize+0x330> <== NOT EXECUTED
4000865c: b8 10 20 00 clr %i4 <== NOT EXECUTED
sc = rtems_disk_create_phys(dev, c->block_size,
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_semaphore_delete (fd->lock);
40008660: 40 00 15 eb call 4000de0c <rtems_semaphore_delete> <== NOT EXECUTED
40008664: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
rtems_disk_delete (dev);
40008668: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4000866c: 7f ff f2 ad call 40005120 <rtems_disk_delete> <== NOT EXECUTED
40008670: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40008674: 40 00 02 ad call 40009128 <free> <== NOT EXECUTED
40008678: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
4000867c: 40 00 02 ab call 40009128 <free> <== NOT EXECUTED
40008680: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40008684: 40 00 02 a9 call 40009128 <free> <== NOT EXECUTED
40008688: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("disk create phy failed");
4000868c: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40008690: 7f ff f5 ca call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40008694: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 40035ec0 <Callbacks.6428+0xc78><== NOT EXECUTED
40008698: 81 c7 e0 08 ret <== NOT EXECUTED
4000869c: 81 e8 00 00 restore <== NOT EXECUTED
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_fdisk_error ("disk lock create failed");
400086a0: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
400086a4: 7f ff f5 c5 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
400086a8: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 40035ea8 <Callbacks.6428+0xc60><== NOT EXECUTED
free (fd->copy_buffer);
400086ac: 40 00 02 9f call 40009128 <free> <== NOT EXECUTED
400086b0: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
400086b4: 40 00 02 9d call 40009128 <free> <== NOT EXECUTED
400086b8: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
400086bc: 40 00 02 9b call 40009128 <free> <== NOT EXECUTED
400086c0: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
400086c4: 81 c7 e0 08 ret <== NOT EXECUTED
400086c8: 81 e8 00 00 restore <== NOT EXECUTED
fd->block_count = blocks;
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
if (!fd->devices)
return RTEMS_NO_MEMORY;
400086cc: 81 c7 e0 08 ret <== NOT EXECUTED
400086d0: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
strerror (ret), ret);
return ret;
}
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
400086d4: 03 10 01 2a sethi %hi(0x4004a800), %g1
400086d8: fa 20 63 74 st %i5, [ %g1 + 0x374 ] ! 4004ab74 <rtems_flashdisk_count>
return RTEMS_SUCCESSFUL;
400086dc: 81 c7 e0 08 ret
400086e0: 91 e8 20 00 restore %g0, 0, %o0
}
ret = rtems_fdisk_compact (fd);
if (ret)
{
rtems_disk_delete (dev);
400086e4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
400086e8: 7f ff f2 8e call 40005120 <rtems_disk_delete> <== NOT EXECUTED
400086ec: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
400086f0: 40 00 15 c7 call 4000de0c <rtems_semaphore_delete> <== NOT EXECUTED
400086f4: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
400086f8: 40 00 02 8c call 40009128 <free> <== NOT EXECUTED
400086fc: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
40008700: 40 00 02 8a call 40009128 <free> <== NOT EXECUTED
40008704: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40008708: 40 00 02 88 call 40009128 <free> <== NOT EXECUTED
4000870c: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("compacting of disk failed: %s (%d)",
40008710: 40 00 76 e5 call 400262a4 <strerror> <== NOT EXECUTED
40008714: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40008718: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
4000871c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40008720: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40008724: 7f ff f5 a5 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40008728: 90 12 23 00 or %o0, 0x300, %o0 ! 40035f00 <Callbacks.6428+0xcb8><== NOT EXECUTED
4000872c: 81 c7 e0 08 ret <== NOT EXECUTED
40008730: 81 e8 00 00 restore <== NOT EXECUTED
fd->device_count = c->device_count;
ret = rtems_fdisk_recover_block_mappings (fd);
if (ret)
{
rtems_disk_delete (dev);
40008734: 7f ff f2 7b call 40005120 <rtems_disk_delete> <== NOT EXECUTED
40008738: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
4000873c: 40 00 15 b4 call 4000de0c <rtems_semaphore_delete> <== NOT EXECUTED
40008740: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
40008744: 40 00 02 79 call 40009128 <free> <== NOT EXECUTED
40008748: d0 06 e0 68 ld [ %i3 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
4000874c: 40 00 02 77 call 40009128 <free> <== NOT EXECUTED
40008750: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
40008754: 40 00 02 75 call 40009128 <free> <== NOT EXECUTED
40008758: d0 06 e0 2c ld [ %i3 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
4000875c: 40 00 76 d2 call 400262a4 <strerror> <== NOT EXECUTED
40008760: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40008764: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
40008768: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4000876c: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40008770: 7f ff f5 92 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40008774: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 40035ed8 <Callbacks.6428+0xc90><== NOT EXECUTED
40008778: 81 c7 e0 08 ret <== NOT EXECUTED
4000877c: 81 e8 00 00 restore <== NOT EXECUTED
40006e34 <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)
{
40006e34: 9d e3 bf 48 save %sp, -184, %sp
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
errno = 0;
40006e38: 40 00 73 40 call 40023b38 <__errno>
40006e3c: fa 06 20 04 ld [ %i0 + 4 ], %i5
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
40006e40: 21 10 01 2a sethi %hi(0x4004a800), %l0
40006e44: c2 04 23 70 ld [ %l0 + 0x370 ], %g1 ! 4004ab70 <rtems_flashdisks>
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
errno = 0;
40006e48: c0 22 00 00 clr [ %o0 ]
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
40006e4c: 87 2f 60 05 sll %i5, 5, %g3
40006e50: 85 2f 60 02 sll %i5, 2, %g2
40006e54: 84 20 c0 02 sub %g3, %g2, %g2
40006e58: 84 00 80 1d add %g2, %i5, %g2
40006e5c: ab 28 a0 02 sll %g2, 2, %l5
40006e60: 82 00 40 15 add %g1, %l5, %g1
40006e64: d0 00 60 64 ld [ %g1 + 0x64 ], %o0
40006e68: 92 10 20 00 clr %o1
40006e6c: 40 00 1c 1f call 4000dee8 <rtems_semaphore_obtain>
40006e70: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
40006e74: 80 a2 20 00 cmp %o0, 0
40006e78: 12 80 00 36 bne 40006f50 <rtems_fdisk_ioctl+0x11c> <== NEVER TAKEN
40006e7c: 01 00 00 00 nop
errno = EIO;
else
{
errno = 0;
40006e80: 40 00 73 2e call 40023b38 <__errno>
40006e84: 01 00 00 00 nop
switch (req)
40006e88: 03 08 00 10 sethi %hi(0x20004000), %g1
40006e8c: 84 10 62 83 or %g1, 0x283, %g2 ! 20004283 <RAM_SIZE+0x1fc04283>
40006e90: 80 a6 40 02 cmp %i1, %g2
40006e94: 02 80 00 5b be 40007000 <rtems_fdisk_ioctl+0x1cc> <== NEVER TAKEN
40006e98: c0 22 00 00 clr [ %o0 ]
40006e9c: 80 a6 40 02 cmp %i1, %g2
40006ea0: 38 80 00 37 bgu,a 40006f7c <rtems_fdisk_ioctl+0x148>
40006ea4: 82 10 62 85 or %g1, 0x285, %g1
40006ea8: 84 10 62 81 or %g1, 0x281, %g2
40006eac: 80 a6 40 02 cmp %i1, %g2
40006eb0: 02 80 00 de be 40007228 <rtems_fdisk_ioctl+0x3f4> <== NEVER TAKEN
40006eb4: 01 00 00 00 nop
40006eb8: 08 80 00 d0 bleu 400071f8 <rtems_fdisk_ioctl+0x3c4> <== ALWAYS TAKEN
40006ebc: 82 10 62 80 or %g1, 0x280, %g1
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
40006ec0: 40 00 73 1e call 40023b38 <__errno> <== NOT EXECUTED
40006ec4: b8 10 20 00 clr %i4 <== NOT EXECUTED
40006ec8: fa 04 23 70 ld [ %l0 + 0x370 ], %i5 <== NOT EXECUTED
40006ecc: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
40006ed0: ba 07 40 15 add %i5, %l5, %i5 <== NOT EXECUTED
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
40006ed4: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
40006ed8: 92 90 60 00 orcc %g1, 0, %o1 <== NOT EXECUTED
40006edc: 02 80 00 15 be 40006f30 <rtems_fdisk_ioctl+0xfc> <== NOT EXECUTED
40006ee0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
40006ee4: c4 00 40 00 ld [ %g1 ], %g2 <== NOT EXECUTED
if (!queue->head)
40006ee8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40006eec: 02 80 01 09 be 40007310 <rtems_fdisk_ioctl+0x4dc> <== NOT EXECUTED
40006ef0: c4 27 60 4c st %g2, [ %i5 + 0x4c ] <== NOT EXECUTED
queue->tail = 0;
queue->count--;
40006ef4: c4 07 60 54 ld [ %i5 + 0x54 ], %g2 <== NOT EXECUTED
40006ef8: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
40006efc: c4 27 60 54 st %g2, [ %i5 + 0x54 ] <== NOT EXECUTED
{
/*
* The segment will either end up on the available queue or
* the failed queue.
*/
int ret = rtems_fdisk_erase_segment (fd, sc);
40006f00: 7f ff fb cd call 40005e34 <rtems_fdisk_erase_segment> <== NOT EXECUTED
40006f04: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
if (ret && !latched_ret)
40006f08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40006f0c: 02 bf ff f3 be 40006ed8 <rtems_fdisk_ioctl+0xa4> <== NOT EXECUTED
40006f10: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
40006f14: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40006f18: 12 bf ff f0 bne 40006ed8 <rtems_fdisk_ioctl+0xa4> <== NOT EXECUTED
40006f1c: 01 00 00 00 nop <== NOT EXECUTED
40006f20: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
40006f24: 92 90 60 00 orcc %g1, 0, %o1 <== NOT EXECUTED
40006f28: 12 bf ff ef bne 40006ee4 <rtems_fdisk_ioctl+0xb0> <== NOT EXECUTED
40006f2c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006f30: c4 04 23 70 ld [ %l0 + 0x370 ], %g2 <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
40006f34: f8 26 c0 00 st %i4, [ %i3 ] <== NOT EXECUTED
40006f38: 84 00 80 15 add %g2, %l5, %g2 <== NOT EXECUTED
default:
rtems_blkdev_ioctl (dd, req, argp);
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
40006f3c: 40 00 1c 3a call 4000e024 <rtems_semaphore_release> <== NOT EXECUTED
40006f40: d0 00 a0 64 ld [ %g2 + 0x64 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40006f44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40006f48: 02 80 00 06 be 40006f60 <rtems_fdisk_ioctl+0x12c> <== NOT EXECUTED
40006f4c: 01 00 00 00 nop <== NOT EXECUTED
errno = EIO;
40006f50: 40 00 72 fa call 40023b38 <__errno> <== NOT EXECUTED
40006f54: 01 00 00 00 nop <== NOT EXECUTED
40006f58: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40006f5c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
40006f60: 40 00 72 f6 call 40023b38 <__errno> <== NOT EXECUTED
40006f64: 01 00 00 00 nop <== NOT EXECUTED
40006f68: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
40006f6c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
40006f70: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED
40006f74: 81 c7 e0 08 ret <== NOT EXECUTED
40006f78: 81 e8 00 00 restore <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
switch (req)
40006f7c: 80 a6 40 01 cmp %i1, %g1
40006f80: 02 80 00 e6 be 40007318 <rtems_fdisk_ioctl+0x4e4>
40006f84: 01 00 00 00 nop
40006f88: 0a 80 00 a5 bcs 4000721c <rtems_fdisk_ioctl+0x3e8> <== NEVER TAKEN
40006f8c: c4 04 23 70 ld [ %l0 + 0x370 ], %g2
40006f90: 03 30 06 10 sethi %hi(0xc0184000), %g1
40006f94: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
40006f98: 80 a6 40 01 cmp %i1, %g1
40006f9c: 12 80 00 9a bne 40007204 <rtems_fdisk_ioctl+0x3d0>
40006fa0: 90 10 00 18 mov %i0, %o0
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
40006fa4: 03 10 01 2a sethi %hi(0x4004a800), %g1
40006fa8: c2 00 63 74 ld [ %g1 + 0x374 ], %g1 ! 4004ab74 <rtems_flashdisk_count>
40006fac: 80 a0 40 1d cmp %g1, %i5
40006fb0: 08 80 02 0b bleu 400077dc <rtems_fdisk_ioctl+0x9a8> <== NEVER TAKEN
40006fb4: c2 04 23 70 ld [ %l0 + 0x370 ], %g1
(rtems_flashdisks[minor].device_count == 0))
40006fb8: 82 00 40 15 add %g1, %l5, %g1
{
errno = 0;
switch (req)
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
40006fbc: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
40006fc0: 80 a0 60 00 cmp %g1, 0
40006fc4: 02 80 02 06 be 400077dc <rtems_fdisk_ioctl+0x9a8> <== NEVER TAKEN
40006fc8: 01 00 00 00 nop
{
errno = ENODEV;
}
else
{
switch (r->req)
40006fcc: c2 06 80 00 ld [ %i2 ], %g1
40006fd0: 80 a0 60 00 cmp %g1, 0
40006fd4: 02 80 03 b0 be 40007e94 <rtems_fdisk_ioctl+0x1060>
40006fd8: 80 a0 60 01 cmp %g1, 1
40006fdc: 02 80 02 09 be 40007800 <rtems_fdisk_ioctl+0x9cc> <== ALWAYS TAKEN
40006fe0: 01 00 00 00 nop
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
break;
default:
errno = EINVAL;
40006fe4: 40 00 72 d5 call 40023b38 <__errno> <== NOT EXECUTED
40006fe8: 01 00 00 00 nop <== NOT EXECUTED
40006fec: c4 04 23 70 ld [ %l0 + 0x370 ], %g2 <== NOT EXECUTED
40006ff0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40006ff4: 84 00 80 15 add %g2, %l5, %g2 <== NOT EXECUTED
break;
40006ff8: 10 80 00 74 b 400071c8 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
40006ffc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
40007000: 40 00 72 ce call 40023b38 <__errno> <== NOT EXECUTED
40007004: 01 00 00 00 nop <== NOT EXECUTED
40007008: c4 04 23 70 ld [ %l0 + 0x370 ], %g2 <== NOT EXECUTED
4000700c: 84 00 80 15 add %g2, %l5, %g2 <== NOT EXECUTED
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
data->block_count = fd->block_count;
40007010: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
40007014: fa 00 a0 14 ld [ %g2 + 0x14 ], %i5 <== NOT EXECUTED
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
40007018: c8 00 a0 20 ld [ %g2 + 0x20 ], %g4 <== NOT EXECUTED
data->device_count = fd->device_count;
4000701c: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
40007020: fa 26 80 00 st %i5, [ %i2 ] <== NOT EXECUTED
data->block_count = fd->block_count;
40007024: c6 26 a0 04 st %g3, [ %i2 + 4 ] <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
40007028: c8 26 a0 08 st %g4, [ %i2 + 8 ] <== NOT EXECUTED
data->device_count = fd->device_count;
4000702c: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
data->blocks_used = 0;
for (i = 0; i < fd->block_count; i++)
40007030: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
40007034: 02 80 00 0f be 40007070 <rtems_fdisk_ioctl+0x23c> <== NOT EXECUTED
40007038: c0 26 a0 18 clr [ %i2 + 0x18 ] <== NOT EXECUTED
4000703c: fa 00 a0 18 ld [ %g2 + 0x18 ], %i5 <== NOT EXECUTED
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
40007040: 89 28 e0 03 sll %g3, 3, %g4 <== NOT EXECUTED
40007044: 86 10 20 00 clr %g3 <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
data->device_count = fd->device_count;
data->blocks_used = 0;
for (i = 0; i < fd->block_count; i++)
if (fd->blocks[i].segment)
40007048: f8 07 40 03 ld [ %i5 + %g3 ], %i4 <== NOT EXECUTED
4000704c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40007050: 02 80 00 05 be 40007064 <rtems_fdisk_ioctl+0x230> <== NOT EXECUTED
40007054: 86 00 e0 08 add %g3, 8, %g3 <== NOT EXECUTED
data->blocks_used++;
40007058: f8 06 a0 18 ld [ %i2 + 0x18 ], %i4 <== NOT EXECUTED
4000705c: b8 07 20 01 inc %i4 <== NOT EXECUTED
40007060: f8 26 a0 18 st %i4, [ %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++)
40007064: 80 a0 c0 04 cmp %g3, %g4 <== NOT EXECUTED
40007068: 32 bf ff f9 bne,a 4000704c <rtems_fdisk_ioctl+0x218> <== NOT EXECUTED
4000706c: f8 07 40 03 ld [ %i5 + %g3 ], %i4 <== NOT EXECUTED
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
40007070: c8 00 a0 34 ld [ %g2 + 0x34 ], %g4 <== NOT EXECUTED
uint32_t count = 0;
while (sc)
40007074: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
40007078: 02 80 00 06 be 40007090 <rtems_fdisk_ioctl+0x25c> <== NOT EXECUTED
4000707c: 86 10 20 00 clr %g3 <== NOT EXECUTED
{
count++;
sc = sc->next;
40007080: c8 01 00 00 ld [ %g4 ], %g4 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
40007084: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
40007088: 12 bf ff fe bne 40007080 <rtems_fdisk_ioctl+0x24c> <== NOT EXECUTED
4000708c: 86 00 e0 01 inc %g3 <== NOT EXECUTED
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
40007090: c8 00 a0 40 ld [ %g2 + 0x40 ], %g4 <== NOT EXECUTED
data->blocks_used = 0;
for (i = 0; i < fd->block_count; i++)
if (fd->blocks[i].segment)
data->blocks_used++;
data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
40007094: c6 26 a0 1c st %g3, [ %i2 + 0x1c ] <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
40007098: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
4000709c: 02 80 00 06 be 400070b4 <rtems_fdisk_ioctl+0x280> <== NOT EXECUTED
400070a0: 86 10 20 00 clr %g3 <== NOT EXECUTED
{
count++;
sc = sc->next;
400070a4: c8 01 00 00 ld [ %g4 ], %g4 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
400070a8: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
400070ac: 12 bf ff fe bne 400070a4 <rtems_fdisk_ioctl+0x270> <== NOT EXECUTED
400070b0: 86 00 e0 01 inc %g3 <== NOT EXECUTED
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
400070b4: c8 00 a0 58 ld [ %g2 + 0x58 ], %g4 <== NOT EXECUTED
for (i = 0; i < fd->block_count; i++)
if (fd->blocks[i].segment)
data->blocks_used++;
data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
data->segs_used = rtems_fdisk_segment_count_queue (&fd->used);
400070b8: c6 26 a0 20 st %g3, [ %i2 + 0x20 ] <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
400070bc: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
400070c0: 02 80 00 06 be 400070d8 <rtems_fdisk_ioctl+0x2a4> <== NOT EXECUTED
400070c4: 86 10 20 00 clr %g3 <== NOT EXECUTED
{
count++;
sc = sc->next;
400070c8: c8 01 00 00 ld [ %g4 ], %g4 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
400070cc: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
400070d0: 12 bf ff fe bne 400070c8 <rtems_fdisk_ioctl+0x294> <== NOT EXECUTED
400070d4: 86 00 e0 01 inc %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);
400070d8: c6 26 a0 24 st %g3, [ %i2 + 0x24 ] <== NOT EXECUTED
data->segment_count = 0;
400070dc: c0 26 a0 10 clr [ %i2 + 0x10 ] <== NOT EXECUTED
data->page_count = 0;
400070e0: c0 26 a0 14 clr [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc = 0;
400070e4: c0 26 a0 2c clr [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active = 0;
400070e8: c0 26 a0 30 clr [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used = 0;
400070ec: c0 26 a0 34 clr [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad = 0;
400070f0: c0 26 a0 38 clr [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
400070f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400070f8: 02 80 00 31 be 400071bc <rtems_fdisk_ioctl+0x388> <== NOT EXECUTED
400070fc: c0 26 a0 28 clr [ %i2 + 0x28 ] <== NOT EXECUTED
40007100: e0 00 a0 2c ld [ %g2 + 0x2c ], %l0 <== NOT EXECUTED
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
40007104: 87 28 60 02 sll %g1, 2, %g3 <== NOT EXECUTED
40007108: a2 10 20 00 clr %l1 <== NOT EXECUTED
4000710c: 83 28 60 04 sll %g1, 4, %g1 <== NOT EXECUTED
40007110: a4 20 40 03 sub %g1, %g3, %l2 <== NOT EXECUTED
40007114: a4 04 00 12 add %l0, %l2, %l2 <== NOT EXECUTED
data->pages_bad = 0;
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
40007118: f0 04 20 04 ld [ %l0 + 4 ], %i0 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
4000711c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
40007120: 02 80 00 22 be 400071a8 <rtems_fdisk_ioctl+0x374> <== NOT EXECUTED
40007124: a2 04 40 18 add %l1, %i0, %l1 <== NOT EXECUTED
40007128: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED
4000712c: f2 06 a0 14 ld [ %i2 + 0x14 ], %i1 <== NOT EXECUTED
40007130: f6 06 a0 2c ld [ %i2 + 0x2c ], %i3 <== NOT EXECUTED
40007134: f8 06 a0 30 ld [ %i2 + 0x30 ], %i4 <== NOT EXECUTED
40007138: fa 06 a0 34 ld [ %i2 + 0x34 ], %i5 <== NOT EXECUTED
4000713c: c8 06 a0 38 ld [ %i2 + 0x38 ], %g4 <== NOT EXECUTED
40007140: c6 06 a0 28 ld [ %i2 + 0x28 ], %g3 <== NOT EXECUTED
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
40007144: 9f 2e 20 04 sll %i0, 4, %o7 <== NOT EXECUTED
40007148: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED
4000714c: 92 26 00 0f sub %i0, %o7, %o1 <== NOT EXECUTED
40007150: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
40007154: d4 00 60 14 ld [ %g1 + 0x14 ], %o2 <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
40007158: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
data->pages_active += sc->pages_active;
4000715c: d8 00 60 1c ld [ %g1 + 0x1c ], %o4 <== NOT EXECUTED
data->pages_used += sc->pages_used;
40007160: da 00 60 20 ld [ %g1 + 0x20 ], %o5 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
40007164: de 00 60 24 ld [ %g1 + 0x24 ], %o7 <== NOT EXECUTED
data->seg_erases += sc->erased;
40007168: f0 00 60 2c ld [ %g1 + 0x2c ], %i0 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
4000716c: b2 06 40 0a add %i1, %o2, %i1 <== NOT EXECUTED
40007170: 82 00 60 30 add %g1, 0x30, %g1 <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
40007174: b6 06 c0 0b add %i3, %o3, %i3 <== NOT EXECUTED
data->pages_active += sc->pages_active;
40007178: b8 07 00 0c add %i4, %o4, %i4 <== NOT EXECUTED
data->pages_used += sc->pages_used;
4000717c: ba 07 40 0d add %i5, %o5, %i5 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
40007180: 88 01 00 0f add %g4, %o7, %g4 <== 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++)
40007184: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED
40007188: 12 bf ff f3 bne 40007154 <rtems_fdisk_ioctl+0x320> <== NOT EXECUTED
4000718c: 86 00 c0 18 add %g3, %i0, %g3 <== NOT EXECUTED
40007190: f2 26 a0 14 st %i1, [ %i2 + 0x14 ] <== NOT EXECUTED
40007194: f6 26 a0 2c st %i3, [ %i2 + 0x2c ] <== NOT EXECUTED
40007198: f8 26 a0 30 st %i4, [ %i2 + 0x30 ] <== NOT EXECUTED
4000719c: fa 26 a0 34 st %i5, [ %i2 + 0x34 ] <== NOT EXECUTED
400071a0: c8 26 a0 38 st %g4, [ %i2 + 0x38 ] <== NOT EXECUTED
400071a4: c6 26 a0 28 st %g3, [ %i2 + 0x28 ] <== NOT EXECUTED
400071a8: a0 04 20 0c add %l0, 0xc, %l0 <== NOT EXECUTED
data->pages_active = 0;
data->pages_used = 0;
data->pages_bad = 0;
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
400071ac: 80 a4 00 12 cmp %l0, %l2 <== NOT EXECUTED
400071b0: 32 bf ff db bne,a 4000711c <rtems_fdisk_ioctl+0x2e8> <== NOT EXECUTED
400071b4: f0 04 20 04 ld [ %l0 + 4 ], %i0 <== NOT EXECUTED
400071b8: e2 26 a0 10 st %l1, [ %i2 + 0x10 ] <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
data->seg_erases += sc->erased;
}
}
data->info_level = fd->info_level;
400071bc: c2 00 a0 6c ld [ %g2 + 0x6c ], %g1 <== NOT EXECUTED
400071c0: c2 26 a0 3c st %g1, [ %i2 + 0x3c ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
400071c4: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED
default:
rtems_blkdev_ioctl (dd, req, argp);
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
400071c8: 40 00 1b 97 call 4000e024 <rtems_semaphore_release>
400071cc: d0 00 a0 64 ld [ %g2 + 0x64 ], %o0
if (sc != RTEMS_SUCCESSFUL)
400071d0: 80 a2 20 00 cmp %o0, 0
400071d4: 12 bf ff 5f bne 40006f50 <rtems_fdisk_ioctl+0x11c> <== NEVER TAKEN
400071d8: 01 00 00 00 nop
errno = EIO;
}
return errno == 0 ? 0 : -1;
400071dc: 40 00 72 57 call 40023b38 <__errno>
400071e0: 01 00 00 00 nop
400071e4: c2 02 00 00 ld [ %o0 ], %g1
400071e8: 80 a0 00 01 cmp %g0, %g1
400071ec: b0 60 20 00 subx %g0, 0, %i0
400071f0: 81 c7 e0 08 ret
400071f4: 81 e8 00 00 restore
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
switch (req)
400071f8: 80 a6 40 01 cmp %i1, %g1
400071fc: 02 80 00 15 be 40007250 <rtems_fdisk_ioctl+0x41c> <== NEVER TAKEN
40007200: 90 10 00 18 mov %i0, %o0
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
break;
default:
rtems_blkdev_ioctl (dd, req, argp);
40007204: 92 10 00 19 mov %i1, %o1
40007208: 40 00 42 c8 call 40017d28 <rtems_blkdev_ioctl>
4000720c: 94 10 00 1a mov %i2, %o2
40007210: c4 04 23 70 ld [ %l0 + 0x370 ], %g2
break;
40007214: 10 bf ff ed b 400071c8 <rtems_fdisk_ioctl+0x394>
40007218: 84 00 80 15 add %g2, %l5, %g2
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
(rtems_fdisk_monitor_data*) argp);
break;
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
4000721c: 84 00 80 15 add %g2, %l5, %g2 <== NOT EXECUTED
break;
40007220: 10 bf ff ea b 400071c8 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
40007224: f4 20 a0 6c st %i2, [ %g2 + 0x6c ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
40007228: 40 00 72 44 call 40023b38 <__errno> <== NOT EXECUTED
4000722c: 01 00 00 00 nop <== NOT EXECUTED
40007230: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
40007234: d0 04 23 70 ld [ %l0 + 0x370 ], %o0 <== NOT EXECUTED
40007238: 7f ff fd 54 call 40006788 <rtems_fdisk_compact> <== NOT EXECUTED
4000723c: 90 02 00 15 add %o0, %l5, %o0 <== NOT EXECUTED
40007240: c4 04 23 70 ld [ %l0 + 0x370 ], %g2 <== NOT EXECUTED
40007244: d0 27 40 00 st %o0, [ %i5 ] <== NOT EXECUTED
break;
40007248: 10 bf ff e0 b 400071c8 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
4000724c: 84 00 80 15 add %g2, %l5, %g2 <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
40007250: 40 00 72 3a call 40023b38 <__errno> <== NOT EXECUTED
40007254: 01 00 00 00 nop <== NOT EXECUTED
40007258: fa 04 23 70 ld [ %l0 + 0x370 ], %i5 <== NOT EXECUTED
4000725c: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
40007260: ba 07 40 15 add %i5, %l5, %i5 <== NOT EXECUTED
{
uint32_t device;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "erase-disk");
40007264: 13 10 00 d7 sethi %hi(0x40035c00), %o1 <== NOT EXECUTED
40007268: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000726c: 7f ff f9 d7 call 400059c8 <rtems_fdisk_info> <== NOT EXECUTED
40007270: 92 12 60 78 or %o1, 0x78, %o1 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
40007274: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
40007278: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000727c: 02 80 03 e3 be 40008208 <rtems_fdisk_ioctl+0x13d4> <== NOT EXECUTED
40007280: 31 10 00 d7 sethi %hi(0x40035c00), %i0 <== 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);
40007284: 33 10 00 d7 sethi %hi(0x40035c00), %i1 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
40007288: b6 10 20 00 clr %i3 <== NOT EXECUTED
4000728c: b8 10 20 00 clr %i4 <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
40007290: b0 16 20 88 or %i0, 0x88, %i0 <== 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);
40007294: 10 80 00 06 b 400072ac <rtems_fdisk_ioctl+0x478> <== NOT EXECUTED
40007298: b2 16 60 a0 or %i1, 0xa0, %i1 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
4000729c: b8 07 20 01 inc %i4 <== NOT EXECUTED
400072a0: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
400072a4: 1a 80 03 be bcc 4000819c <rtems_fdisk_ioctl+0x1368> <== NOT EXECUTED
400072a8: b6 06 e0 0c add %i3, 0xc, %i3 <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
400072ac: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
400072b0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
400072b4: 7f ff f9 c5 call 400059c8 <rtems_fdisk_info> <== NOT EXECUTED
400072b8: 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;
400072bc: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
400072c0: 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;
400072c4: 82 00 40 1b add %g1, %i3, %g1 <== NOT EXECUTED
400072c8: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
400072cc: 92 10 00 19 mov %i1, %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;
400072d0: e2 00 60 08 ld [ %g1 + 8 ], %l1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
400072d4: 7f ff f9 df call 40005a50 <rtems_fdisk_printf> <== NOT EXECUTED
400072d8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
#endif
return ops->erase_device (fd->devices[device].descriptor, device);
400072dc: c4 07 60 2c ld [ %i5 + 0x2c ], %g2 <== NOT EXECUTED
400072e0: c2 04 60 14 ld [ %l1 + 0x14 ], %g1 <== NOT EXECUTED
400072e4: 84 00 80 1b add %g2, %i3, %g2 <== NOT EXECUTED
400072e8: d0 00 a0 08 ld [ %g2 + 8 ], %o0 <== NOT EXECUTED
400072ec: 9f c0 40 00 call %g1 <== NOT EXECUTED
400072f0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
rtems_fdisk_info (fd, " erase-flash:%02d", device);
#endif
ret = rtems_fdisk_device_erase (fd, device);
if (ret != 0)
400072f4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400072f8: 22 bf ff e9 be,a 4000729c <rtems_fdisk_ioctl+0x468> <== NOT EXECUTED
400072fc: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
40007300: c4 04 23 70 ld [ %l0 + 0x370 ], %g2 <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
40007304: d0 26 80 00 st %o0, [ %i2 ] <== NOT EXECUTED
break;
40007308: 10 bf ff b0 b 400071c8 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
4000730c: 84 00 80 15 add %g2, %l5, %g2 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
40007310: 10 bf fe f9 b 40006ef4 <rtems_fdisk_ioctl+0xc0> <== NOT EXECUTED
40007314: c0 27 60 50 clr [ %i5 + 0x50 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
break;
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
40007318: 40 00 72 08 call 40023b38 <__errno>
4000731c: ba 10 20 00 clr %i5
40007320: c2 04 23 70 ld [ %l0 + 0x370 ], %g1
40007324: d0 27 bf e8 st %o0, [ %fp + -24 ]
40007328: b6 00 40 15 add %g1, %l5, %i3
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
4000732c: d4 00 40 15 ld [ %g1 + %l5 ], %o2
*/
static int
rtems_fdisk_print_status (rtems_flashdisk* fd)
{
#if RTEMS_FDISK_TRACE
uint32_t current_info_level = fd->info_level;
40007330: c4 06 e0 6c ld [ %i3 + 0x6c ], %g2
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
40007334: d6 06 e0 04 ld [ %i3 + 4 ], %o3
uint32_t current_info_level = fd->info_level;
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
40007338: 82 10 20 03 mov 3, %g1
*/
static int
rtems_fdisk_print_status (rtems_flashdisk* fd)
{
#if RTEMS_FDISK_TRACE
uint32_t current_info_level = fd->info_level;
4000733c: c4 27 bf e4 st %g2, [ %fp + -28 ]
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
40007340: c2 26 e0 6c st %g1, [ %i3 + 0x6c ]
rtems_fdisk_printf (fd,
40007344: 90 10 00 1b mov %i3, %o0
40007348: 13 10 00 d7 sethi %hi(0x40035c00), %o1
4000734c: 7f ff f9 c1 call 40005a50 <rtems_fdisk_printf>
40007350: 92 12 60 b8 or %o1, 0xb8, %o1 ! 40035cb8 <Callbacks.6428+0xa70>
"Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
40007354: d4 06 e0 1c ld [ %i3 + 0x1c ], %o2
40007358: 90 10 00 1b mov %i3, %o0
4000735c: 13 10 00 d7 sethi %hi(0x40035c00), %o1
40007360: 7f ff f9 bc call 40005a50 <rtems_fdisk_printf>
40007364: 92 12 60 e0 or %o1, 0xe0, %o1 ! 40035ce0 <Callbacks.6428+0xa98>
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
40007368: d4 06 e0 20 ld [ %i3 + 0x20 ], %o2
4000736c: 90 10 00 1b mov %i3, %o0
40007370: 13 10 00 d7 sethi %hi(0x40035c00), %o1
40007374: 7f ff f9 b7 call 40005a50 <rtems_fdisk_printf>
40007378: 92 12 60 f0 or %o1, 0xf0, %o1 ! 40035cf0 <Callbacks.6428+0xaa8>
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
4000737c: d4 06 e0 24 ld [ %i3 + 0x24 ], %o2
40007380: 90 10 00 1b mov %i3, %o0
40007384: 13 10 00 d7 sethi %hi(0x40035c00), %o1
40007388: 7f ff f9 b2 call 40005a50 <rtems_fdisk_printf>
4000738c: 92 12 61 08 or %o1, 0x108, %o1 ! 40035d08 <Callbacks.6428+0xac0>
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
40007390: d4 06 e0 70 ld [ %i3 + 0x70 ], %o2
40007394: 90 10 00 1b mov %i3, %o0
40007398: 13 10 00 d7 sethi %hi(0x40035c00), %o1
4000739c: 7f ff f9 ad call 40005a50 <rtems_fdisk_printf>
400073a0: 92 12 61 20 or %o1, 0x120, %o1 ! 40035d20 <Callbacks.6428+0xad8>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
400073a4: c2 06 e0 34 ld [ %i3 + 0x34 ], %g1
uint32_t count = 0;
while (sc)
400073a8: 80 a0 60 00 cmp %g1, 0
400073ac: 22 80 00 07 be,a 400073c8 <rtems_fdisk_ioctl+0x594> <== NEVER TAKEN
400073b0: d6 06 e0 3c ld [ %i3 + 0x3c ], %o3 <== NOT EXECUTED
{
count++;
sc = sc->next;
400073b4: c2 00 40 00 ld [ %g1 ], %g1
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
400073b8: 80 a0 60 00 cmp %g1, 0
400073bc: 12 bf ff fe bne 400073b4 <rtems_fdisk_ioctl+0x580> <== NEVER TAKEN
400073c0: ba 07 60 01 inc %i5
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
count = rtems_fdisk_segment_count_queue (&fd->available);
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
400073c4: d6 06 e0 3c ld [ %i3 + 0x3c ], %o3
400073c8: 94 10 00 1d mov %i5, %o2
400073cc: 90 10 00 1b mov %i3, %o0
400073d0: 13 10 00 d7 sethi %hi(0x40035c00), %o1
400073d4: 7f ff f9 9f call 40005a50 <rtems_fdisk_printf>
400073d8: 92 12 61 30 or %o1, 0x130, %o1 ! 40035d30 <Callbacks.6428+0xae8>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
400073dc: c2 06 e0 40 ld [ %i3 + 0x40 ], %g1
uint32_t count = 0;
while (sc)
400073e0: 80 a0 60 00 cmp %g1, 0
400073e4: 02 80 00 06 be 400073fc <rtems_fdisk_ioctl+0x5c8> <== NEVER TAKEN
400073e8: 94 10 20 00 clr %o2
{
count++;
sc = sc->next;
400073ec: c2 00 40 00 ld [ %g1 ], %g1
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
400073f0: 80 a0 60 00 cmp %g1, 0
400073f4: 12 bf ff fe bne 400073ec <rtems_fdisk_ioctl+0x5b8>
400073f8: 94 02 a0 01 inc %o2
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
400073fc: d6 06 e0 48 ld [ %i3 + 0x48 ], %o3
count = rtems_fdisk_segment_count_queue (&fd->available);
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
total += count;
40007400: ba 02 80 1d add %o2, %i5, %i5
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
40007404: 90 10 00 1b mov %i3, %o0
40007408: 13 10 00 d7 sethi %hi(0x40035c00), %o1
4000740c: 7f ff f9 91 call 40005a50 <rtems_fdisk_printf>
40007410: 92 12 61 50 or %o1, 0x150, %o1 ! 40035d50 <Callbacks.6428+0xb08>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
40007414: c2 06 e0 4c ld [ %i3 + 0x4c ], %g1
uint32_t count = 0;
while (sc)
40007418: 80 a0 60 00 cmp %g1, 0
4000741c: 02 80 00 06 be 40007434 <rtems_fdisk_ioctl+0x600> <== ALWAYS TAKEN
40007420: 94 10 20 00 clr %o2
{
count++;
sc = sc->next;
40007424: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
40007428: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000742c: 12 bf ff fe bne 40007424 <rtems_fdisk_ioctl+0x5f0> <== NOT EXECUTED
40007430: 94 02 a0 01 inc %o2 <== NOT EXECUTED
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
40007434: d6 06 e0 54 ld [ %i3 + 0x54 ], %o3
count = rtems_fdisk_segment_count_queue (&fd->used);
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
total += count;
40007438: ba 07 40 0a add %i5, %o2, %i5
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
4000743c: 90 10 00 1b mov %i3, %o0
40007440: 13 10 00 d7 sethi %hi(0x40035c00), %o1
40007444: 7f ff f9 83 call 40005a50 <rtems_fdisk_printf>
40007448: 92 12 61 68 or %o1, 0x168, %o1 ! 40035d68 <Callbacks.6428+0xb20>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
4000744c: c4 06 e0 58 ld [ %i3 + 0x58 ], %g2
uint32_t count = 0;
while (sc)
40007450: 80 a0 a0 00 cmp %g2, 0
40007454: 02 80 00 06 be 4000746c <rtems_fdisk_ioctl+0x638> <== ALWAYS TAKEN
40007458: 94 10 20 00 clr %o2
{
count++;
sc = sc->next;
4000745c: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
40007460: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40007464: 12 bf ff fe bne 4000745c <rtems_fdisk_ioctl+0x628> <== NOT EXECUTED
40007468: 94 02 a0 01 inc %o2 <== NOT EXECUTED
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->erase));
count = rtems_fdisk_segment_count_queue (&fd->failed);
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
4000746c: d6 06 e0 60 ld [ %i3 + 0x60 ], %o3
count = rtems_fdisk_segment_count_queue (&fd->erase);
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->erase));
count = rtems_fdisk_segment_count_queue (&fd->failed);
total += count;
40007470: ba 07 40 0a add %i5, %o2, %i5
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
40007474: 90 10 00 1b mov %i3, %o0
40007478: 13 10 00 d7 sethi %hi(0x40035c00), %o1
4000747c: 7f ff f9 75 call 40005a50 <rtems_fdisk_printf>
40007480: 92 12 61 80 or %o1, 0x180, %o1 ! 40035d80 <Callbacks.6428+0xb38>
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
40007484: c4 06 e0 30 ld [ %i3 + 0x30 ], %g2
40007488: 80 a0 a0 00 cmp %g2, 0
4000748c: 02 80 00 db be 400077f8 <rtems_fdisk_ioctl+0x9c4> <== NEVER TAKEN
40007490: 87 28 a0 02 sll %g2, 2, %g3
40007494: c2 06 e0 2c ld [ %i3 + 0x2c ], %g1
count = rtems_fdisk_segment_count_queue (&fd->failed);
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
40007498: 96 10 20 00 clr %o3
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
4000749c: 85 28 a0 04 sll %g2, 4, %g2
400074a0: 84 20 80 03 sub %g2, %g3, %g2
400074a4: 84 00 80 01 add %g2, %g1, %g2
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
count += fd->devices[device].segment_count;
400074a8: c6 00 60 04 ld [ %g1 + 4 ], %g3
400074ac: 82 00 60 0c add %g1, 0xc, %g1
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
400074b0: 80 a0 40 02 cmp %g1, %g2
400074b4: 12 bf ff fd bne 400074a8 <rtems_fdisk_ioctl+0x674> <== NEVER TAKEN
400074b8: 96 02 c0 03 add %o3, %g3, %o3
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
400074bc: 19 10 00 d6 sethi %hi(0x40035800), %o4
400074c0: 80 a7 40 0b cmp %i5, %o3
400074c4: 02 80 02 71 be 40007e88 <rtems_fdisk_ioctl+0x1054> <== ALWAYS TAKEN
400074c8: 98 13 20 80 or %o4, 0x80, %o4
400074cc: 94 10 00 1d mov %i5, %o2
400074d0: 90 10 00 1b mov %i3, %o0
400074d4: 13 10 00 d7 sethi %hi(0x40035c00), %o1
400074d8: 7f ff f9 5e call 40005a50 <rtems_fdisk_printf>
400074dc: 92 12 61 98 or %o1, 0x198, %o1 ! 40035d98 <Callbacks.6428+0xb50>
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
400074e0: d4 06 e0 30 ld [ %i3 + 0x30 ], %o2
400074e4: 90 10 00 1b mov %i3, %o0
400074e8: 13 10 00 d7 sethi %hi(0x40035c00), %o1
400074ec: 7f ff f9 59 call 40005a50 <rtems_fdisk_printf>
400074f0: 92 12 61 b8 or %o1, 0x1b8, %o1 ! 40035db8 <Callbacks.6428+0xb70>
for (device = 0; device < fd->device_count; device++)
400074f4: c2 06 e0 30 ld [ %i3 + 0x30 ], %g1
400074f8: 80 a0 60 00 cmp %g1, 0
400074fc: 22 80 00 8e be,a 40007734 <rtems_fdisk_ioctl+0x900> <== NEVER TAKEN
40007500: fa 06 e0 40 ld [ %i3 + 0x40 ], %i5 <== NOT EXECUTED
40007504: b0 10 20 00 clr %i0
40007508: c0 27 bf ec clr [ %fp + -20 ]
{
uint32_t block;
uint32_t seg;
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
4000750c: d4 07 bf ec ld [ %fp + -20 ], %o2
40007510: 13 10 00 d7 sethi %hi(0x40035c00), %o1
40007514: 90 10 00 1b mov %i3, %o0
40007518: 7f ff f9 4e call 40005a50 <rtems_fdisk_printf>
4000751c: 92 12 61 c8 or %o1, 0x1c8, %o1
rtems_fdisk_printf (fd, " Segment count\t%ld",
40007520: c2 06 e0 2c ld [ %i3 + 0x2c ], %g1
40007524: 90 10 00 1b mov %i3, %o0
40007528: 82 00 40 18 add %g1, %i0, %g1
4000752c: d4 00 60 04 ld [ %g1 + 4 ], %o2
40007530: 13 10 00 d7 sethi %hi(0x40035c00), %o1
40007534: 7f ff f9 47 call 40005a50 <rtems_fdisk_printf>
40007538: 92 12 61 d8 or %o1, 0x1d8, %o1 ! 40035dd8 <Callbacks.6428+0xb90>
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
4000753c: c2 06 e0 2c ld [ %i3 + 0x2c ], %g1
40007540: 82 00 40 18 add %g1, %i0, %g1
40007544: c4 00 60 04 ld [ %g1 + 4 ], %g2
40007548: 80 a0 a0 00 cmp %g2, 0
4000754c: 02 80 00 73 be 40007718 <rtems_fdisk_ioctl+0x8e4> <== NEVER TAKEN
40007550: c4 07 bf ec ld [ %fp + -20 ], %g2
40007554: b2 10 20 00 clr %i1
40007558: b4 10 20 00 clr %i2
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
4000755c: f8 00 40 00 ld [ %g1 ], %i4
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
40007560: 90 10 00 1b mov %i3, %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];
40007564: b8 07 00 19 add %i4, %i1, %i4
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
40007568: 94 07 bf f8 add %fp, -8, %o2
4000756c: 7f ff f8 b9 call 40005850 <rtems_fdisk_queue_status>
40007570: 92 10 00 1c mov %i4, %o1
for (page = 0; page < sc->pages; page++)
40007574: d8 07 20 14 ld [ %i4 + 0x14 ], %o4
40007578: 80 a3 20 00 cmp %o4, 0
4000757c: 22 80 00 94 be,a 400077cc <rtems_fdisk_ioctl+0x998> <== NEVER TAKEN
40007580: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
40007584: c6 06 e0 1c ld [ %i3 + 0x1c ], %g3
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
40007588: a8 10 20 00 clr %l4
4000758c: 82 10 00 03 mov %g3, %g1
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;
40007590: ae 10 20 00 clr %l7
uint32_t used = 0;
40007594: ac 10 20 00 clr %l6
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
40007598: a2 10 20 00 clr %l1
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
4000759c: a4 10 20 00 clr %l2
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
400075a0: c8 07 20 10 ld [ %i4 + 0x10 ], %g4
* @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)
400075a4: 85 2c a0 03 sll %l2, 3, %g2
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
400075a8: fa 01 00 02 ld [ %g4 + %g2 ], %i5
400075ac: 80 a7 7f ff cmp %i5, -1
400075b0: 02 80 00 7d be 400077a4 <rtems_fdisk_ioctl+0x970>
400075b4: 84 01 00 02 add %g4, %g2, %g2
* 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;
400075b8: 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],
400075bc: 80 88 a0 01 btst 1, %g2
400075c0: 12 80 00 07 bne 400075dc <rtems_fdisk_ioctl+0x7a8> <== NEVER TAKEN
400075c4: 80 a0 e0 00 cmp %g3, 0
RTEMS_FDISK_PAGE_ACTIVE))
{
if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
400075c8: 80 88 a0 02 btst 2, %g2
400075cc: 32 80 00 7c bne,a 400077bc <rtems_fdisk_ioctl+0x988>
400075d0: ae 05 e0 01 inc %l7
RTEMS_FDISK_PAGE_USED))
used++;
400075d4: ac 05 a0 01 inc %l6
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
400075d8: 80 a0 e0 00 cmp %g3, 0
400075dc: 22 80 00 23 be,a 40007668 <rtems_fdisk_ioctl+0x834> <== NEVER TAKEN
400075e0: a4 04 a0 01 inc %l2 <== NOT EXECUTED
400075e4: ba 10 20 00 clr %i5
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
400075e8: 10 80 00 06 b 40007600 <rtems_fdisk_ioctl+0x7cc>
400075ec: a6 0d 20 ff and %l4, 0xff, %l3
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
400075f0: ba 07 60 01 inc %i5
400075f4: 80 a7 40 03 cmp %i5, %g3
400075f8: 1a 80 00 1a bcc 40007660 <rtems_fdisk_ioctl+0x82c>
400075fc: 82 10 00 03 mov %g3, %g1
{
if ((fd->blocks[block].segment == sc) &&
40007600: c4 06 e0 18 ld [ %i3 + 0x18 ], %g2
* @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)
40007604: 83 2f 60 03 sll %i5, 3, %g1
}
}
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
40007608: c8 00 80 01 ld [ %g2 + %g1 ], %g4
4000760c: 80 a7 00 04 cmp %i4, %g4
40007610: 12 bf ff f8 bne 400075f0 <rtems_fdisk_ioctl+0x7bc>
40007614: 82 00 80 01 add %g2, %g1, %g1
40007618: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000761c: 80 a4 80 01 cmp %l2, %g1
40007620: 32 bf ff f5 bne,a 400075f4 <rtems_fdisk_ioctl+0x7c0>
40007624: ba 07 60 01 inc %i5
(fd->blocks[block].page == page) && !is_active)
40007628: 80 a4 e0 00 cmp %l3, 0
4000762c: 32 bf ff f2 bne,a 400075f4 <rtems_fdisk_ioctl+0x7c0> <== ALWAYS TAKEN
40007630: ba 07 60 01 inc %i5
rtems_fdisk_printf (fd,
40007634: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
40007638: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000763c: 13 10 00 d7 sethi %hi(0x40035c00), %o1 <== NOT EXECUTED
40007640: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
40007644: 7f ff f9 03 call 40005a50 <rtems_fdisk_printf> <== NOT EXECUTED
40007648: 92 12 61 f0 or %o1, 0x1f0, %o1 <== NOT EXECUTED
4000764c: c6 06 e0 1c ld [ %i3 + 0x1c ], %g3 <== NOT EXECUTED
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
40007650: ba 07 60 01 inc %i5 <== NOT EXECUTED
40007654: 80 a7 40 03 cmp %i5, %g3 <== NOT EXECUTED
40007658: 0a bf ff ea bcs 40007600 <rtems_fdisk_ioctl+0x7cc> <== NOT EXECUTED
4000765c: 82 10 00 03 mov %g3, %g1 <== NOT EXECUTED
40007660: d8 07 20 14 ld [ %i4 + 0x14 ], %o4
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
40007664: a4 04 a0 01 inc %l2
40007668: 80 a4 80 0c cmp %l2, %o4
4000766c: 2a bf ff ce bcs,a 400075a4 <rtems_fdisk_ioctl+0x770>
40007670: c8 07 20 10 ld [ %i4 + 0x10 ], %g4
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
40007674: 80 a0 60 00 cmp %g1, 0
40007678: 02 80 00 53 be 400077c4 <rtems_fdisk_ioctl+0x990> <== NEVER TAKEN
4000767c: 83 28 60 03 sll %g1, 3, %g1
40007680: fa 06 e0 18 ld [ %i3 + 0x18 ], %i5
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
40007684: 84 10 20 00 clr %g2
40007688: 86 10 20 00 clr %g3
}
count = 0;
for (block = 0; block < fd->block_count; block++)
{
if (fd->blocks[block].segment == sc)
4000768c: c8 07 40 02 ld [ %i5 + %g2 ], %g4
40007690: 84 00 a0 08 add %g2, 8, %g2
count++;
40007694: 88 1f 00 04 xor %i4, %g4, %g4
40007698: 80 a0 00 04 cmp %g0, %g4
4000769c: 86 60 ff ff subx %g3, -1, %g3
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
400076a0: 80 a0 80 01 cmp %g2, %g1
400076a4: 32 bf ff fb bne,a 40007690 <rtems_fdisk_ioctl+0x85c>
400076a8: c8 07 40 02 ld [ %i5 + %g2 ], %g4
" 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),
400076ac: c4 07 20 20 ld [ %i4 + 0x20 ], %g2
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 +
400076b0: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
400076b4: c4 23 a0 60 st %g2, [ %sp + 0x60 ]
400076b8: ee 23 a0 5c st %l7, [ %sp + 0x5c ]
400076bc: ec 23 a0 64 st %l6, [ %sp + 0x64 ]
400076c0: e2 23 a0 68 st %l1, [ %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)
400076c4: c8 07 20 24 ld [ %i4 + 0x24 ], %g4
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
400076c8: 94 10 00 1a mov %i2, %o2
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
400076cc: 84 00 80 04 add %g2, %g4, %g2
400076d0: 84 00 80 01 add %g2, %g1, %g2
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
400076d4: 84 23 00 02 sub %o4, %g2, %g2
400076d8: 9a 10 00 01 mov %g1, %o5
400076dc: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
400076e0: c6 23 a0 70 st %g3, [ %sp + 0x70 ]
400076e4: 90 10 00 1b mov %i3, %o0
400076e8: 13 10 00 d7 sethi %hi(0x40035c00), %o1
400076ec: 96 07 bf f8 add %fp, -8, %o3
400076f0: 7f ff f8 d8 call 40005a50 <rtems_fdisk_printf>
400076f4: 92 12 62 20 or %o1, 0x220, %o1
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++)
400076f8: c2 06 e0 2c ld [ %i3 + 0x2c ], %g1
400076fc: b4 06 a0 01 inc %i2
40007700: 82 00 40 18 add %g1, %i0, %g1
40007704: c4 00 60 04 ld [ %g1 + 4 ], %g2
40007708: 80 a6 80 02 cmp %i2, %g2
4000770c: 0a bf ff 94 bcs 4000755c <rtems_fdisk_ioctl+0x728>
40007710: b2 06 60 30 add %i1, 0x30, %i1
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++)
40007714: c4 07 bf ec ld [ %fp + -20 ], %g2
40007718: c2 06 e0 30 ld [ %i3 + 0x30 ], %g1
4000771c: 84 00 a0 01 inc %g2
40007720: c4 27 bf ec st %g2, [ %fp + -20 ]
40007724: 80 a0 80 01 cmp %g2, %g1
40007728: 0a bf ff 79 bcs 4000750c <rtems_fdisk_ioctl+0x6d8> <== NEVER TAKEN
4000772c: b0 06 20 0c add %i0, 0xc, %i0
count);
}
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
40007730: fa 06 e0 40 ld [ %i3 + 0x40 ], %i5
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
40007734: 90 10 00 1b mov %i3, %o0
40007738: 13 10 00 d7 sethi %hi(0x40035c00), %o1
4000773c: 7f ff f8 c5 call 40005a50 <rtems_fdisk_printf>
40007740: 92 12 62 60 or %o1, 0x260, %o1 ! 40035e60 <Callbacks.6428+0xc18>
while (sc)
40007744: 80 a7 60 00 cmp %i5, 0
40007748: 02 80 00 11 be 4000778c <rtems_fdisk_ioctl+0x958> <== NEVER TAKEN
4000774c: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
40007750: 35 10 00 d7 sethi %hi(0x40035c00), %i2
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
while (sc)
40007754: b8 10 20 00 clr %i4
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
40007758: b4 16 a2 70 or %i2, 0x270, %i2
4000775c: d6 07 60 08 ld [ %i5 + 8 ], %o3
40007760: d8 07 60 0c ld [ %i5 + 0xc ], %o4
40007764: da 07 60 20 ld [ %i5 + 0x20 ], %o5
40007768: 94 10 00 1c mov %i4, %o2
4000776c: 90 10 00 1b mov %i3, %o0
40007770: 7f ff f8 b8 call 40005a50 <rtems_fdisk_printf>
40007774: 92 10 00 1a mov %i2, %o1
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
40007778: fa 07 40 00 ld [ %i5 ], %i5
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
while (sc)
4000777c: 80 a7 60 00 cmp %i5, 0
40007780: 12 bf ff f7 bne 4000775c <rtems_fdisk_ioctl+0x928>
40007784: b8 07 20 01 inc %i4
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
40007788: c2 07 bf e4 ld [ %fp + -28 ], %g1
4000778c: c4 04 23 70 ld [ %l0 + 0x370 ], %g2
40007790: c2 26 e0 6c st %g1, [ %i3 + 0x6c ]
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
break;
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
40007794: c2 07 bf e8 ld [ %fp + -24 ], %g1
40007798: 84 00 80 15 add %g2, %l5, %g2
break;
4000779c: 10 bf fe 8b b 400071c8 <rtems_fdisk_ioctl+0x394>
400077a0: c0 20 40 00 clr [ %g1 ]
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
400077a4: c8 00 a0 04 ld [ %g2 + 4 ], %g4
400077a8: 80 a1 3f ff cmp %g4, -1
400077ac: 32 bf ff 84 bne,a 400075bc <rtems_fdisk_ioctl+0x788> <== NEVER TAKEN
400077b0: c4 10 a0 02 lduh [ %g2 + 2 ], %g2 <== NOT EXECUTED
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
erased++;
400077b4: 10 bf ff 89 b 400075d8 <rtems_fdisk_ioctl+0x7a4>
400077b8: a2 04 60 01 inc %l1
RTEMS_FDISK_PAGE_USED))
used++;
else
{
active++;
is_active = true;
400077bc: 10 bf ff 87 b 400075d8 <rtems_fdisk_ioctl+0x7a4>
400077c0: a8 10 20 01 mov 1, %l4
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
400077c4: 10 bf ff ba b 400076ac <rtems_fdisk_ioctl+0x878> <== NOT EXECUTED
400077c8: 86 10 20 00 clr %g3 <== NOT EXECUTED
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
uint32_t active = 0;
400077cc: ae 10 20 00 clr %l7 <== NOT EXECUTED
uint32_t used = 0;
400077d0: ac 10 20 00 clr %l6 <== NOT EXECUTED
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
400077d4: 10 bf ff a8 b 40007674 <rtems_fdisk_ioctl+0x840> <== NOT EXECUTED
400077d8: a2 10 20 00 clr %l1 <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
(rtems_flashdisks[minor].device_count == 0))
{
errno = ENODEV;
400077dc: 40 00 70 d7 call 40023b38 <__errno> <== NOT EXECUTED
400077e0: 01 00 00 00 nop <== NOT EXECUTED
400077e4: c4 04 23 70 ld [ %l0 + 0x370 ], %g2 <== NOT EXECUTED
400077e8: 82 10 20 13 mov 0x13, %g1 <== NOT EXECUTED
400077ec: 84 00 80 15 add %g2, %l5, %g2 <== NOT EXECUTED
400077f0: 10 bf fe 76 b 400071c8 <rtems_fdisk_ioctl+0x394> <== NOT EXECUTED
400077f4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
count = rtems_fdisk_segment_count_queue (&fd->failed);
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
400077f8: 10 bf ff 31 b 400074bc <rtems_fdisk_ioctl+0x688> <== NOT EXECUTED
400077fc: 96 10 20 00 clr %o3 <== NOT EXECUTED
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
40007800: 40 00 70 ce call 40023b38 <__errno>
40007804: a8 06 a0 28 add %i2, 0x28, %l4
40007808: fa 04 23 70 ld [ %l0 + 0x370 ], %i5
4000780c: f8 06 a0 10 ld [ %i2 + 0x10 ], %i4
40007810: d0 27 bf e0 st %o0, [ %fp + -32 ]
40007814: ba 07 40 15 add %i5, %l5, %i5
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
40007818: ac 10 20 01 mov 1, %l6
4000781c: f4 27 bf ec st %i2, [ %fp + -20 ]
40007820: ea 27 bf e8 st %l5, [ %fp + -24 ]
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
40007824: 82 05 bf ff add %l6, -1, %g1
40007828: 80 a0 40 1c cmp %g1, %i4
4000782c: 3a 80 02 7d bcc,a 40008220 <rtems_fdisk_ioctl+0x13ec>
40007830: f4 07 bf ec ld [ %fp + -20 ], %i2
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
40007834: d0 05 3f f4 ld [ %l4 + -12 ], %o0
40007838: 7f ff eb 9a call 400026a0 <.udiv>
4000783c: d2 07 60 14 ld [ %i5 + 0x14 ], %o1
40007840: d0 27 bf e4 st %o0, [ %fp + -28 ]
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
40007844: 80 a2 20 00 cmp %o0, 0
40007848: 02 80 01 0e be 40007c80 <rtems_fdisk_ioctl+0xe4c> <== NEVER TAKEN
4000784c: f4 05 3f f8 ld [ %l4 + -8 ], %i2
40007850: b2 10 20 00 clr %i1
40007854: ec 27 bf dc st %l6, [ %fp + -36 ]
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
40007858: ee 05 3f f0 ld [ %l4 + -16 ], %l7
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
4000785c: 05 10 00 d6 sethi %hi(0x40035800), %g2
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);
40007860: ae 06 40 17 add %i1, %l7, %l7
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
40007864: 92 10 a2 08 or %g2, 0x208, %o1
40007868: 90 10 00 1d mov %i5, %o0
4000786c: 7f ff f8 57 call 400059c8 <rtems_fdisk_info>
40007870: 94 10 00 17 mov %l7, %o2
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
40007874: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
40007878: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000787c: 82 20 80 01 sub %g2, %g1, %g1
40007880: 80 a5 c0 01 cmp %l7, %g1
40007884: 1a 80 01 02 bcc 40007c8c <rtems_fdisk_ioctl+0xe58> <== NEVER TAKEN
40007888: 11 10 00 d6 sethi %hi(0x40035800), %o0
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
4000788c: e6 07 60 18 ld [ %i5 + 0x18 ], %l3
40007890: a5 2d e0 03 sll %l7, 3, %l2
/*
* Does the page exist in flash ?
*/
if (bc->segment)
40007894: f8 04 c0 12 ld [ %l3 + %l2 ], %i4
40007898: 80 a7 20 00 cmp %i4, 0
4000789c: 02 80 00 6d be 40007a50 <rtems_fdisk_ioctl+0xc1c>
400078a0: a2 04 c0 12 add %l3, %l2, %l1
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
400078a4: c2 04 60 04 ld [ %l1 + 4 ], %g1
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
400078a8: d4 07 20 08 ld [ %i4 + 8 ], %o2
400078ac: d6 07 20 0c ld [ %i4 + 0xc ], %o3
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
400078b0: f0 07 20 10 ld [ %i4 + 0x10 ], %i0
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
400078b4: 98 10 00 01 mov %g1, %o4
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
400078b8: 83 28 60 03 sll %g1, 3, %g1
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
400078bc: 90 10 00 1d mov %i5, %o0
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
400078c0: b0 06 00 01 add %i0, %g1, %i0
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
400078c4: 13 10 00 d6 sethi %hi(0x40035800), %o1
400078c8: 7f ff f8 40 call 400059c8 <rtems_fdisk_info>
400078cc: 92 12 62 40 or %o1, 0x240, %o1 ! 40035a40 <Callbacks.6428+0x7f8>
#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,
400078d0: c4 04 60 04 ld [ %l1 + 4 ], %g2
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);
400078d4: ec 07 60 14 ld [ %i5 + 0x14 ], %l6
#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,
400078d8: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
400078dc: ea 07 20 08 ld [ %i4 + 8 ], %l5
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
400078e0: 92 10 00 16 mov %l6, %o1
400078e4: 7f ff eb 35 call 400025b8 <.umul>
400078e8: 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;
400078ec: c8 07 60 2c ld [ %i5 + 0x2c ], %g4
400078f0: b7 2d 60 04 sll %l5, 4, %i3
400078f4: 87 2d 60 02 sll %l5, 2, %g3
400078f8: 86 26 c0 03 sub %i3, %g3, %g3
400078fc: b6 01 00 03 add %g4, %g3, %i3
40007900: de 01 00 03 ld [ %g4 + %g3 ], %o7
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;
40007904: da 06 e0 08 ld [ %i3 + 8 ], %o5
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
40007908: f6 07 20 0c ld [ %i4 + 0xc ], %i3
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;
4000790c: c6 03 60 08 ld [ %o5 + 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;
40007910: 93 2e e0 06 sll %i3, 6, %o1
40007914: 89 2e e0 04 sll %i3, 4, %g4
40007918: 88 22 40 04 sub %o1, %g4, %g4
4000791c: 88 03 c0 04 add %o7, %g4, %g4
40007920: c8 01 20 04 ld [ %g4 + 4 ], %g4
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
40007924: 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",
40007928: 98 10 00 08 mov %o0, %o4
4000792c: c4 3f bf d0 std %g2, [ %fp + -48 ]
40007930: 94 10 00 15 mov %l5, %o2
40007934: 96 10 00 1b mov %i3, %o3
40007938: 9a 10 00 16 mov %l6, %o5
4000793c: c8 27 bf cc st %g4, [ %fp + -52 ]
40007940: 90 10 00 1d mov %i5, %o0
40007944: 13 10 00 d6 sethi %hi(0x40035800), %o1
40007948: 7f ff f8 42 call 40005a50 <rtems_fdisk_printf>
4000794c: 92 12 62 68 or %o1, 0x268, %o1 ! 40035a68 <Callbacks.6428+0x820>
device, segment, offset, size);
#endif
return ops->verify (sd, device, segment, offset, buffer, size);
40007950: c6 07 bf d4 ld [ %fp + -44 ], %g3
40007954: c8 07 bf cc ld [ %fp + -52 ], %g4
40007958: c4 07 bf d0 ld [ %fp + -48 ], %g2
4000795c: c6 00 e0 0c ld [ %g3 + 0xc ], %g3
40007960: 90 10 00 04 mov %g4, %o0
40007964: 92 10 00 15 mov %l5, %o1
40007968: 94 10 00 1b mov %i3, %o2
4000796c: 96 10 00 02 mov %g2, %o3
40007970: 98 10 00 1a mov %i2, %o4
40007974: 9f c0 c0 00 call %g3
40007978: 9a 10 00 16 mov %l6, %o5
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
4000797c: 80 a2 20 00 cmp %o0, 0
40007980: 22 80 00 f9 be,a 40007d64 <rtems_fdisk_ioctl+0xf30>
40007984: d6 07 20 08 ld [ %i4 + 8 ], %o3
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
40007988: c6 16 20 02 lduh [ %i0 + 2 ], %g3
* matches the flash device.
*/
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc_flags (fd, sc, bc->page, pd);
4000798c: c2 04 60 04 ld [ %l1 + 4 ], %g1
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
40007990: c4 07 60 08 ld [ %i5 + 8 ], %g2
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
40007994: 86 08 ff fd and %g3, -3, %g3
40007998: c6 36 20 02 sth %g3, [ %i0 + 2 ]
rtems_fdisk_seg_write_page_desc_flags (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +
4000799c: ab 28 60 03 sll %g1, 3, %l5
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
400079a0: 80 88 a0 08 btst 8, %g2
400079a4: 02 80 00 d6 be 40007cfc <rtems_fdisk_ioctl+0xec8> <== NEVER TAKEN
400079a8: aa 05 60 02 add %l5, 2, %l5
{
uint16_t flash_flags;
int ret;
ret = rtems_fdisk_seg_read (fd, sc, offset,
400079ac: c2 27 bf d8 st %g1, [ %fp + -40 ]
400079b0: 90 10 00 1d mov %i5, %o0
400079b4: 92 10 00 1c mov %i4, %o1
400079b8: 94 10 00 15 mov %l5, %o2
400079bc: 96 07 bf f6 add %fp, -10, %o3
400079c0: 7f ff f8 46 call 40005ad8 <rtems_fdisk_seg_read>
400079c4: 98 10 20 02 mov 2, %o4
&flash_flags, sizeof (flash_flags));
if (ret)
400079c8: b6 92 20 00 orcc %o0, 0, %i3
400079cc: 12 80 00 d5 bne 40007d20 <rtems_fdisk_ioctl+0xeec> <== NEVER TAKEN
400079d0: c2 07 bf d8 ld [ %fp + -40 ], %g1
return ret;
if ((flash_flags & page_desc->flags) != page_desc->flags)
400079d4: c8 16 20 02 lduh [ %i0 + 2 ], %g4
400079d8: c4 17 bf f6 lduh [ %fp + -10 ], %g2
400079dc: 87 29 20 10 sll %g4, 0x10, %g3
400079e0: 88 08 80 04 and %g2, %g4, %g4
400079e4: 89 29 20 10 sll %g4, 0x10, %g4
400079e8: 80 a1 00 03 cmp %g4, %g3
400079ec: 02 80 00 c4 be 40007cfc <rtems_fdisk_ioctl+0xec8> <== ALWAYS TAKEN
400079f0: 9b 30 e0 10 srl %g3, 0x10, %o5
{
rtems_fdisk_error (" seg-write-page-flags: %02d-%03d-%03d: "
400079f4: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED
400079f8: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED
400079fc: 99 28 a0 10 sll %g2, 0x10, %o4 <== NOT EXECUTED
40007a00: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
40007a04: 96 10 00 01 mov %g1, %o3 <== NOT EXECUTED
40007a08: 90 12 22 c0 or %o0, 0x2c0, %o0 <== NOT EXECUTED
40007a0c: 7f ff f8 eb call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40007a10: 99 33 20 10 srl %o4, 0x10, %o4 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
40007a14: c4 07 20 1c ld [ %i4 + 0x1c ], %g2 <== NOT EXECUTED
sc->pages_used++;
40007a18: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
40007a1c: 84 00 bf ff add %g2, -1, %g2
sc->pages_used++;
40007a20: 82 00 60 01 inc %g1
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
40007a24: c4 27 20 1c st %g2, [ %i4 + 0x1c ]
sc->pages_used++;
40007a28: 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);
40007a2c: 90 10 00 1d mov %i5, %o0
40007a30: 7f ff f9 8a call 40006058 <rtems_fdisk_queue_segment>
40007a34: 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)
40007a38: c2 07 60 08 ld [ %i5 + 8 ], %g1
40007a3c: 80 88 60 02 btst 2, %g1
40007a40: 32 80 00 05 bne,a 40007a54 <rtems_fdisk_ioctl+0xc20> <== NEVER TAKEN
40007a44: f8 07 60 34 ld [ %i5 + 0x34 ], %i4 <== NOT EXECUTED
rtems_fdisk_compact (fd);
40007a48: 7f ff fb 50 call 40006788 <rtems_fdisk_compact>
40007a4c: 90 10 00 1d mov %i5, %o0
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
40007a50: f8 07 60 34 ld [ %i5 + 0x34 ], %i4
uint32_t count = 0;
while (sc)
40007a54: 80 a7 20 00 cmp %i4, 0
40007a58: 02 80 00 e7 be 40007df4 <rtems_fdisk_ioctl+0xfc0> <== NEVER TAKEN
40007a5c: 82 10 00 1c mov %i4, %g1
40007a60: 84 10 20 00 clr %g2
{
count++;
sc = sc->next;
40007a64: c2 00 40 00 ld [ %g1 ], %g1
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
40007a68: 80 a0 60 00 cmp %g1, 0
40007a6c: 12 bf ff fe bne 40007a64 <rtems_fdisk_ioctl+0xc30>
40007a70: 84 00 a0 01 inc %g2
/*
* Is it time to compact the disk ?
*
* We override the background compaction configruation.
*/
if (rtems_fdisk_segment_count_queue (&fd->available) <=
40007a74: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40007a78: 80 a0 40 02 cmp %g1, %g2
40007a7c: 1a 80 00 de bcc 40007df4 <rtems_fdisk_ioctl+0xfc0>
40007a80: 01 00 00 00 nop
{
if (queue->head)
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
40007a84: c2 07 00 00 ld [ %i4 ], %g1
if (!queue->head)
40007a88: 80 a0 60 00 cmp %g1, 0
40007a8c: 02 80 00 d8 be 40007dec <rtems_fdisk_ioctl+0xfb8>
40007a90: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
queue->tail = 0;
queue->count--;
40007a94: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
40007a98: 82 00 7f ff add %g1, -1, %g1
40007a9c: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
return ENOSPC;
}
}
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
40007aa0: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
40007aa4: 80 a0 60 02 cmp %g1, 2
40007aa8: 18 80 00 b8 bgu 40007d88 <rtems_fdisk_ioctl+0xf54> <== NEVER TAKEN
40007aac: c0 27 00 00 clr [ %i4 ]
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
40007ab0: c6 07 20 14 ld [ %i4 + 0x14 ], %g3
40007ab4: 80 a0 e0 00 cmp %g3, 0
40007ab8: 02 80 00 83 be 40007cc4 <rtems_fdisk_ioctl+0xe90> <== NEVER TAKEN
40007abc: f6 07 20 10 ld [ %i4 + 0x10 ], %i3
40007ac0: 10 80 00 05 b 40007ad4 <rtems_fdisk_ioctl+0xca0>
40007ac4: b0 10 20 00 clr %i0
40007ac8: 80 a6 00 03 cmp %i0, %g3
40007acc: 02 80 00 7e be 40007cc4 <rtems_fdisk_ioctl+0xe90> <== NEVER TAKEN
40007ad0: b6 06 e0 08 add %i3, 8, %i3
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
40007ad4: c2 06 c0 00 ld [ %i3 ], %g1
40007ad8: 80 a0 7f ff cmp %g1, -1
40007adc: 32 bf ff fb bne,a 40007ac8 <rtems_fdisk_ioctl+0xc94>
40007ae0: b0 06 20 01 inc %i0
40007ae4: c2 06 e0 04 ld [ %i3 + 4 ], %g1
40007ae8: 80 a0 7f ff cmp %g1, -1
40007aec: 32 bf ff f7 bne,a 40007ac8 <rtems_fdisk_ioctl+0xc94> <== NEVER TAKEN
40007af0: b0 06 20 01 inc %i0 <== NOT EXECUTED
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
40007af4: de 07 60 14 ld [ %i5 + 0x14 ], %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++)
40007af8: 80 a3 e0 00 cmp %o7, 0
40007afc: 02 80 00 e0 be 40007e7c <rtems_fdisk_ioctl+0x1048> <== NEVER TAKEN
40007b00: 15 10 00 d7 sethi %hi(0x40035c00), %o2
40007b04: 03 10 01 2a sethi %hi(0x4004a800), %g1
* @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)
40007b08: 9e 06 80 0f add %i2, %o7, %o7
40007b0c: da 00 63 78 ld [ %g1 + 0x378 ], %o5
* 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;
40007b10: 84 10 3f ff mov -1, %g2
* @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)
40007b14: 82 10 00 1a mov %i2, %g1
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
40007b18: c8 08 40 00 ldub [ %g1 ], %g4
40007b1c: 84 08 a0 ff and %g2, 0xff, %g2
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++)
40007b20: 82 00 60 01 inc %g1
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
40007b24: 84 18 80 04 xor %g2, %g4, %g2
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++)
40007b28: 80 a0 40 0f cmp %g1, %o7
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
40007b2c: 85 28 a0 01 sll %g2, 1, %g2
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++)
40007b30: 12 bf ff fa bne 40007b18 <rtems_fdisk_ioctl+0xce4>
40007b34: c4 13 40 02 lduh [ %o5 + %g2 ], %g2
40007b38: 83 28 a0 10 sll %g2, 0x10, %g1
40007b3c: 83 30 60 10 srl %g1, 0x10, %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;
40007b40: c8 16 e0 02 lduh [ %i3 + 2 ], %g4
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
40007b44: c4 36 c0 00 sth %g2, [ %i3 ]
pd->block = block;
40007b48: ee 26 e0 04 st %l7, [ %i3 + 4 ]
bc->segment = sc;
40007b4c: f8 24 c0 12 st %i4, [ %l3 + %l2 ]
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: " \
40007b50: c4 07 00 00 ld [ %i4 ], %g2
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
pd->block = block;
bc->segment = sc;
bc->page = page;
40007b54: f0 24 60 04 st %i0, [ %l1 + 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;
40007b58: 88 09 3f fe and %g4, -2, %g4
40007b5c: c8 36 e0 02 sth %g4, [ %i3 + 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: " \
40007b60: d6 07 20 08 ld [ %i4 + 8 ], %o3
40007b64: d8 07 20 0c ld [ %i4 + 0xc ], %o4
40007b68: e4 07 20 1c ld [ %i4 + 0x1c ], %l2
40007b6c: d0 07 20 20 ld [ %i4 + 0x20 ], %o0
40007b70: 80 a0 a0 00 cmp %g2, 0
40007b74: 02 80 00 bf be 40007e70 <rtems_fdisk_ioctl+0x103c> <== ALWAYS TAKEN
40007b78: de 07 20 24 ld [ %i4 + 0x24 ], %o7
40007b7c: 05 10 00 d5 sethi %hi(0x40035400), %g2 <== NOT EXECUTED
40007b80: 84 10 a0 68 or %g2, 0x68, %g2 ! 40035468 <Callbacks.6428+0x220><== NOT EXECUTED
40007b84: 89 29 20 10 sll %g4, 0x10, %g4
40007b88: 89 31 20 10 srl %g4, 0x10, %g4
40007b8c: 94 10 00 17 mov %l7, %o2
40007b90: 9a 10 00 18 mov %i0, %o5
40007b94: c6 23 a0 5c st %g3, [ %sp + 0x5c ]
40007b98: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
40007b9c: d0 23 a0 64 st %o0, [ %sp + 0x64 ]
40007ba0: de 23 a0 68 st %o7, [ %sp + 0x68 ]
40007ba4: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
40007ba8: c8 23 a0 70 st %g4, [ %sp + 0x70 ]
40007bac: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
40007bb0: 13 10 00 d6 sethi %hi(0x40035800), %o1
40007bb4: ee 23 a0 78 st %l7, [ %sp + 0x78 ]
40007bb8: 92 12 63 78 or %o1, 0x378, %o1
40007bbc: 7f ff f7 83 call 400059c8 <rtems_fdisk_info>
40007bc0: 90 10 00 1d mov %i5, %o0
/*
* We use the segment page offset not the page number used in the
* driver. This skips the page descriptors.
*/
ret = rtems_fdisk_seg_write_page (fd, sc, page + sc->pages_desc, buffer);
40007bc4: d4 07 20 18 ld [ %i4 + 0x18 ], %o2
40007bc8: 90 10 00 1d mov %i5, %o0
40007bcc: 92 10 00 1c mov %i4, %o1
40007bd0: 94 06 00 0a add %i0, %o2, %o2
40007bd4: 7f ff f8 3b call 40005cc0 <rtems_fdisk_seg_write_page>
40007bd8: 96 10 00 1a mov %i2, %o3
if (ret)
40007bdc: a4 92 20 00 orcc %o0, 0, %l2
40007be0: 22 80 00 78 be,a 40007dc0 <rtems_fdisk_ioctl+0xf8c> <== ALWAYS TAKEN
40007be4: 90 10 00 1d mov %i5, %o0
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
40007be8: e2 07 20 08 ld [ %i4 + 8 ], %l1 <== NOT EXECUTED
40007bec: 40 00 79 ae call 400262a4 <strerror> <== NOT EXECUTED
40007bf0: f6 07 20 0c ld [ %i4 + 0xc ], %i3 <== NOT EXECUTED
40007bf4: 13 10 00 d6 sethi %hi(0x40035800), %o1 <== NOT EXECUTED
40007bf8: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40007bfc: e4 23 a0 5c st %l2, [ %sp + 0x5c ] <== NOT EXECUTED
40007c00: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40007c04: 92 12 63 c8 or %o1, 0x3c8, %o1 <== NOT EXECUTED
40007c08: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
40007c0c: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
40007c10: 7f ff f7 6e call 400059c8 <rtems_fdisk_info> <== NOT EXECUTED
40007c14: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
40007c18: 90 10 00 1d mov %i5, %o0
40007c1c: 7f ff f9 0f call 40006058 <rtems_fdisk_queue_segment>
40007c20: 92 10 00 1c mov %i4, %o1
static bool
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
40007c24: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
40007c28: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40007c2c: 80 a0 80 01 cmp %g2, %g1
40007c30: 1a 80 00 08 bcc 40007c50 <rtems_fdisk_ioctl+0xe1c>
40007c34: 80 a4 a0 00 cmp %l2, 0
fd->starvations++;
40007c38: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
40007c3c: 90 10 00 1d mov %i5, %o0
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
fd->starvations++;
40007c40: 82 00 60 01 inc %g1
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
40007c44: 7f ff fa d1 call 40006788 <rtems_fdisk_compact>
40007c48: 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)
40007c4c: 80 a4 a0 00 cmp %l2, 0
40007c50: 32 80 01 72 bne,a 40008218 <rtems_fdisk_ioctl+0x13e4> <== NEVER TAKEN
40007c54: f4 07 bf ec ld [ %fp + -20 ], %i2 <== 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)
40007c58: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40007c5c: b2 06 60 01 inc %i1
40007c60: b4 06 80 01 add %i2, %g1, %i2
40007c64: c2 07 bf e4 ld [ %fp + -28 ], %g1
40007c68: 80 a6 40 01 cmp %i1, %g1
40007c6c: 32 bf fe fc bne,a 4000785c <rtems_fdisk_ioctl+0xa28> <== NEVER TAKEN
40007c70: ee 05 3f f0 ld [ %l4 + -16 ], %l7 <== NOT EXECUTED
40007c74: c4 07 bf ec ld [ %fp + -20 ], %g2
40007c78: ec 07 bf dc ld [ %fp + -36 ], %l6
40007c7c: f8 00 a0 10 ld [ %g2 + 0x10 ], %i4
40007c80: a8 05 20 10 add %l4, 0x10, %l4
40007c84: 10 bf fe e8 b 40007824 <rtems_fdisk_ioctl+0x9f0>
40007c88: ac 05 a0 01 inc %l6
40007c8c: f4 07 bf ec ld [ %fp + -20 ], %i2 <== NOT EXECUTED
40007c90: ea 07 bf e8 ld [ %fp + -24 ], %l5 <== NOT EXECUTED
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
40007c94: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
40007c98: 7f ff f8 48 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40007c9c: 90 12 22 18 or %o0, 0x218, %o0 <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40007ca0: 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);
40007ca4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40007ca8: 9f c0 40 00 call %g1
40007cac: 90 10 00 1a mov %i2, %o0
40007cb0: c4 04 23 70 ld [ %l0 + 0x370 ], %g2
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
40007cb4: c2 07 bf e0 ld [ %fp + -32 ], %g1
40007cb8: 84 00 80 15 add %g2, %l5, %g2
break;
40007cbc: 10 bf fd 43 b 400071c8 <rtems_fdisk_ioctl+0x394>
40007cc0: c0 20 40 00 clr [ %g1 ]
return ret;
}
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
40007cc4: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED
40007cc8: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED
40007ccc: f4 07 bf ec ld [ %fp + -20 ], %i2 <== NOT EXECUTED
40007cd0: ea 07 bf e8 ld [ %fp + -24 ], %l5 <== NOT EXECUTED
40007cd4: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40007cd8: 7f ff f8 38 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40007cdc: 90 12 20 40 or %o0, 0x40, %o0 ! 40035c40 <Callbacks.6428+0x9f8><== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
40007ce0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
40007ce4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40007ce8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40007cec: 7f ff f8 db call 40006058 <rtems_fdisk_queue_segment> <== NOT EXECUTED
40007cf0: c2 27 20 28 st %g1, [ %i4 + 0x28 ] <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40007cf4: 10 bf ff ec b 40007ca4 <rtems_fdisk_ioctl+0xe70> <== NOT EXECUTED
40007cf8: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
sc->device, sc->segment, page,
flash_flags, page_desc->flags);
return ret;
}
}
return rtems_fdisk_seg_write (fd, sc, offset,
40007cfc: 90 10 00 1d mov %i5, %o0
40007d00: 92 10 00 1c mov %i4, %o1
40007d04: 94 10 00 15 mov %l5, %o2
40007d08: 96 06 20 02 add %i0, 2, %o3
40007d0c: 7f ff f7 b6 call 40005be4 <rtems_fdisk_seg_write>
40007d10: 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)
40007d14: b6 92 20 00 orcc %o0, 0, %i3
40007d18: 22 bf ff 40 be,a 40007a18 <rtems_fdisk_ioctl+0xbe4> <== ALWAYS TAKEN
40007d1c: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: " \
40007d20: d4 07 20 08 ld [ %i4 + 8 ], %o2 <== NOT EXECUTED
40007d24: ea 07 20 0c ld [ %i4 + 0xc ], %l5 <== NOT EXECUTED
40007d28: f0 04 60 04 ld [ %l1 + 4 ], %i0 <== NOT EXECUTED
40007d2c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40007d30: 40 00 79 5d call 400262a4 <strerror> <== NOT EXECUTED
40007d34: d4 27 bf c8 st %o2, [ %fp + -56 ] <== NOT EXECUTED
40007d38: d4 07 bf c8 ld [ %fp + -56 ], %o2 <== NOT EXECUTED
40007d3c: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40007d40: f6 23 a0 5c st %i3, [ %sp + 0x5c ] <== NOT EXECUTED
40007d44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40007d48: 13 10 00 d6 sethi %hi(0x40035800), %o1 <== NOT EXECUTED
40007d4c: 96 10 00 15 mov %l5, %o3 <== NOT EXECUTED
40007d50: 92 12 63 10 or %o1, 0x310, %o1 <== NOT EXECUTED
40007d54: 7f ff f7 1d call 400059c8 <rtems_fdisk_info> <== NOT EXECUTED
40007d58: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
/*
* If possible reuse this segment. This will mean the segment
* needs to be removed from the available list and placed
* back if space is still available.
*/
rtems_fdisk_queue_segment (fd, sc);
40007d5c: 10 bf ff 35 b 40007a30 <rtems_fdisk_ioctl+0xbfc> <== NOT EXECUTED
40007d60: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
bc->page + sc->pages_desc, buffer) == 0)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d=>%02d-%03d-%03d: page verified",
40007d64: d8 07 20 0c ld [ %i4 + 0xc ], %o4
40007d68: da 04 60 04 ld [ %l1 + 4 ], %o5
40007d6c: 90 10 00 1d mov %i5, %o0
40007d70: 13 10 00 d6 sethi %hi(0x40035800), %o1
40007d74: 94 10 00 17 mov %l7, %o2
40007d78: 7f ff f7 14 call 400059c8 <rtems_fdisk_info>
40007d7c: 92 12 62 90 or %o1, 0x290, %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)
40007d80: 10 bf ff b7 b 40007c5c <rtems_fdisk_ioctl+0xe28>
40007d84: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
{
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
40007d88: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40007d8c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40007d90: 7f ff f6 b0 call 40005850 <rtems_fdisk_queue_status> <== NOT EXECUTED
40007d94: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",
40007d98: d6 07 20 08 ld [ %i4 + 8 ], %o3 <== NOT EXECUTED
40007d9c: d8 07 20 0c ld [ %i4 + 0xc ], %o4 <== NOT EXECUTED
40007da0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40007da4: 13 10 00 d6 sethi %hi(0x40035800), %o1 <== NOT EXECUTED
40007da8: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED
40007dac: 92 12 63 50 or %o1, 0x350, %o1 <== NOT EXECUTED
40007db0: 7f ff f7 06 call 400059c8 <rtems_fdisk_info> <== NOT EXECUTED
40007db4: 9a 07 bf f8 add %fp, -8, %o5 <== NOT EXECUTED
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
40007db8: 10 bf ff 3f b 40007ab4 <rtems_fdisk_ioctl+0xc80> <== NOT EXECUTED
40007dbc: c6 07 20 14 ld [ %i4 + 0x14 ], %g3 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
40007dc0: 92 10 00 1c mov %i4, %o1
40007dc4: 94 10 00 18 mov %i0, %o2
40007dc8: 7f ff f7 ad call 40005c7c <rtems_fdisk_seg_write_page_desc>
40007dcc: 96 10 00 1b mov %i3, %o3
if (ret)
40007dd0: a4 92 20 00 orcc %o0, 0, %l2
40007dd4: 32 80 00 19 bne,a 40007e38 <rtems_fdisk_ioctl+0x1004> <== NEVER TAKEN
40007dd8: e6 07 20 08 ld [ %i4 + 8 ], %l3 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active++;
40007ddc: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
40007de0: 82 00 60 01 inc %g1
40007de4: 10 bf ff 8d b 40007c18 <rtems_fdisk_ioctl+0xde4>
40007de8: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
if (!queue->head)
queue->tail = 0;
40007dec: 10 bf ff 2a b 40007a94 <rtems_fdisk_ioctl+0xc60>
40007df0: c0 27 60 38 clr [ %i5 + 0x38 ]
*
* We override the background compaction configruation.
*/
if (rtems_fdisk_segment_count_queue (&fd->available) <=
fd->avail_compact_segs)
rtems_fdisk_compact (fd);
40007df4: 7f ff fa 65 call 40006788 <rtems_fdisk_compact>
40007df8: 90 10 00 1d mov %i5, %o0
40007dfc: f8 07 60 34 ld [ %i5 + 0x34 ], %i4
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
40007e00: 80 a7 20 00 cmp %i4, 0
40007e04: 32 bf ff 21 bne,a 40007a88 <rtems_fdisk_ioctl+0xc54> <== ALWAYS TAKEN
40007e08: c2 07 00 00 ld [ %i4 ], %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))
40007e0c: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
40007e10: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
40007e14: 12 80 01 06 bne 4000822c <rtems_fdisk_ioctl+0x13f8> <== NOT EXECUTED
40007e18: 01 00 00 00 nop <== NOT EXECUTED
40007e1c: f4 07 bf ec ld [ %fp + -20 ], %i2 <== NOT EXECUTED
40007e20: ea 07 bf e8 ld [ %fp + -24 ], %l5 <== NOT EXECUTED
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
if (!sc)
{
rtems_fdisk_error ("write-block: no available pages");
40007e24: 11 10 00 d7 sethi %hi(0x40035c00), %o0 <== NOT EXECUTED
40007e28: 7f ff f7 e4 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40007e2c: 90 12 22 88 or %o0, 0x288, %o0 ! 40035e88 <Callbacks.6428+0xc40><== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40007e30: 10 bf ff 9d b 40007ca4 <rtems_fdisk_ioctl+0xe70> <== NOT EXECUTED
40007e34: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
if (ret)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: " \
40007e38: f0 07 20 0c ld [ %i4 + 0xc ], %i0 <== NOT EXECUTED
40007e3c: 40 00 79 1a call 400262a4 <strerror> <== NOT EXECUTED
40007e40: f6 04 60 04 ld [ %l1 + 4 ], %i3 <== NOT EXECUTED
40007e44: 13 10 00 d7 sethi %hi(0x40035c00), %o1 <== NOT EXECUTED
40007e48: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40007e4c: e4 23 a0 5c st %l2, [ %sp + 0x5c ] <== NOT EXECUTED
40007e50: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40007e54: 92 12 60 00 mov %o1, %o1 <== NOT EXECUTED
40007e58: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
40007e5c: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
40007e60: 7f ff f6 da call 400059c8 <rtems_fdisk_info> <== NOT EXECUTED
40007e64: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
40007e68: 10 bf ff 6d b 40007c1c <rtems_fdisk_ioctl+0xde8> <== NOT EXECUTED
40007e6c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
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: " \
40007e70: 05 10 00 d5 sethi %hi(0x40035400), %g2
40007e74: 10 bf ff 44 b 40007b84 <rtems_fdisk_ioctl+0xd50>
40007e78: 84 10 a0 70 or %g2, 0x70, %g2 ! 40035470 <Callbacks.6428+0x228>
* 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;
40007e7c: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
40007e80: 10 bf ff 30 b 40007b40 <rtems_fdisk_ioctl+0xd0c> <== NOT EXECUTED
40007e84: c2 02 a3 24 ld [ %o2 + 0x324 ], %g1 <== NOT EXECUTED
count = 0;
for (device = 0; device < fd->device_count; device++)
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
40007e88: 19 10 00 d6 sethi %hi(0x40035800), %o4
40007e8c: 10 bf fd 90 b 400074cc <rtems_fdisk_ioctl+0x698>
40007e90: 98 13 20 78 or %o4, 0x78, %o4 ! 40035878 <Callbacks.6428+0x630>
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
40007e94: 40 00 6f 29 call 40023b38 <__errno>
40007e98: b0 06 a0 18 add %i2, 0x18, %i0
40007e9c: f8 04 23 70 ld [ %l0 + 0x370 ], %i4
40007ea0: fa 06 a0 10 ld [ %i2 + 0x10 ], %i5
40007ea4: d0 27 bf e8 st %o0, [ %fp + -24 ]
40007ea8: b8 07 00 15 add %i4, %l5, %i4
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
40007eac: a6 10 20 00 clr %l3
40007eb0: ea 27 bf ec st %l5, [ %fp + -20 ]
40007eb4: 80 a4 c0 1d cmp %l3, %i5
40007eb8: 1a 80 00 a5 bcc 4000814c <rtems_fdisk_ioctl+0x1318>
40007ebc: ea 07 bf ec ld [ %fp + -20 ], %l5
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
40007ec0: d0 06 20 04 ld [ %i0 + 4 ], %o0
40007ec4: 7f ff e9 f7 call 400026a0 <.udiv>
40007ec8: d2 07 20 14 ld [ %i4 + 0x14 ], %o1
data = sg->buffer;
40007ecc: f2 06 20 08 ld [ %i0 + 8 ], %i1
for (b = 0; b < fb; b++, data += fd->block_size)
40007ed0: 80 a2 20 00 cmp %o0, 0
40007ed4: 02 80 00 9b be 40008140 <rtems_fdisk_ioctl+0x130c> <== NEVER TAKEN
40007ed8: a8 10 00 08 mov %o0, %l4
40007edc: a4 10 20 00 clr %l2
{
ret = rtems_fdisk_read_block (fd, sg->block + b, data);
40007ee0: f6 06 00 00 ld [ %i0 ], %i3
rtems_fdisk_block_ctl* bc;
rtems_fdisk_segment_ctl* sc;
rtems_fdisk_page_desc* pd;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block:%d", block);
40007ee4: 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);
40007ee8: b6 04 80 1b add %l2, %i3, %i3
rtems_fdisk_block_ctl* bc;
rtems_fdisk_segment_ctl* sc;
rtems_fdisk_page_desc* pd;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block:%d", block);
40007eec: 13 10 00 d6 sethi %hi(0x40035800), %o1
40007ef0: 94 10 00 1b mov %i3, %o2
40007ef4: 7f ff f6 b5 call 400059c8 <rtems_fdisk_info>
40007ef8: 92 12 60 88 or %o1, 0x88, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
40007efc: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
40007f00: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
40007f04: 82 20 80 01 sub %g2, %g1, %g1
40007f08: 80 a6 c0 01 cmp %i3, %g1
40007f0c: 1a 80 00 74 bcc 400080dc <rtems_fdisk_ioctl+0x12a8> <== NEVER TAKEN
40007f10: 83 2e e0 03 sll %i3, 3, %g1
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
40007f14: ea 07 20 18 ld [ %i4 + 0x18 ], %l5
if (!bc->segment)
40007f18: fa 05 40 01 ld [ %l5 + %g1 ], %i5
40007f1c: 80 a7 60 00 cmp %i5, 0
40007f20: 02 80 00 79 be 40008104 <rtems_fdisk_ioctl+0x12d0>
40007f24: aa 05 40 01 add %l5, %g1, %l5
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
40007f28: da 05 60 04 ld [ %l5 + 4 ], %o5
40007f2c: ec 07 60 10 ld [ %i5 + 0x10 ], %l6
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40007f30: c2 07 40 00 ld [ %i5 ], %g1
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
40007f34: a3 2b 60 03 sll %o5, 3, %l1
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40007f38: 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];
40007f3c: ae 05 80 11 add %l6, %l1, %l7
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40007f40: d8 07 60 0c ld [ %i5 + 0xc ], %o4
40007f44: de 07 60 14 ld [ %i5 + 0x14 ], %o7
40007f48: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
40007f4c: c6 07 60 20 ld [ %i5 + 0x20 ], %g3
40007f50: 80 a0 60 00 cmp %g1, 0
40007f54: 02 80 00 69 be 400080f8 <rtems_fdisk_ioctl+0x12c4>
40007f58: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
40007f5c: 15 10 00 d5 sethi %hi(0x40035400), %o2
40007f60: 82 12 a0 68 or %o2, 0x68, %g1 ! 40035468 <Callbacks.6428+0x220>
40007f64: de 23 a0 5c st %o7, [ %sp + 0x5c ]
40007f68: c8 23 a0 60 st %g4, [ %sp + 0x60 ]
40007f6c: c6 23 a0 64 st %g3, [ %sp + 0x64 ]
40007f70: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
40007f74: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
40007f78: c2 15 e0 02 lduh [ %l7 + 2 ], %g1
40007f7c: 90 10 00 1c mov %i4, %o0
40007f80: c2 23 a0 70 st %g1, [ %sp + 0x70 ]
40007f84: c2 15 80 11 lduh [ %l6 + %l1 ], %g1
40007f88: 13 10 00 d6 sethi %hi(0x40035800), %o1
40007f8c: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
40007f90: c2 05 e0 04 ld [ %l7 + 4 ], %g1
40007f94: 92 12 60 e8 or %o1, 0xe8, %o1
40007f98: c2 23 a0 78 st %g1, [ %sp + 0x78 ]
40007f9c: 7f ff f6 8b call 400059c8 <rtems_fdisk_info>
40007fa0: 94 10 00 1b mov %i3, %o2
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
40007fa4: c2 15 e0 02 lduh [ %l7 + 2 ], %g1
sc->pages, sc->pages_active, sc->pages_used, sc->pages_bad,
sc->next ? "set" : "null",
pd->flags, pd->crc, pd->block);
#endif
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
40007fa8: 80 88 60 01 btst 1, %g1
40007fac: 12 80 00 15 bne 40008000 <rtems_fdisk_ioctl+0x11cc> <== NEVER TAKEN
40007fb0: 80 88 60 02 btst 2, %g1
{
if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
40007fb4: 12 80 00 1e bne 4000802c <rtems_fdisk_ioctl+0x11f8> <== ALWAYS TAKEN
40007fb8: 92 10 00 1b mov %i3, %o1
40007fbc: a2 10 00 15 mov %l5, %l1 <== 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",
40007fc0: d4 07 60 08 ld [ %i5 + 8 ], %o2 <== NOT EXECUTED
40007fc4: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
40007fc8: d8 04 60 04 ld [ %l1 + 4 ], %o4 <== NOT EXECUTED
40007fcc: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
40007fd0: ea 07 bf ec ld [ %fp + -20 ], %l5 <== NOT EXECUTED
40007fd4: 7f ff f7 79 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40007fd8: 90 12 21 a0 or %o0, 0x1a0, %o0 <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40007fdc: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
40007fe0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40007fe4: 9f c0 40 00 call %g1
40007fe8: 90 10 00 1a mov %i2, %o0
40007fec: c4 04 23 70 ld [ %l0 + 0x370 ], %g2
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
40007ff0: c2 07 bf e8 ld [ %fp + -24 ], %g1
40007ff4: 84 00 80 15 add %g2, %l5, %g2
break;
40007ff8: 10 bf fc 74 b 400071c8 <rtems_fdisk_ioctl+0x394>
40007ffc: c0 20 40 00 clr [ %g1 ]
40008000: a2 10 00 15 mov %l5, %l1 <== NOT EXECUTED
block, sc->device, sc->segment, bc->page);
}
}
else
{
rtems_fdisk_error ("read-block: block page not active: %d: %d-%d-%d",
40008004: d4 07 60 08 ld [ %i5 + 8 ], %o2 <== NOT EXECUTED
40008008: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
4000800c: d8 04 60 04 ld [ %l1 + 4 ], %o4 <== NOT EXECUTED
40008010: ea 07 bf ec ld [ %fp + -20 ], %l5 <== NOT EXECUTED
40008014: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40008018: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
4000801c: 7f ff f7 67 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40008020: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 400359d8 <Callbacks.6428+0x790><== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40008024: 10 bf ff ef b 40007fe0 <rtems_fdisk_ioctl+0x11ac> <== NOT EXECUTED
40008028: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
page * fd->block_size, buffer, fd->block_size);
4000802c: ee 07 20 14 ld [ %i4 + 0x14 ], %l7
/*
* 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,
40008030: c2 05 60 04 ld [ %l5 + 4 ], %g1
40008034: 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,
40008038: 92 10 00 17 mov %l7, %o1
4000803c: 7f ff e9 5f call 400025b8 <.umul>
40008040: 90 02 00 01 add %o0, %g1, %o0
40008044: 92 10 00 1d mov %i5, %o1
40008048: 94 10 00 08 mov %o0, %o2
4000804c: 96 10 00 19 mov %i1, %o3
40008050: 90 10 00 1c mov %i4, %o0
40008054: 7f ff f6 a1 call 40005ad8 <rtems_fdisk_seg_read>
40008058: 98 10 00 17 mov %l7, %o4
* driver. This skips the page descriptors.
*/
int ret = rtems_fdisk_seg_read_page (fd, sc,
bc->page + sc->pages_desc, buffer);
if (ret)
4000805c: 84 92 20 00 orcc %o0, 0, %g2
40008060: 32 80 00 3d bne,a 40008154 <rtems_fdisk_ioctl+0x1320> <== NEVER TAKEN
40008064: f2 07 60 08 ld [ %i5 + 8 ], %i1 <== NOT EXECUTED
strerror (ret), ret);
#endif
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
40008068: c2 07 20 14 ld [ %i4 + 0x14 ], %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++)
4000806c: 80 a0 60 00 cmp %g1, 0
40008070: 22 80 00 0f be,a 400080ac <rtems_fdisk_ioctl+0x1278> <== NEVER TAKEN
40008074: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED
40008078: 05 10 01 2a sethi %hi(0x4004a800), %g2
* @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)
4000807c: 88 06 40 01 add %i1, %g1, %g4
40008080: fa 00 a3 78 ld [ %g2 + 0x378 ], %i5
40008084: 86 10 00 19 mov %i1, %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;
40008088: 84 10 3f ff mov -1, %g2
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
4000808c: de 08 c0 00 ldub [ %g3 ], %o7
40008090: 84 08 a0 ff and %g2, 0xff, %g2
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++)
40008094: 86 00 e0 01 inc %g3
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
40008098: 84 18 80 0f xor %g2, %o7, %g2
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++)
4000809c: 80 a0 c0 04 cmp %g3, %g4
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
400080a0: 85 28 a0 01 sll %g2, 1, %g2
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++)
400080a4: 12 bf ff fa bne 4000808c <rtems_fdisk_ioctl+0x1258>
400080a8: c4 17 40 02 lduh [ %i5 + %g2 ], %g2
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
if (cs == pd->crc)
400080ac: d6 15 80 11 lduh [ %l6 + %l1 ], %o3
400080b0: 85 28 a0 10 sll %g2, 0x10, %g2
400080b4: 95 30 a0 10 srl %g2, 0x10, %o2
400080b8: 80 a2 80 0b cmp %o2, %o3
400080bc: 02 80 00 1c be 4000812c <rtems_fdisk_ioctl+0x12f8> <== ALWAYS TAKEN
400080c0: ea 07 bf ec ld [ %fp + -20 ], %l5
return 0;
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
400080c4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400080c8: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
400080cc: 7f ff f7 3b call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
400080d0: 90 12 21 68 or %o0, 0x168, %o0 ! 40035968 <Callbacks.6428+0x720><== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
400080d4: 10 bf ff c3 b 40007fe0 <rtems_fdisk_ioctl+0x11ac> <== NOT EXECUTED
400080d8: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
400080dc: ea 07 bf ec ld [ %fp + -20 ], %l5 <== NOT EXECUTED
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
400080e0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400080e4: 11 10 00 d6 sethi %hi(0x40035800), %o0 <== NOT EXECUTED
400080e8: 7f ff f7 34 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
400080ec: 90 12 20 98 or %o0, 0x98, %o0 ! 40035898 <Callbacks.6428+0x650><== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
400080f0: 10 bf ff bc b 40007fe0 <rtems_fdisk_ioctl+0x11ac> <== NOT EXECUTED
400080f4: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
400080f8: 15 10 00 d5 sethi %hi(0x40035400), %o2
400080fc: 10 bf ff 9a b 40007f64 <rtems_fdisk_ioctl+0x1130>
40008100: 82 12 a0 70 or %o2, 0x70, %g1 ! 40035470 <Callbacks.6428+0x228>
bc = &fd->blocks[block];
if (!bc->segment)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
40008104: 94 10 00 1b mov %i3, %o2
40008108: 13 10 00 d6 sethi %hi(0x40035800), %o1
4000810c: 90 10 00 1c mov %i4, %o0
40008110: 7f ff f6 2e call 400059c8 <rtems_fdisk_info>
40008114: 92 12 60 c0 or %o1, 0xc0, %o1
#endif
memset (buffer, 0xff, fd->block_size);
40008118: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
4000811c: 90 10 00 19 mov %i1, %o0
40008120: 40 00 73 99 call 40024f84 <memset>
40008124: 92 10 20 ff mov 0xff, %o1
40008128: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
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)
4000812c: a4 04 a0 01 inc %l2
40008130: 80 a4 80 14 cmp %l2, %l4
40008134: 12 bf ff 6b bne 40007ee0 <rtems_fdisk_ioctl+0x10ac> <== NEVER TAKEN
40008138: b2 06 40 01 add %i1, %g1, %i1
4000813c: fa 06 a0 10 ld [ %i2 + 0x10 ], %i5
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
40008140: a6 04 e0 01 inc %l3
40008144: 10 bf ff 5c b 40007eb4 <rtems_fdisk_ioctl+0x1080>
40008148: b0 06 20 10 add %i0, 0x10, %i0
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
4000814c: 10 bf ff a5 b 40007fe0 <rtems_fdisk_ioctl+0x11ac>
40008150: 92 10 20 00 clr %o1
bc->page + sc->pages_desc, buffer);
if (ret)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
40008154: f6 07 60 0c ld [ %i5 + 0xc ], %i3 <== NOT EXECUTED
40008158: a2 10 00 15 mov %l5, %l1 <== NOT EXECUTED
4000815c: ea 07 bf ec ld [ %fp + -20 ], %l5 <== NOT EXECUTED
40008160: fa 04 60 04 ld [ %l1 + 4 ], %i5 <== NOT EXECUTED
40008164: 40 00 78 50 call 400262a4 <strerror> <== NOT EXECUTED
40008168: c4 27 bf d0 st %g2, [ %fp + -48 ] <== NOT EXECUTED
4000816c: c4 07 bf d0 ld [ %fp + -48 ], %g2 <== NOT EXECUTED
40008170: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
40008174: c4 23 a0 5c st %g2, [ %sp + 0x5c ] <== NOT EXECUTED
40008178: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000817c: 13 10 00 d6 sethi %hi(0x40035800), %o1 <== NOT EXECUTED
40008180: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40008184: 92 12 61 30 or %o1, 0x130, %o1 <== NOT EXECUTED
40008188: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4000818c: 7f ff f6 0f call 400059c8 <rtems_fdisk_info> <== NOT EXECUTED
40008190: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40008194: 10 bf ff 93 b 40007fe0 <rtems_fdisk_ioctl+0x11ac> <== NOT EXECUTED
40008198: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
ret = rtems_fdisk_erase_flash (fd);
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
4000819c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400081a0: 02 bf fc 59 be 40007304 <rtems_fdisk_ioctl+0x4d0> <== NOT EXECUTED
400081a4: c4 04 23 70 ld [ %l0 + 0x370 ], %g2 <== NOT EXECUTED
{
if (!fd->devices[device].segments)
400081a8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
400081ac: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
400081b0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400081b4: 02 bf fc 54 be 40007304 <rtems_fdisk_ioctl+0x4d0> <== NOT EXECUTED
400081b8: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
400081bc: b6 10 20 0c mov 0xc, %i3 <== NOT EXECUTED
400081c0: 10 80 00 0b b 400081ec <rtems_fdisk_ioctl+0x13b8> <== NOT EXECUTED
400081c4: b8 10 20 00 clr %i4 <== NOT EXECUTED
ret = rtems_fdisk_erase_flash (fd);
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
400081c8: b8 07 20 01 inc %i4 <== NOT EXECUTED
400081cc: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
400081d0: 1a bf fc 4d bcc 40007304 <rtems_fdisk_ioctl+0x4d0> <== NOT EXECUTED
400081d4: c4 04 23 70 ld [ %l0 + 0x370 ], %g2 <== NOT EXECUTED
{
if (!fd->devices[device].segments)
400081d8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
400081dc: c2 00 40 1b ld [ %g1 + %i3 ], %g1 <== NOT EXECUTED
400081e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400081e4: 02 80 00 0b be 40008210 <rtems_fdisk_ioctl+0x13dc> <== NOT EXECUTED
400081e8: b6 06 e0 0c add %i3, 0xc, %i3 <== NOT EXECUTED
return ENOMEM;
ret = rtems_fdisk_recover_block_mappings (fd);
400081ec: 7f ff fa 1d call 40006a60 <rtems_fdisk_recover_block_mappings><== NOT EXECUTED
400081f0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (ret)
400081f4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400081f8: 22 bf ff f4 be,a 400081c8 <rtems_fdisk_ioctl+0x1394> <== NOT EXECUTED
400081fc: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
40008200: 10 bf fc 41 b 40007304 <rtems_fdisk_ioctl+0x4d0> <== NOT EXECUTED
40008204: c4 04 23 70 ld [ %l0 + 0x370 ], %g2 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
40008208: 10 bf fc 3e b 40007300 <rtems_fdisk_ioctl+0x4cc> <== NOT EXECUTED
4000820c: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
{
if (!fd->devices[device].segments)
return ENOMEM;
40008210: 10 bf fc 3c b 40007300 <rtems_fdisk_ioctl+0x4cc> <== NOT EXECUTED
40008214: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
40008218: 10 bf fe a2 b 40007ca0 <rtems_fdisk_ioctl+0xe6c> <== NOT EXECUTED
4000821c: ea 07 bf e8 ld [ %fp + -24 ], %l5 <== NOT EXECUTED
40008220: ea 07 bf e8 ld [ %fp + -24 ], %l5
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40008224: 10 bf fe a0 b 40007ca4 <rtems_fdisk_ioctl+0xe70>
40008228: 92 10 20 00 clr %o1
/*
* If compacting is configured for the background do it now
* to see if we can get some space back.
*/
if ((fd->flags & RTEMS_FDISK_BACKGROUND_COMPACT))
rtems_fdisk_compact (fd);
4000822c: 7f ff f9 57 call 40006788 <rtems_fdisk_compact> <== NOT EXECUTED
40008230: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
40008234: f8 07 60 34 ld [ %i5 + 0x34 ], %i4 <== NOT EXECUTED
40008238: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000823c: 32 bf fe 13 bne,a 40007a88 <rtems_fdisk_ioctl+0xc54> <== NOT EXECUTED
40008240: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
40008244: 10 bf fe f7 b 40007e20 <rtems_fdisk_ioctl+0xfec> <== NOT EXECUTED
40008248: f4 07 bf ec ld [ %fp + -20 ], %i2 <== NOT EXECUTED
40006058 <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)
{
40006058: 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",
4000605c: 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)
{
40006060: 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",
40006064: d4 06 60 08 ld [ %i1 + 8 ], %o2
40006068: d6 06 60 0c ld [ %i1 + 0xc ], %o3
4000606c: d8 06 60 14 ld [ %i1 + 0x14 ], %o4
40006070: da 06 60 1c ld [ %i1 + 0x1c ], %o5
40006074: c8 06 60 20 ld [ %i1 + 0x20 ], %g4
40006078: 80 a0 60 00 cmp %g1, 0
4000607c: 02 80 00 2b be 40006128 <rtems_fdisk_queue_segment+0xd0> <== ALWAYS TAKEN
40006080: c6 06 60 24 ld [ %i1 + 0x24 ], %g3
40006084: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED
40006088: 03 10 00 d5 sethi %hi(0x40035400), %g1 <== NOT EXECUTED
4000608c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40006090: 02 80 00 2b be 4000613c <rtems_fdisk_queue_segment+0xe4> <== NOT EXECUTED
40006094: 82 10 60 58 or %g1, 0x58, %g1 <== NOT EXECUTED
40006098: 05 10 00 d5 sethi %hi(0x40035400), %g2
4000609c: 84 10 a0 68 or %g2, 0x68, %g2 ! 40035468 <Callbacks.6428+0x220>
400060a0: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
400060a4: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
400060a8: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
400060ac: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
400060b0: 90 10 00 18 mov %i0, %o0
400060b4: 13 10 00 d5 sethi %hi(0x40035400), %o1
400060b8: 7f ff fe 44 call 400059c8 <rtems_fdisk_info>
400060bc: 92 12 60 78 or %o1, 0x78, %o1 ! 40035478 <Callbacks.6428+0x230>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
400060c0: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
400060c4: 80 a0 60 00 cmp %g1, 0
400060c8: 22 80 00 2c be,a 40006178 <rtems_fdisk_queue_segment+0x120><== ALWAYS TAKEN
400060cc: 92 10 00 1a mov %i2, %o1
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
400060d0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED
while (it)
400060d4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400060d8: 02 80 00 89 be 400062fc <rtems_fdisk_queue_segment+0x2a4> <== NOT EXECUTED
400060dc: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
{
if (it == sc)
400060e0: 32 80 00 06 bne,a 400060f8 <rtems_fdisk_queue_segment+0xa0><== NOT EXECUTED
400060e4: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
400060e8: 30 80 00 89 b,a 4000630c <rtems_fdisk_queue_segment+0x2b4><== NOT EXECUTED
400060ec: 02 80 00 88 be 4000630c <rtems_fdisk_queue_segment+0x2b4> <== NOT EXECUTED
400060f0: 01 00 00 00 nop <== NOT EXECUTED
return true;
it = it->next;
400060f4: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
400060f8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400060fc: 12 bf ff fc bne 400060ec <rtems_fdisk_queue_segment+0x94> <== NOT EXECUTED
40006100: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
40006104: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
40006108: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
if (queue->head)
{
queue->tail->next = sc;
4000610c: f4 20 40 00 st %i2, [ %g1 ] <== NOT EXECUTED
queue->tail = sc;
40006110: f4 26 20 5c st %i2, [ %i0 + 0x5c ] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
40006114: c2 06 20 60 ld [ %i0 + 0x60 ], %g1 <== NOT EXECUTED
40006118: 82 00 60 01 inc %g1 <== NOT EXECUTED
4000611c: c2 26 20 60 st %g1, [ %i0 + 0x60 ] <== NOT EXECUTED
40006120: 81 c7 e0 08 ret <== NOT EXECUTED
40006124: 81 e8 00 00 restore <== NOT EXECUTED
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " queue-seg:%02d-%03d: p=%d a=%d u=%d b=%d f=%s n=%s",
40006128: c4 06 80 00 ld [ %i2 ], %g2
4000612c: 03 10 00 d5 sethi %hi(0x40035400), %g1
40006130: 80 a0 a0 00 cmp %g2, 0
40006134: 12 bf ff d9 bne 40006098 <rtems_fdisk_queue_segment+0x40>
40006138: 82 10 60 60 or %g1, 0x60, %g1
4000613c: 05 10 00 d5 sethi %hi(0x40035400), %g2
40006140: 84 10 a0 70 or %g2, 0x70, %g2 ! 40035470 <Callbacks.6428+0x228>
40006144: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
40006148: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
4000614c: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
40006150: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
40006154: 90 10 00 18 mov %i0, %o0
40006158: 13 10 00 d5 sethi %hi(0x40035400), %o1
4000615c: 7f ff fe 1b call 400059c8 <rtems_fdisk_info>
40006160: 92 12 60 78 or %o1, 0x78, %o1 ! 40035478 <Callbacks.6428+0x230>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
40006164: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
40006168: 80 a0 60 00 cmp %g1, 0
4000616c: 32 bf ff da bne,a 400060d4 <rtems_fdisk_queue_segment+0x7c><== NEVER TAKEN
40006170: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED
}
/*
* Remove the queue from the available or used queue.
*/
rtems_fdisk_segment_queue_remove (&fd->available, sc);
40006174: 92 10 00 1a mov %i2, %o1
40006178: b8 06 20 34 add %i0, 0x34, %i4
4000617c: 7f ff fd 94 call 400057cc <rtems_fdisk_segment_queue_remove>
40006180: 90 10 00 1c mov %i4, %o0
rtems_fdisk_segment_queue_remove (&fd->used, sc);
40006184: b6 06 20 40 add %i0, 0x40, %i3
40006188: 92 10 00 1a mov %i2, %o1
4000618c: 7f ff fd 90 call 400057cc <rtems_fdisk_segment_queue_remove>
40006190: 90 10 00 1b mov %i3, %o0
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
40006194: c6 06 a0 1c ld [ %i2 + 0x1c ], %g3
40006198: fa 06 a0 14 ld [ %i2 + 0x14 ], %i5
4000619c: c2 06 a0 20 ld [ %i2 + 0x20 ], %g1
400061a0: c4 06 a0 24 ld [ %i2 + 0x24 ], %g2
400061a4: 88 00 40 03 add %g1, %g3, %g4
400061a8: 84 01 00 02 add %g4, %g2, %g2
* If they are and the driver has been configured to background
* erase place the segment on the used queue. If not configured
* to background erase perform the erase now.
*
*/
if (rtems_fdisk_seg_pages_available (sc) == 0)
400061ac: 80 a7 40 02 cmp %i5, %g2
400061b0: 02 80 00 29 be 40006254 <rtems_fdisk_queue_segment+0x1fc>
400061b4: 80 a0 e0 00 cmp %g3, 0
* bit is cleared for that segment. When 32 erasers
* has occurred the page is re-written to the flash
* with all the counters updated with the number of
* bits cleared and all bits set back to 1.
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
400061b8: f2 06 20 34 ld [ %i0 + 0x34 ], %i1
while (seg)
400061bc: 80 a6 60 00 cmp %i1, 0
400061c0: 22 80 00 57 be,a 4000631c <rtems_fdisk_queue_segment+0x2c4>
400061c4: c0 26 80 00 clr [ %i2 ]
*
* @param fd The flash disk control table.
* @param sc The segment control table to be reallocated
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
400061c8: f6 06 60 20 ld [ %i1 + 0x20 ], %i3
400061cc: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
400061d0: c8 06 60 14 ld [ %i1 + 0x14 ], %g4
400061d4: c6 06 60 1c ld [ %i1 + 0x1c ], %g3
400061d8: ba 27 40 02 sub %i5, %g2, %i5
*
* @param fd The flash disk control table.
* @param sc The segment control table to be reallocated
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
400061dc: 82 06 c0 01 add %i3, %g1, %g1
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
400061e0: 82 21 00 01 sub %g4, %g1, %g1
400061e4: 82 20 40 03 sub %g1, %g3, %g1
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
400061e8: 80 a7 40 01 cmp %i5, %g1
400061ec: 3a 80 00 0e bcc,a 40006224 <rtems_fdisk_queue_segment+0x1cc>
400061f0: f2 06 40 00 ld [ %i1 ], %i1
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
400061f4: 7f ff ff 6f call 40005fb0 <rtems_fdisk_segment_queue_insert_before>
400061f8: 91 e8 00 1c restore %g0, %i4, %o0
*
* @param fd The flash disk control table.
* @param sc The segment control table to be reallocated
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
400061fc: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
40006200: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
40006204: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
*
* @param fd The flash disk control table.
* @param sc The segment control table to be reallocated
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
40006208: 82 01 00 01 add %g4, %g1, %g1
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
4000620c: 82 20 c0 01 sub %g3, %g1, %g1
40006210: 82 20 40 02 sub %g1, %g2, %g1
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
40006214: 80 a7 40 01 cmp %i5, %g1
40006218: 0a bf ff f7 bcs 400061f4 <rtems_fdisk_queue_segment+0x19c><== NEVER TAKEN
4000621c: 01 00 00 00 nop
rtems_fdisk_seg_pages_available (seg))
break;
seg = seg->next;
40006220: 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)
40006224: 80 a6 60 00 cmp %i1, 0
40006228: 32 bf ff f5 bne,a 400061fc <rtems_fdisk_queue_segment+0x1a4>
4000622c: c8 06 60 24 ld [ %i1 + 0x24 ], %g4
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
40006230: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
40006234: c0 26 80 00 clr [ %i2 ]
if (queue->head)
{
queue->tail->next = sc;
40006238: f4 20 40 00 st %i2, [ %g1 ]
queue->tail = sc;
4000623c: f4 26 20 38 st %i2, [ %i0 + 0x38 ]
else
{
queue->head = queue->tail = sc;
}
queue->count++;
40006240: c2 06 20 3c ld [ %i0 + 0x3c ], %g1
40006244: 82 00 60 01 inc %g1
40006248: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
4000624c: 81 c7 e0 08 ret
40006250: 81 e8 00 00 restore
* to background erase perform the erase now.
*
*/
if (rtems_fdisk_seg_pages_available (sc) == 0)
{
if (sc->pages_active)
40006254: 22 80 00 1b be,a 400062c0 <rtems_fdisk_queue_segment+0x268><== NEVER TAKEN
40006258: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
/*
* Keep the used queue sorted by the most number of used
* pages. When we compact we want to move the pages into
* a new segment and cover more than one segment.
*/
rtems_fdisk_segment_ctl* seg = fd->used.head;
4000625c: f2 06 20 40 ld [ %i0 + 0x40 ], %i1
while (seg)
40006260: 80 a6 60 00 cmp %i1, 0
40006264: 22 80 00 36 be,a 4000633c <rtems_fdisk_queue_segment+0x2e4>
40006268: c0 26 80 00 clr [ %i2 ]
{
if (sc->pages_used > seg->pages_used)
4000626c: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
40006270: 80 a0 40 02 cmp %g1, %g2
40006274: 28 80 00 07 bleu,a 40006290 <rtems_fdisk_queue_segment+0x238>
40006278: f2 06 40 00 ld [ %i1 ], %i1
4000627c: 30 80 00 26 b,a 40006314 <rtems_fdisk_queue_segment+0x2bc>
40006280: 80 a0 80 01 cmp %g2, %g1
40006284: 0a 80 00 24 bcs 40006314 <rtems_fdisk_queue_segment+0x2bc>
40006288: 01 00 00 00 nop
break;
seg = seg->next;
4000628c: 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)
40006290: 80 a6 60 00 cmp %i1, 0
40006294: 32 bf ff fb bne,a 40006280 <rtems_fdisk_queue_segment+0x228>
40006298: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
4000629c: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
400062a0: c0 26 80 00 clr [ %i2 ]
if (queue->head)
{
queue->tail->next = sc;
400062a4: f4 20 40 00 st %i2, [ %g1 ]
queue->tail = sc;
400062a8: f4 26 20 44 st %i2, [ %i0 + 0x44 ]
else
{
queue->head = queue->tail = sc;
}
queue->count++;
400062ac: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
400062b0: 82 00 60 01 inc %g1
400062b4: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
400062b8: 81 c7 e0 08 ret
400062bc: 81 e8 00 00 restore
else
rtems_fdisk_segment_queue_push_tail (&fd->used, sc);
}
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
400062c0: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
400062c4: 02 80 00 19 be 40006328 <rtems_fdisk_queue_segment+0x2d0> <== NOT EXECUTED
400062c8: 01 00 00 00 nop <== NOT EXECUTED
{
if (sc)
{
sc->next = 0;
if (queue->head)
400062cc: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 <== NOT EXECUTED
400062d0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400062d4: 02 80 00 17 be 40006330 <rtems_fdisk_queue_segment+0x2d8> <== NOT EXECUTED
400062d8: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
{
queue->tail->next = sc;
400062dc: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 <== NOT EXECUTED
400062e0: f4 20 40 00 st %i2, [ %g1 ] <== NOT EXECUTED
queue->tail = sc;
400062e4: f4 26 20 50 st %i2, [ %i0 + 0x50 ] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
400062e8: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED
400062ec: 82 00 60 01 inc %g1 <== NOT EXECUTED
400062f0: c2 26 20 54 st %g1, [ %i0 + 0x54 ] <== NOT EXECUTED
400062f4: 81 c7 e0 08 ret <== NOT EXECUTED
400062f8: 81 e8 00 00 restore <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
400062fc: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
40006300: f4 26 20 5c st %i2, [ %i0 + 0x5c ] <== NOT EXECUTED
40006304: 10 bf ff 84 b 40006114 <rtems_fdisk_queue_segment+0xbc> <== NOT EXECUTED
40006308: f4 26 20 58 st %i2, [ %i0 + 0x58 ] <== NOT EXECUTED
4000630c: 81 c7 e0 08 ret <== NOT EXECUTED
40006310: 81 e8 00 00 restore <== NOT EXECUTED
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->used, seg, sc);
40006314: 7f ff ff 27 call 40005fb0 <rtems_fdisk_segment_queue_insert_before>
40006318: 91 e8 00 1b restore %g0, %i3, %o0
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
4000631c: f4 26 20 38 st %i2, [ %i0 + 0x38 ]
40006320: 10 bf ff c8 b 40006240 <rtems_fdisk_queue_segment+0x1e8>
40006324: f4 26 20 34 st %i2, [ %i0 + 0x34 ]
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
rtems_fdisk_segment_queue_push_tail (&fd->erase, sc);
else
rtems_fdisk_erase_segment (fd, sc);
40006328: 7f ff fe c3 call 40005e34 <rtems_fdisk_erase_segment> <== NOT EXECUTED
4000632c: 93 e8 00 1a restore %g0, %i2, %o1 <== NOT EXECUTED
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
40006330: f4 26 20 50 st %i2, [ %i0 + 0x50 ] <== NOT EXECUTED
40006334: 10 bf ff ed b 400062e8 <rtems_fdisk_queue_segment+0x290> <== NOT EXECUTED
40006338: f4 26 20 4c st %i2, [ %i0 + 0x4c ] <== NOT EXECUTED
4000633c: f4 26 20 44 st %i2, [ %i0 + 0x44 ]
40006340: 10 bf ff db b 400062ac <rtems_fdisk_queue_segment+0x254>
40006344: f4 26 20 40 st %i2, [ %i0 + 0x40 ]
40005850 <rtems_fdisk_queue_status>:
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
40005850: c2 02 20 34 ld [ %o0 + 0x34 ], %g1
while (it)
40005854: 80 a0 60 00 cmp %g1, 0
40005858: 12 80 00 07 bne 40005874 <rtems_fdisk_queue_status+0x24> <== ALWAYS TAKEN
4000585c: 80 a2 40 01 cmp %o1, %g1
static void
rtems_fdisk_queue_status (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
40005860: 10 80 00 0a b 40005888 <rtems_fdisk_queue_status+0x38> <== NOT EXECUTED
40005864: 82 10 20 2d mov 0x2d, %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
40005868: 80 a0 60 00 cmp %g1, 0
4000586c: 02 80 00 06 be 40005884 <rtems_fdisk_queue_status+0x34> <== ALWAYS TAKEN
40005870: 80 a2 40 01 cmp %o1, %g1
{
if (it == sc)
40005874: 32 bf ff fd bne,a 40005868 <rtems_fdisk_queue_status+0x18>
40005878: c2 00 40 00 ld [ %g1 ], %g1
static void
rtems_fdisk_queue_status (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
4000587c: 10 80 00 03 b 40005888 <rtems_fdisk_queue_status+0x38>
40005880: 82 10 20 41 mov 0x41, %g1
40005884: 82 10 20 2d mov 0x2d, %g1
40005888: c2 2a 80 00 stb %g1, [ %o2 ]
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
4000588c: c2 02 20 40 ld [ %o0 + 0x40 ], %g1
while (it)
40005890: 80 a0 60 00 cmp %g1, 0
40005894: 12 80 00 07 bne 400058b0 <rtems_fdisk_queue_status+0x60> <== ALWAYS TAKEN
40005898: 80 a2 40 01 cmp %o1, %g1
rtems_fdisk_queue_status (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
4000589c: 10 80 00 0a b 400058c4 <rtems_fdisk_queue_status+0x74> <== NOT EXECUTED
400058a0: 82 10 20 2d mov 0x2d, %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
400058a4: 80 a0 60 00 cmp %g1, 0
400058a8: 02 80 00 06 be 400058c0 <rtems_fdisk_queue_status+0x70>
400058ac: 80 a2 40 01 cmp %o1, %g1
{
if (it == sc)
400058b0: 32 bf ff fd bne,a 400058a4 <rtems_fdisk_queue_status+0x54>
400058b4: c2 00 40 00 ld [ %g1 ], %g1
rtems_fdisk_queue_status (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
400058b8: 10 80 00 03 b 400058c4 <rtems_fdisk_queue_status+0x74>
400058bc: 82 10 20 55 mov 0x55, %g1
400058c0: 82 10 20 2d mov 0x2d, %g1
400058c4: c2 2a a0 01 stb %g1, [ %o2 + 1 ]
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
400058c8: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
while (it)
400058cc: 80 a0 60 00 cmp %g1, 0
400058d0: 12 80 00 07 bne 400058ec <rtems_fdisk_queue_status+0x9c> <== NEVER TAKEN
400058d4: 80 a2 40 01 cmp %o1, %g1
rtems_fdisk_segment_ctl* sc,
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc) ? 'E' : '-';
400058d8: 10 80 00 0a b 40005900 <rtems_fdisk_queue_status+0xb0>
400058dc: 82 10 20 2d mov 0x2d, %g1
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
400058e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400058e4: 02 80 00 06 be 400058fc <rtems_fdisk_queue_status+0xac> <== NOT EXECUTED
400058e8: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
{
if (it == sc)
400058ec: 32 bf ff fd bne,a 400058e0 <rtems_fdisk_queue_status+0x90><== NOT EXECUTED
400058f0: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc,
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc) ? 'E' : '-';
400058f4: 10 80 00 03 b 40005900 <rtems_fdisk_queue_status+0xb0> <== NOT EXECUTED
400058f8: 82 10 20 45 mov 0x45, %g1 <== NOT EXECUTED
400058fc: 82 10 20 2d mov 0x2d, %g1 <== NOT EXECUTED
40005900: c2 2a a0 02 stb %g1, [ %o2 + 2 ]
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
40005904: c2 02 20 58 ld [ %o0 + 0x58 ], %g1
while (it)
40005908: 80 a0 60 00 cmp %g1, 0
4000590c: 12 80 00 07 bne 40005928 <rtems_fdisk_queue_status+0xd8> <== NEVER TAKEN
40005910: 80 a2 40 01 cmp %o1, %g1
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc) ? 'E' : '-';
queues[3] = rtems_fdisk_segment_queue_present (&fd->failed, sc) ? 'F' : '-';
40005914: 10 80 00 0c b 40005944 <rtems_fdisk_queue_status+0xf4>
40005918: 82 10 20 2d mov 0x2d, %g1
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
4000591c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005920: 02 80 00 08 be 40005940 <rtems_fdisk_queue_status+0xf0> <== NOT EXECUTED
40005924: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
{
if (it == sc)
40005928: 32 bf ff fd bne,a 4000591c <rtems_fdisk_queue_status+0xcc><== NOT EXECUTED
4000592c: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc) ? 'E' : '-';
queues[3] = rtems_fdisk_segment_queue_present (&fd->failed, sc) ? 'F' : '-';
40005930: 82 10 20 46 mov 0x46, %g1 <== NOT EXECUTED
queues[4] = '\0';
40005934: c0 2a a0 04 clrb [ %o2 + 4 ] <== NOT EXECUTED
40005938: 81 c3 e0 08 retl <== NOT EXECUTED
4000593c: c2 2a a0 03 stb %g1, [ %o2 + 3 ] <== NOT EXECUTED
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc) ? 'E' : '-';
queues[3] = rtems_fdisk_segment_queue_present (&fd->failed, sc) ? 'F' : '-';
40005940: 82 10 20 2d mov 0x2d, %g1 <== NOT EXECUTED
queues[4] = '\0';
40005944: c0 2a a0 04 clrb [ %o2 + 4 ]
40005948: 81 c3 e0 08 retl
4000594c: c2 2a a0 03 stb %g1, [ %o2 + 3 ]
40006a60 <rtems_fdisk_recover_block_mappings>:
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
40006a60: 9d e3 bf 90 save %sp, -112, %sp
rtems_fdisk_segment_queue_init (&fd->failed);
/*
* Clear the lock mappings.
*/
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
40006a64: d4 06 20 1c ld [ %i0 + 0x1c ], %o2
40006a68: 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;
40006a6c: c0 26 20 38 clr [ %i0 + 0x38 ]
40006a70: c0 26 20 34 clr [ %i0 + 0x34 ]
queue->count = 0;
40006a74: 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;
40006a78: c0 26 20 44 clr [ %i0 + 0x44 ]
40006a7c: c0 26 20 40 clr [ %i0 + 0x40 ]
queue->count = 0;
40006a80: 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;
40006a84: c0 26 20 50 clr [ %i0 + 0x50 ]
40006a88: c0 26 20 4c clr [ %i0 + 0x4c ]
queue->count = 0;
40006a8c: 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;
40006a90: c0 26 20 5c clr [ %i0 + 0x5c ]
40006a94: c0 26 20 58 clr [ %i0 + 0x58 ]
queue->count = 0;
40006a98: 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));
40006a9c: 92 10 20 00 clr %o1
40006aa0: 40 00 79 39 call 40024f84 <memset>
40006aa4: 95 2a a0 03 sll %o2, 3, %o2
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
40006aa8: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
40006aac: c0 26 20 28 clr [ %i0 + 0x28 ]
fd->starvation_threshold = 0;
40006ab0: c0 26 20 24 clr [ %i0 + 0x24 ]
for (device = 0; device < fd->device_count; device++)
40006ab4: 80 a0 e0 00 cmp %g3, 0
40006ab8: 02 80 00 82 be 40006cc0 <rtems_fdisk_recover_block_mappings+0x260><== NEVER TAKEN
40006abc: ae 10 00 18 mov %i0, %l7
40006ac0: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
40006ac4: 25 10 00 d5 sethi %hi(0x40035400), %l2
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
40006ac8: 29 10 00 d5 sethi %hi(0x40035400), %l4
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
page, pd);
if (ret)
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
40006acc: 2d 10 00 d5 sethi %hi(0x40035400), %l6
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
40006ad0: 27 10 00 d6 sethi %hi(0x40035800), %l3
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
{
if (pd->block >= fd->block_count)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
40006ad4: 2b 10 00 d6 sethi %hi(0x40035800), %l5
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
40006ad8: a2 10 20 00 clr %l1
40006adc: 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);
40006ae0: a4 14 a3 60 or %l2, 0x360, %l2
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
40006ae4: a8 15 23 d0 or %l4, 0x3d0, %l4
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
page, pd);
if (ret)
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
40006ae8: ac 15 a3 f0 or %l6, 0x3f0, %l6
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
40006aec: a6 14 e0 48 or %l3, 0x48, %l3
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
{
if (pd->block >= fd->block_count)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
40006af0: aa 15 60 18 or %l5, 0x18, %l5
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
40006af4: 82 00 80 11 add %g2, %l1, %g1
40006af8: c8 00 60 04 ld [ %g1 + 4 ], %g4
40006afc: a0 10 20 00 clr %l0
40006b00: 80 a1 20 00 cmp %g4, 0
40006b04: 02 80 00 6b be 40006cb0 <rtems_fdisk_recover_block_mappings+0x250><== NEVER TAKEN
40006b08: b4 10 20 00 clr %i2
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[segment];
40006b0c: f6 00 40 00 ld [ %g1 ], %i3
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
40006b10: 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];
40006b14: b6 06 c0 10 add %i3, %l0, %i3
const rtems_fdisk_segment_desc* sd = sc->descriptor;
40006b18: fa 06 e0 04 ld [ %i3 + 4 ], %i5
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
40006b1c: 96 10 00 1a mov %i2, %o3
40006b20: 92 10 00 12 mov %l2, %o1
40006b24: 7f ff fb a9 call 400059c8 <rtems_fdisk_info>
40006b28: 90 10 00 17 mov %l7, %o0
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
40006b2c: d0 07 60 08 ld [ %i5 + 8 ], %o0
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
40006b30: f8 05 e0 14 ld [ %l7 + 0x14 ], %i4
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
40006b34: 7f ff ee db call 400026a0 <.udiv>
40006b38: 92 10 00 1c mov %i4, %o1
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
return ((bytes - 1) / page_size) + 1;
40006b3c: 92 10 00 1c mov %i4, %o1
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
40006b40: ba 10 00 08 mov %o0, %i5
static uint32_t
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
40006b44: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
40006b48: 7f ff ee d6 call 400026a0 <.udiv>
40006b4c: 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)
40006b50: c4 05 e0 24 ld [ %l7 + 0x24 ], %g2
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
return ((bytes - 1) / page_size) + 1;
40006b54: 90 02 20 01 inc %o0
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
40006b58: 82 27 40 08 sub %i5, %o0, %g1
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
40006b5c: d0 26 e0 18 st %o0, [ %i3 + 0x18 ]
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
40006b60: 80 a0 40 02 cmp %g1, %g2
40006b64: 08 80 00 03 bleu 40006b70 <rtems_fdisk_recover_block_mappings+0x110>
40006b68: c2 26 e0 14 st %g1, [ %i3 + 0x14 ]
fd->starvation_threshold = sc->pages;
40006b6c: c2 25 e0 24 st %g1, [ %l7 + 0x24 ]
sc->pages_used = 0;
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
40006b70: fa 06 e0 10 ld [ %i3 + 0x10 ], %i5
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
fd->starvation_threshold = sc->pages;
sc->pages_active = 0;
40006b74: c0 26 e0 1c clr [ %i3 + 0x1c ]
sc->pages_used = 0;
40006b78: c0 26 e0 20 clr [ %i3 + 0x20 ]
sc->pages_bad = 0;
40006b7c: c0 26 e0 24 clr [ %i3 + 0x24 ]
sc->failed = false;
40006b80: c0 26 e0 28 clr [ %i3 + 0x28 ]
if (!sc->page_descriptors)
40006b84: 80 a7 60 00 cmp %i5, 0
40006b88: 02 80 00 94 be 40006dd8 <rtems_fdisk_recover_block_mappings+0x378><== ALWAYS TAKEN
40006b8c: 92 10 00 1c mov %i4, %o1
40006b90: 7f ff ee 8a call 400025b8 <.umul> <== NOT EXECUTED
40006b94: 01 00 00 00 nop <== NOT EXECUTED
40006b98: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
* descriptors.
*
* @todo It may be better to ask the driver to get these value
* so NAND flash could be better supported.
*/
ret = rtems_fdisk_seg_read (fd, sc, 0, (void*) pd,
40006b9c: 90 10 00 17 mov %l7, %o0
40006ba0: 92 10 00 1b mov %i3, %o1
40006ba4: 94 10 20 00 clr %o2
40006ba8: 7f ff fb cc call 40005ad8 <rtems_fdisk_seg_read>
40006bac: 96 10 00 1d mov %i5, %o3
sc->pages_desc * fd->block_size);
if (ret)
40006bb0: b0 92 20 00 orcc %o0, 0, %i0
40006bb4: 12 80 00 95 bne 40006e08 <rtems_fdisk_recover_block_mappings+0x3a8><== NEVER TAKEN
40006bb8: 01 00 00 00 nop
* are active and how many are used.
*
* If the page is active see if the block is with-in range and
* if the block is a duplicate.
*/
for (page = 0; page < sc->pages; page++, pd++)
40006bbc: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
40006bc0: 80 a0 a0 00 cmp %g2, 0
40006bc4: 12 80 00 0a bne 40006bec <rtems_fdisk_recover_block_mappings+0x18c><== ALWAYS TAKEN
40006bc8: b8 10 20 00 clr %i4
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
40006bcc: 10 80 00 2f b 40006c88 <rtems_fdisk_recover_block_mappings+0x228><== NOT EXECUTED
40006bd0: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
{
sc->pages_used++;
40006bd4: 82 00 60 01 inc %g1 <== NOT EXECUTED
40006bd8: c2 26 e0 20 st %g1, [ %i3 + 0x20 ] <== NOT EXECUTED
* are active and how many are used.
*
* If the page is active see if the block is with-in range and
* if the block is a duplicate.
*/
for (page = 0; page < sc->pages; page++, pd++)
40006bdc: b8 07 20 01 inc %i4
40006be0: 80 a0 80 1c cmp %g2, %i4
40006be4: 08 80 00 28 bleu 40006c84 <rtems_fdisk_recover_block_mappings+0x224>
40006be8: ba 07 60 08 add %i5, 8, %i5
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
40006bec: c2 07 40 00 ld [ %i5 ], %g1
40006bf0: 80 a0 7f ff cmp %g1, -1
40006bf4: 22 80 00 35 be,a 40006cc8 <rtems_fdisk_recover_block_mappings+0x268><== ALWAYS TAKEN
40006bf8: c2 07 60 04 ld [ %i5 + 4 ], %g1
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
40006bfc: c2 17 60 02 lduh [ %i5 + 2 ], %g1 <== NOT EXECUTED
sc->pages_used++;
}
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
40006c00: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
40006c04: 22 bf ff f4 be,a 40006bd4 <rtems_fdisk_recover_block_mappings+0x174><== NOT EXECUTED
40006c08: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1 <== NOT EXECUTED
{
sc->pages_used++;
}
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
40006c0c: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
40006c10: 32 80 00 43 bne,a 40006d1c <rtems_fdisk_recover_block_mappings+0x2bc><== NOT EXECUTED
40006c14: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1 <== NOT EXECUTED
{
if (pd->block >= fd->block_count)
40006c18: da 07 60 04 ld [ %i5 + 4 ], %o5 <== NOT EXECUTED
40006c1c: c2 05 e0 1c ld [ %l7 + 0x1c ], %g1 <== NOT EXECUTED
40006c20: 80 a3 40 01 cmp %o5, %g1 <== NOT EXECUTED
40006c24: 1a 80 00 57 bcc 40006d80 <rtems_fdisk_recover_block_mappings+0x320><== NOT EXECUTED
40006c28: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
"invalid block number: %d-%d-%d: block: %d",
device, segment, page, pd->block);
#endif
sc->pages_bad++;
}
else if (fd->blocks[pd->block].segment)
40006c2c: c6 05 e0 18 ld [ %l7 + 0x18 ], %g3 <== NOT EXECUTED
40006c30: 9b 2b 60 03 sll %o5, 3, %o5 <== NOT EXECUTED
40006c34: c2 00 c0 0d ld [ %g3 + %o5 ], %g1 <== NOT EXECUTED
40006c38: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006c3c: 02 80 00 5b be 40006da8 <rtems_fdisk_recover_block_mappings+0x348><== NOT EXECUTED
40006c40: 88 00 c0 0d add %g3, %o5, %g4 <== NOT EXECUTED
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
40006c44: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
40006c48: d4 00 60 0c ld [ %g1 + 0xc ], %o2 <== NOT EXECUTED
40006c4c: d6 01 20 04 ld [ %g4 + 4 ], %o3 <== NOT EXECUTED
40006c50: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
40006c54: f8 23 a0 5c st %i4, [ %sp + 0x5c ] <== NOT EXECUTED
40006c58: 98 10 00 19 mov %i1, %o4 <== NOT EXECUTED
40006c5c: 7f ff fc 57 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40006c60: 9a 10 00 1a mov %i2, %o5 <== NOT EXECUTED
"duplicate: %d-%d-%d",
bsc->device, bsc->segment,
fd->blocks[pd->block].page,
device, segment, page);
sc->pages_bad++;
40006c64: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1 <== NOT EXECUTED
40006c68: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2 <== NOT EXECUTED
40006c6c: 82 00 60 01 inc %g1 <== NOT EXECUTED
40006c70: c2 26 e0 24 st %g1, [ %i3 + 0x24 ] <== NOT EXECUTED
* are active and how many are used.
*
* If the page is active see if the block is with-in range and
* if the block is a duplicate.
*/
for (page = 0; page < sc->pages; page++, pd++)
40006c74: b8 07 20 01 inc %i4 <== NOT EXECUTED
40006c78: 80 a0 80 1c cmp %g2, %i4 <== NOT EXECUTED
40006c7c: 18 bf ff dc bgu 40006bec <rtems_fdisk_recover_block_mappings+0x18c><== NOT EXECUTED
40006c80: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
40006c84: 90 10 00 17 mov %l7, %o0
40006c88: 7f ff fc f4 call 40006058 <rtems_fdisk_queue_segment>
40006c8c: 92 10 00 1b mov %i3, %o1
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
40006c90: c4 05 e0 2c ld [ %l7 + 0x2c ], %g2
40006c94: b4 06 a0 01 inc %i2
40006c98: 82 00 80 11 add %g2, %l1, %g1
40006c9c: c6 00 60 04 ld [ %g1 + 4 ], %g3
40006ca0: 80 a0 c0 1a cmp %g3, %i2
40006ca4: 18 bf ff 9a bgu 40006b0c <rtems_fdisk_recover_block_mappings+0xac>
40006ca8: a0 04 20 30 add %l0, 0x30, %l0
40006cac: c6 05 e0 30 ld [ %l7 + 0x30 ], %g3
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
40006cb0: b2 06 60 01 inc %i1
40006cb4: 80 a0 c0 19 cmp %g3, %i1
40006cb8: 18 bf ff 8f bgu 40006af4 <rtems_fdisk_recover_block_mappings+0x94><== NEVER TAKEN
40006cbc: a2 04 60 0c add %l1, 0xc, %l1
*/
rtems_fdisk_queue_segment (fd, sc);
}
}
return 0;
40006cc0: 81 c7 e0 08 ret
40006cc4: 91 e8 20 00 restore %g0, 0, %o0
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
40006cc8: 80 a0 7f ff cmp %g1, -1
40006ccc: 32 bf ff cd bne,a 40006c00 <rtems_fdisk_recover_block_mappings+0x1a0><== NEVER TAKEN
40006cd0: c2 17 60 02 lduh [ %i5 + 2 ], %g1 <== NOT EXECUTED
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
page * fd->block_size, fd->block_size);
40006cd4: f0 05 e0 14 ld [ %l7 + 0x14 ], %i0
if (rtems_fdisk_page_desc_erased (pd))
{
/*
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
40006cd8: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0
static int
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
40006cdc: 92 10 00 18 mov %i0, %o1
40006ce0: 7f ff ee 36 call 400025b8 <.umul>
40006ce4: 90 07 00 08 add %i4, %o0, %o0
40006ce8: 92 10 00 1b mov %i3, %o1
40006cec: 94 10 00 08 mov %o0, %o2
40006cf0: 96 10 00 18 mov %i0, %o3
40006cf4: 7f ff fb 9b call 40005b60 <rtems_fdisk_seg_blank_check>
40006cf8: 90 10 00 17 mov %l7, %o0
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
page + sc->pages_desc);
if (ret == 0)
40006cfc: 80 a2 20 00 cmp %o0, 0
40006d00: 32 80 00 0a bne,a 40006d28 <rtems_fdisk_recover_block_mappings+0x2c8><== NEVER TAKEN
40006d04: da 07 60 04 ld [ %i5 + 4 ], %o5 <== NOT EXECUTED
{
++fd->erased_blocks;
40006d08: c2 05 e0 28 ld [ %l7 + 0x28 ], %g1
40006d0c: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
40006d10: 82 00 60 01 inc %g1
40006d14: 10 bf ff b2 b 40006bdc <rtems_fdisk_recover_block_mappings+0x17c>
40006d18: c2 25 e0 28 st %g1, [ %l7 + 0x28 ]
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
40006d1c: 82 00 60 01 inc %g1 <== NOT EXECUTED
40006d20: 10 bf ff af b 40006bdc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40006d24: c2 26 e0 24 st %g1, [ %i3 + 0x24 ] <== NOT EXECUTED
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
40006d28: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
40006d2c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40006d30: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
40006d34: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED
40006d38: 7f ff fb fe call 40005d30 <rtems_fdisk_warning> <== NOT EXECUTED
40006d3c: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
40006d40: c2 17 60 02 lduh [ %i5 + 2 ], %g1 <== NOT EXECUTED
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
device, segment, page, pd->block);
#endif
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
40006d44: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
40006d48: 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,
40006d4c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
40006d50: c2 37 60 02 sth %g1, [ %i5 + 2 ] <== NOT EXECUTED
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
device, segment, page, pd->block);
#endif
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
40006d54: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40006d58: 7f ff fb c9 call 40005c7c <rtems_fdisk_seg_write_page_desc><== NOT EXECUTED
40006d5c: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
page, pd);
if (ret)
40006d60: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40006d64: 12 80 00 17 bne 40006dc0 <rtems_fdisk_recover_block_mappings+0x360><== NOT EXECUTED
40006d68: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
device, segment, page);
}
sc->pages_used++;
40006d6c: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1 <== NOT EXECUTED
40006d70: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2 <== NOT EXECUTED
40006d74: 82 00 60 01 inc %g1 <== NOT EXECUTED
40006d78: 10 bf ff 99 b 40006bdc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40006d7c: c2 26 e0 20 st %g1, [ %i3 + 0x20 ] <== NOT EXECUTED
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
{
if (pd->block >= fd->block_count)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
40006d80: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
40006d84: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40006d88: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
40006d8c: 7f ff fb e9 call 40005d30 <rtems_fdisk_warning> <== NOT EXECUTED
40006d90: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED
"invalid block number: %d-%d-%d: block: %d",
device, segment, page, pd->block);
#endif
sc->pages_bad++;
40006d94: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1 <== NOT EXECUTED
40006d98: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2 <== NOT EXECUTED
40006d9c: 82 00 60 01 inc %g1 <== NOT EXECUTED
40006da0: 10 bf ff 8f b 40006bdc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40006da4: c2 26 e0 24 st %g1, [ %i3 + 0x24 ] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
/*
* The page is active.
*/
sc->pages_active++;
40006da8: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
{
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
40006dac: f6 20 c0 0d st %i3, [ %g3 + %o5 ] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
40006db0: f8 21 20 04 st %i4, [ %g4 + 4 ] <== NOT EXECUTED
/*
* The page is active.
*/
sc->pages_active++;
40006db4: 82 00 60 01 inc %g1 <== NOT EXECUTED
40006db8: 10 bf ff 89 b 40006bdc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40006dbc: c2 26 e0 1c st %g1, [ %i3 + 0x1c ] <== NOT EXECUTED
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
page, pd);
if (ret)
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
40006dc0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40006dc4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40006dc8: 7f ff fb fc call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40006dcc: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
device, segment, page);
}
sc->pages_used++;
40006dd0: 10 bf ff e8 b 40006d70 <rtems_fdisk_recover_block_mappings+0x310><== NOT EXECUTED
40006dd4: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1 <== NOT EXECUTED
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
40006dd8: 7f ff ed f8 call 400025b8 <.umul>
40006ddc: 01 00 00 00 nop
40006de0: 40 00 0a 6f call 4000979c <malloc>
40006de4: d0 27 bf fc st %o0, [ %fp + -4 ]
40006de8: d0 26 e0 10 st %o0, [ %i3 + 0x10 ]
40006dec: ba 10 00 08 mov %o0, %i5
if (!sc->page_descriptors)
40006df0: 80 a2 20 00 cmp %o0, 0
40006df4: 12 bf ff 6a bne 40006b9c <rtems_fdisk_recover_block_mappings+0x13c><== ALWAYS TAKEN
40006df8: d8 07 bf fc ld [ %fp + -4 ], %o4
rtems_fdisk_abort ("no memory for page descriptors");
40006dfc: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40006e00: 40 00 06 60 call 40008780 <rtems_fdisk_abort.constprop.1> <== NOT EXECUTED
40006e04: 90 12 23 40 or %o0, 0x340, %o0 ! 40035740 <Callbacks.6428+0x4f8><== NOT EXECUTED
ret = rtems_fdisk_seg_read (fd, sc, 0, (void*) pd,
sc->pages_desc * fd->block_size);
if (ret)
{
rtems_fdisk_error ("recover-block-mappings:%02d-%03d: " \
40006e08: 40 00 7d 27 call 400262a4 <strerror> <== NOT EXECUTED
40006e0c: 01 00 00 00 nop <== NOT EXECUTED
40006e10: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40006e14: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40006e18: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40006e1c: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40006e20: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
40006e24: 7f ff fb e5 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40006e28: 90 12 23 88 or %o0, 0x388, %o0 <== NOT EXECUTED
"read page desc failed: %s (%d)",
device, segment, strerror (ret), ret);
return ret;
40006e2c: 81 c7 e0 08 ret <== NOT EXECUTED
40006e30: 81 e8 00 00 restore <== NOT EXECUTED
40006348 <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)
{
40006348: 9d e3 bf 78 save %sp, -136, %sp
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
4000634c: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
40006350: c0 27 bf f8 clr [ %fp + -8 ]
40006354: 80 a0 e0 00 cmp %g3, 0
40006358: 02 80 00 7f be 40006554 <rtems_fdisk_recycle_segment+0x20c><== NEVER TAKEN
4000635c: 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);
40006360: 82 06 20 34 add %i0, 0x34, %g1
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
40006364: b8 10 20 00 clr %i4
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
dsc = rtems_fdisk_seg_most_available (&fd->available);
40006368: c2 27 bf f4 st %g1, [ %fp + -12 ]
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
4000636c: e2 06 60 10 ld [ %i1 + 0x10 ], %l1
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
40006370: a1 2f 20 03 sll %i4, 3, %l0
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (!dsc && ssc->pages_active > 0)
40006374: 80 a6 a0 00 cmp %i2, 0
40006378: 02 80 00 8d be 400065ac <rtems_fdisk_recycle_segment+0x264>
4000637c: ac 04 40 10 add %l1, %l0, %l6
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
40006380: c4 15 a0 02 lduh [ %l6 + 2 ], %g2
{
rtems_fdisk_error ("recycle: no available dst segment");
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
40006384: 80 88 a0 01 btst 1, %g2
40006388: 32 80 00 6b bne,a 40006534 <rtems_fdisk_recycle_segment+0x1ec><== NEVER TAKEN
4000638c: c4 04 40 10 ld [ %l1 + %l0 ], %g2 <== NOT EXECUTED
40006390: 80 88 a0 02 btst 2, %g2
40006394: 22 80 00 68 be,a 40006534 <rtems_fdisk_recycle_segment+0x1ec>
40006398: c4 04 40 10 ld [ %l1 + %l0 ], %g2
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
4000639c: de 06 a0 14 ld [ %i2 + 0x14 ], %o7
400063a0: 80 a3 e0 00 cmp %o7, 0
400063a4: 02 80 00 8d be 400065d8 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
400063a8: ee 06 a0 10 ld [ %i2 + 0x10 ], %l7
400063ac: 84 10 00 17 mov %l7, %g2
400063b0: 10 80 00 05 b 400063c4 <rtems_fdisk_recycle_segment+0x7c>
400063b4: ba 10 20 00 clr %i5
400063b8: 80 a7 40 0f cmp %i5, %o7
400063bc: 02 80 00 87 be 400065d8 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
400063c0: 84 00 a0 08 add %g2, 8, %g2
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
400063c4: c8 00 80 00 ld [ %g2 ], %g4
400063c8: 80 a1 3f ff cmp %g4, -1
400063cc: 32 bf ff fb bne,a 400063b8 <rtems_fdisk_recycle_segment+0x70>
400063d0: ba 07 60 01 inc %i5
400063d4: c8 00 a0 04 ld [ %g2 + 4 ], %g4
400063d8: 80 a1 3f ff cmp %g4, -1
400063dc: 32 bf ff f7 bne,a 400063b8 <rtems_fdisk_recycle_segment+0x70><== NEVER TAKEN
400063e0: ba 07 60 01 inc %i5 <== NOT EXECUTED
uint32_t dst_pages;
rtems_fdisk_page_desc* dpd;
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
400063e4: 83 2f 60 03 sll %i5, 3, %g1
400063e8: c2 27 bf fc st %g1, [ %fp + -4 ]
active++;
400063ec: c2 07 bf f8 ld [ %fp + -8 ], %g1
if (dpage >= dsc->pages)
400063f0: 80 a7 40 0f cmp %i5, %o7
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
active++;
400063f4: 82 00 60 01 inc %g1
400063f8: c2 27 bf f8 st %g1, [ %fp + -8 ]
uint32_t dst_pages;
rtems_fdisk_page_desc* dpd;
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
400063fc: c2 07 bf fc ld [ %fp + -4 ], %g1
active++;
if (dpage >= dsc->pages)
40006400: 1a 80 00 76 bcc 400065d8 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
40006404: a6 05 c0 01 add %l7, %g1, %l3
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return EIO;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
40006408: da 06 a0 08 ld [ %i2 + 8 ], %o5
4000640c: c4 06 a0 0c ld [ %i2 + 0xc ], %g2
40006410: d4 06 60 08 ld [ %i1 + 8 ], %o2
40006414: d6 06 60 0c ld [ %i1 + 0xc ], %o3
40006418: 98 10 00 1c mov %i4, %o4
4000641c: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
40006420: 13 10 00 d5 sethi %hi(0x40035400), %o1
40006424: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
40006428: 92 12 61 08 or %o1, 0x108, %o1
4000642c: 7f ff fd 67 call 400059c8 <rtems_fdisk_info>
40006430: 90 10 00 18 mov %i0, %o0
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
40006434: c8 06 a0 18 ld [ %i2 + 0x18 ], %g4
rtems_fdisk_segment_ctl* dst_sc,
uint32_t dst_page)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
40006438: da 06 a0 08 ld [ %i2 + 8 ], %o5
4000643c: de 06 a0 0c ld [ %i2 + 0xc ], %o7
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
40006440: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
rtems_fdisk_segment_ctl* dst_sc,
uint32_t dst_page)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
40006444: d4 06 60 08 ld [ %i1 + 8 ], %o2
40006448: d6 06 60 0c ld [ %i1 + 0xc ], %o3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
4000644c: a8 07 00 02 add %i4, %g2, %l4
40006450: aa 07 40 04 add %i5, %g4, %l5
rtems_fdisk_segment_ctl* dst_sc,
uint32_t dst_page)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
40006454: de 23 a0 5c st %o7, [ %sp + 0x5c ]
40006458: 98 10 00 14 mov %l4, %o4
4000645c: 13 10 00 d5 sethi %hi(0x40035400), %o1
40006460: ea 23 a0 60 st %l5, [ %sp + 0x60 ]
40006464: 92 12 61 30 or %o1, 0x130, %o1
40006468: 7f ff fd 7a call 40005a50 <rtems_fdisk_printf>
4000646c: 90 10 00 18 mov %i0, %o0
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
page * fd->block_size, buffer, fd->block_size);
40006470: d8 06 20 14 ld [ %i0 + 0x14 ], %o4
rtems_fdisk_seg_read_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
40006474: 90 10 00 14 mov %l4, %o0
40006478: 92 10 00 0c mov %o4, %o1
4000647c: 7f ff f0 4f call 400025b8 <.umul>
40006480: d8 27 bf ec st %o4, [ %fp + -20 ]
40006484: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
40006488: d8 07 bf ec ld [ %fp + -20 ], %o4
4000648c: 94 10 00 08 mov %o0, %o2
40006490: 92 10 00 19 mov %i1, %o1
40006494: 7f ff fd 91 call 40005ad8 <rtems_fdisk_seg_read>
40006498: 90 10 00 18 mov %i0, %o0
src_sc->device, src_sc->segment, src_page,
dst_sc->device, dst_sc->segment, dst_page);
#endif
ret = rtems_fdisk_seg_read_page (fd, src_sc, src_page,
fd->copy_buffer);
if (ret)
4000649c: 84 92 20 00 orcc %o0, 0, %g2
400064a0: 22 80 00 6a be,a 40006648 <rtems_fdisk_recycle_segment+0x300><== ALWAYS TAKEN
400064a4: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
spage + ssc->pages_desc,
dsc,
dpage + dsc->pages_desc);
if (ret)
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
400064a8: e2 06 a0 08 ld [ %i2 + 8 ], %l1 <== NOT EXECUTED
400064ac: e0 06 a0 0c ld [ %i2 + 0xc ], %l0 <== NOT EXECUTED
400064b0: e4 06 60 0c ld [ %i1 + 0xc ], %l2 <== NOT EXECUTED
400064b4: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
400064b8: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
400064bc: 40 00 7f 7a call 400262a4 <strerror> <== NOT EXECUTED
400064c0: c4 27 bf f0 st %g2, [ %fp + -16 ] <== NOT EXECUTED
400064c4: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED
400064c8: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
400064cc: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
400064d0: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
400064d4: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
400064d8: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
400064dc: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
400064e0: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
400064e4: c4 23 a0 64 st %g2, [ %sp + 0x64 ] <== NOT EXECUTED
400064e8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400064ec: 90 12 21 60 or %o0, 0x160, %o0 <== NOT EXECUTED
dsc,
dpage, dpd);
if (ret)
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
400064f0: 7f ff fe 32 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
400064f4: 01 00 00 00 nop <== NOT EXECUTED
"%02d-%03d-%03d: copy pd failed: %s (%d)",
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage,
strerror (ret), ret);
rtems_fdisk_queue_segment (fd, dsc);
400064f8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400064fc: 7f ff fe d7 call 40006058 <rtems_fdisk_queue_segment> <== NOT EXECUTED
40006500: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = queue->head;
40006504: c6 06 20 40 ld [ %i0 + 0x40 ], %g3 <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
40006508: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = queue->head;
4000650c: c6 26 40 00 st %g3, [ %i1 ] <== NOT EXECUTED
queue->head = sc;
40006510: f2 26 20 40 st %i1, [ %i0 + 0x40 ] <== NOT EXECUTED
if (queue->tail == 0)
40006514: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006518: 02 80 00 98 be 40006778 <rtems_fdisk_recycle_segment+0x430><== NOT EXECUTED
4000651c: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED
queue->tail = sc;
queue->count++;
40006520: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED
40006524: 82 00 60 01 inc %g1 <== NOT EXECUTED
40006528: c2 26 20 48 st %g1, [ %i0 + 0x48 ] <== NOT EXECUTED
}
ret = rtems_fdisk_erase_segment (fd, ssc);
return ret;
}
4000652c: 81 c7 e0 08 ret <== NOT EXECUTED
40006530: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
40006534: 80 a0 bf ff cmp %g2, -1
40006538: 22 80 00 16 be,a 40006590 <rtems_fdisk_recycle_segment+0x248><== NEVER TAKEN
4000653c: c2 05 a0 04 ld [ %l6 + 4 ], %g1 <== NOT EXECUTED
{
--fd->erased_blocks;
}
else
{
used++;
40006540: a4 04 a0 01 inc %l2
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
40006544: b8 07 20 01 inc %i4
40006548: 80 a0 c0 1c cmp %g3, %i4
4000654c: 38 bf ff 89 bgu,a 40006370 <rtems_fdisk_recycle_segment+0x28>
40006550: e2 06 60 10 ld [ %i1 + 0x10 ], %l1
used++;
}
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, "ssc end: %d-%d: p=%ld, a=%ld, u=%ld",
40006554: d4 06 60 08 ld [ %i1 + 8 ], %o2
40006558: d6 06 60 0c ld [ %i1 + 0xc ], %o3
4000655c: da 07 bf f8 ld [ %fp + -8 ], %o5
40006560: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
40006564: 90 10 00 18 mov %i0, %o0
40006568: 13 10 00 d5 sethi %hi(0x40035400), %o1
4000656c: 98 10 00 1b mov %i3, %o4
40006570: 7f ff fd 38 call 40005a50 <rtems_fdisk_printf>
40006574: 92 12 61 f0 or %o1, 0x1f0, %o1
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
40006578: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4000657c: 80 a2 60 00 cmp %o1, 0
40006580: 12 80 00 69 bne 40006724 <rtems_fdisk_recycle_segment+0x3dc><== NEVER TAKEN
40006584: 11 10 00 d5 sethi %hi(0x40035400), %o0
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
40006588: 7f ff fe 2b call 40005e34 <rtems_fdisk_erase_segment>
4000658c: 81 e8 00 00 restore
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
40006590: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
40006594: 32 bf ff ec bne,a 40006544 <rtems_fdisk_recycle_segment+0x1fc><== NOT EXECUTED
40006598: a4 04 a0 01 inc %l2 <== NOT EXECUTED
(*pages)--;
}
else if (rtems_fdisk_page_desc_erased (spd))
{
--fd->erased_blocks;
4000659c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
400065a0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
400065a4: 10 bf ff e8 b 40006544 <rtems_fdisk_recycle_segment+0x1fc><== NOT EXECUTED
400065a8: c2 26 20 28 st %g1, [ %i0 + 0x28 ] <== NOT EXECUTED
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (!dsc && ssc->pages_active > 0)
400065ac: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
400065b0: 80 a0 a0 00 cmp %g2, 0
400065b4: 22 bf ff 74 be,a 40006384 <rtems_fdisk_recycle_segment+0x3c><== ALWAYS TAKEN
400065b8: c4 15 a0 02 lduh [ %l6 + 2 ], %g2
{
rtems_fdisk_error ("recycle: no available dst segment");
return EIO;
400065bc: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (!dsc && ssc->pages_active > 0)
{
rtems_fdisk_error ("recycle: no available dst segment");
400065c0: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
400065c4: c4 27 bf f0 st %g2, [ %fp + -16 ] <== NOT EXECUTED
400065c8: 7f ff fd fc call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
400065cc: 90 12 20 b0 or %o0, 0xb0, %o0 <== NOT EXECUTED
return EIO;
400065d0: 10 bf ff d7 b 4000652c <rtems_fdisk_recycle_segment+0x1e4><== NOT EXECUTED
400065d4: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
400065d8: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2 <== NOT EXECUTED
400065dc: c2 06 a0 20 ld [ %i2 + 0x20 ], %g1 <== NOT EXECUTED
400065e0: d6 06 a0 24 ld [ %i2 + 0x24 ], %o3 <== NOT EXECUTED
active++;
if (dpage >= dsc->pages)
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
400065e4: d2 06 a0 08 ld [ %i2 + 8 ], %o1 <== NOT EXECUTED
400065e8: d4 06 a0 0c ld [ %i2 + 0xc ], %o2 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
400065ec: 96 02 c0 02 add %o3, %g2, %o3 <== NOT EXECUTED
active++;
if (dpage >= dsc->pages)
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
400065f0: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
400065f4: 96 02 c0 01 add %o3, %g1, %o3 <== NOT EXECUTED
active++;
if (dpage >= dsc->pages)
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
400065f8: 96 23 c0 0b sub %o7, %o3, %o3 <== NOT EXECUTED
400065fc: 7f ff fd ef call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40006600: 90 12 20 d8 or %o0, 0xd8, %o0 <== NOT EXECUTED
"no page desc available: %d",
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
40006604: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
40006608: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
"no page desc available: %d",
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
4000660c: c2 26 a0 28 st %g1, [ %i2 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
40006610: 7f ff fe 92 call 40006058 <rtems_fdisk_queue_segment> <== NOT EXECUTED
40006614: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = queue->head;
40006618: c4 06 20 40 ld [ %i0 + 0x40 ], %g2 <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
4000661c: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = queue->head;
40006620: c4 26 40 00 st %g2, [ %i1 ] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
40006624: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006628: 02 80 00 56 be 40006780 <rtems_fdisk_recycle_segment+0x438><== NOT EXECUTED
4000662c: f2 26 20 40 st %i1, [ %i0 + 0x40 ] <== NOT EXECUTED
queue->tail = sc;
queue->count++;
40006630: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return EIO;
40006634: 84 10 20 05 mov 5, %g2 <== NOT EXECUTED
sc->next = queue->head;
queue->head = sc;
if (queue->tail == 0)
queue->tail = sc;
queue->count++;
40006638: 82 00 60 01 inc %g1 <== NOT EXECUTED
4000663c: c2 26 20 48 st %g1, [ %i0 + 0x48 ] <== NOT EXECUTED
}
ret = rtems_fdisk_erase_segment (fd, ssc);
return ret;
}
40006640: 81 c7 e0 08 ret <== NOT EXECUTED
40006644: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED
#endif
ret = rtems_fdisk_seg_read_page (fd, src_sc, src_page,
fd->copy_buffer);
if (ret)
return ret;
return rtems_fdisk_seg_write_page (fd, dst_sc, dst_page,
40006648: 90 10 00 18 mov %i0, %o0
4000664c: 92 10 00 1a mov %i2, %o1
40006650: 7f ff fd 9c call 40005cc0 <rtems_fdisk_seg_write_page>
40006654: 94 10 00 15 mov %l5, %o2
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
spage + ssc->pages_desc,
dsc,
dpage + dsc->pages_desc);
if (ret)
40006658: 84 92 20 00 orcc %o0, 0, %g2
4000665c: 12 bf ff 93 bne 400064a8 <rtems_fdisk_recycle_segment+0x160><== NEVER TAKEN
40006660: c2 07 bf fc ld [ %fp + -4 ], %g1
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
40006664: c4 04 40 10 ld [ %l1 + %l0 ], %g2
ret = rtems_fdisk_seg_write_page_desc (fd,
40006668: 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;
4000666c: c4 25 c0 01 st %g2, [ %l7 + %g1 ]
40006670: c4 05 a0 04 ld [ %l6 + 4 ], %g2
ret = rtems_fdisk_seg_write_page_desc (fd,
40006674: 92 10 00 1a mov %i2, %o1
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
40006678: c4 24 e0 04 st %g2, [ %l3 + 4 ]
ret = rtems_fdisk_seg_write_page_desc (fd,
4000667c: 94 10 00 1d mov %i5, %o2
40006680: 7f ff fd 7f call 40005c7c <rtems_fdisk_seg_write_page_desc>
40006684: 96 10 00 13 mov %l3, %o3
dsc,
dpage, dpd);
if (ret)
40006688: 84 92 20 00 orcc %o0, 0, %g2
4000668c: 32 80 00 2a bne,a 40006734 <rtems_fdisk_recycle_segment+0x3ec><== NEVER TAKEN
40006690: e2 06 a0 08 ld [ %i2 + 8 ], %l1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
dsc->pages_active++;
40006694: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
ssc->pages_used++;
40006698: c6 06 60 20 ld [ %i1 + 0x20 ], %g3
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
dsc->pages_active++;
4000669c: 84 00 a0 01 inc %g2
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
400066a0: c2 05 a0 04 ld [ %l6 + 4 ], %g1
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
dsc->pages_active++;
400066a4: c4 26 a0 1c st %g2, [ %i2 + 0x1c ]
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
400066a8: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
* segment will be erased. Power down could be a problem.
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
400066ac: c8 06 60 1c ld [ %i1 + 0x1c ], %g4
ssc->pages_used++;
400066b0: 86 00 e0 01 inc %g3
fd->blocks[spd->block].segment = dsc;
400066b4: 83 28 60 03 sll %g1, 3, %g1
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
ssc->pages_used++;
400066b8: c6 26 60 20 st %g3, [ %i1 + 0x20 ]
* segment will be erased. Power down could be a problem.
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
400066bc: 88 01 3f ff add %g4, -1, %g4
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
400066c0: 86 00 80 01 add %g2, %g1, %g3
* segment will be erased. Power down could be a problem.
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
400066c4: c8 26 60 1c st %g4, [ %i1 + 0x1c ]
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
400066c8: f4 20 80 01 st %i2, [ %g2 + %g1 ]
fd->blocks[spd->block].page = dpage;
400066cc: fa 20 e0 04 st %i5, [ %g3 + 4 ]
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
400066d0: 90 10 00 18 mov %i0, %o0
400066d4: 7f ff fe 61 call 40006058 <rtems_fdisk_queue_segment>
400066d8: 92 10 00 1a mov %i2, %o1
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
400066dc: c8 06 a0 20 ld [ %i2 + 0x20 ], %g4
400066e0: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
400066e4: c6 06 a0 24 ld [ %i2 + 0x24 ], %g3
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
400066e8: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
400066ec: 82 01 00 01 add %g4, %g1, %g1
400066f0: 82 00 40 03 add %g1, %g3, %g1
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
400066f4: 80 a0 80 01 cmp %g2, %g1
400066f8: 02 80 00 07 be 40006714 <rtems_fdisk_recycle_segment+0x3cc>
400066fc: 01 00 00 00 nop
dsc = rtems_fdisk_seg_most_available (&fd->available);
(*pages)--;
40006700: c2 06 c0 00 ld [ %i3 ], %g1
40006704: 82 00 7f ff add %g1, -1, %g1
40006708: c2 26 c0 00 st %g1, [ %i3 ]
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
!rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_USED))
{
4000670c: 10 bf ff 8e b 40006544 <rtems_fdisk_recycle_segment+0x1fc>
40006710: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
dsc = rtems_fdisk_seg_most_available (&fd->available);
40006714: 7f ff fc 8f call 40005950 <rtems_fdisk_seg_most_available>
40006718: d0 07 bf f4 ld [ %fp + -12 ], %o0
4000671c: 10 bf ff f9 b 40006700 <rtems_fdisk_recycle_segment+0x3b8>
40006720: b4 10 00 08 mov %o0, %i2
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
40006724: 7f ff fd a5 call 40005db8 <rtems_fdisk_error> <== NOT EXECUTED
40006728: 90 12 22 18 or %o0, 0x218, %o0 <== NOT EXECUTED
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
4000672c: 7f ff fd c2 call 40005e34 <rtems_fdisk_erase_segment> <== NOT EXECUTED
40006730: 81 e8 00 00 restore <== NOT EXECUTED
dsc,
dpage, dpd);
if (ret)
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
40006734: e0 06 a0 0c ld [ %i2 + 0xc ], %l0 <== NOT EXECUTED
40006738: e4 06 60 0c ld [ %i1 + 0xc ], %l2 <== NOT EXECUTED
4000673c: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
40006740: 40 00 7e d9 call 400262a4 <strerror> <== NOT EXECUTED
40006744: c4 27 bf f0 st %g2, [ %fp + -16 ] <== NOT EXECUTED
40006748: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED
4000674c: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
40006750: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
40006754: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40006758: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4000675c: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
40006760: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
40006764: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
40006768: c4 23 a0 64 st %g2, [ %sp + 0x64 ] <== NOT EXECUTED
4000676c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40006770: 10 bf ff 60 b 400064f0 <rtems_fdisk_recycle_segment+0x1a8><== NOT EXECUTED
40006774: 90 12 21 a8 or %o0, 0x1a8, %o0 <== NOT EXECUTED
{
sc->next = queue->head;
queue->head = sc;
if (queue->tail == 0)
queue->tail = sc;
40006778: 10 bf ff 6a b 40006520 <rtems_fdisk_recycle_segment+0x1d8><== NOT EXECUTED
4000677c: f2 26 20 44 st %i1, [ %i0 + 0x44 ] <== NOT EXECUTED
40006780: 10 bf ff ac b 40006630 <rtems_fdisk_recycle_segment+0x2e8><== NOT EXECUTED
40006784: f2 26 20 44 st %i1, [ %i0 + 0x44 ] <== NOT EXECUTED
40005be4 <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)
{
40005be4: 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;
40005be8: e0 06 60 08 ld [ %i1 + 8 ], %l0
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
40005bec: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
40005bf0: 87 2c 20 04 sll %l0, 4, %g3
uint32_t device;
uint32_t segment;
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
40005bf4: 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;
40005bf8: 83 2c 20 02 sll %l0, 2, %g1
40005bfc: 82 20 c0 01 sub %g3, %g1, %g1
40005c00: 86 00 80 01 add %g2, %g1, %g3
40005c04: c2 00 80 01 ld [ %g2 + %g1 ], %g1
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
40005c08: 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;
40005c0c: 85 2f 60 04 sll %i5, 4, %g2
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
40005c10: e2 00 e0 08 ld [ %g3 + 8 ], %l1
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
40005c14: 87 2f 60 06 sll %i5, 6, %g3
40005c18: 84 20 c0 02 sub %g3, %g2, %g2
40005c1c: 82 00 40 02 add %g1, %g2, %g1
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
40005c20: 94 10 00 10 mov %l0, %o2
40005c24: 96 10 00 1d mov %i5, %o3
40005c28: 98 10 00 1a mov %i2, %o4
40005c2c: 9a 10 00 1c mov %i4, %o5
40005c30: 90 10 00 18 mov %i0, %o0
40005c34: 13 10 00 d4 sethi %hi(0x40035000), %o1
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
40005c38: f0 00 60 04 ld [ %g1 + 4 ], %i0
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
40005c3c: 7f ff ff 85 call 40005a50 <rtems_fdisk_printf>
40005c40: 92 12 63 d8 or %o1, 0x3d8, %o1
device, segment, offset, size);
#endif
ret = ops->write (sd, device, segment, offset, buffer, size);
40005c44: c2 04 60 04 ld [ %l1 + 4 ], %g1
40005c48: 90 10 00 18 mov %i0, %o0
40005c4c: 92 10 00 10 mov %l0, %o1
40005c50: 94 10 00 1d mov %i5, %o2
40005c54: 96 10 00 1a mov %i2, %o3
40005c58: 98 10 00 1b mov %i3, %o4
40005c5c: 9f c0 40 00 call %g1
40005c60: 9a 10 00 1c mov %i4, %o5
if (ret)
40005c64: b0 92 20 00 orcc %o0, 0, %i0
40005c68: 02 80 00 03 be 40005c74 <rtems_fdisk_seg_write+0x90> <== ALWAYS TAKEN
40005c6c: 82 10 20 01 mov 1, %g1
sc->failed = true;
40005c70: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
return ret;
}
40005c74: 81 c7 e0 08 ret
40005c78: 81 e8 00 00 restore
40005cc0 <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)
{
40005cc0: 9d e3 bf a0 save %sp, -96, %sp
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
40005cc4: c2 06 20 08 ld [ %i0 + 8 ], %g1
40005cc8: 80 88 60 08 btst 8, %g1
40005ccc: 22 80 00 0f be,a 40005d08 <rtems_fdisk_seg_write_page+0x48><== NEVER TAKEN
40005cd0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
page * fd->block_size, fd->block_size);
40005cd4: fa 06 20 14 ld [ %i0 + 0x14 ], %i5
static int
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
40005cd8: 90 10 00 1a mov %i2, %o0
40005cdc: 7f ff f2 37 call 400025b8 <.umul>
40005ce0: 92 10 00 1d mov %i5, %o1
40005ce4: 92 10 00 19 mov %i1, %o1
40005ce8: 94 10 00 08 mov %o0, %o2
40005cec: 96 10 00 1d mov %i5, %o3
40005cf0: 7f ff ff 9c call 40005b60 <rtems_fdisk_seg_blank_check>
40005cf4: 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)
40005cf8: 80 a2 20 00 cmp %o0, 0
40005cfc: 12 80 00 0b bne 40005d28 <rtems_fdisk_seg_write_page+0x68><== NEVER TAKEN
40005d00: 01 00 00 00 nop
return ret;
}
--fd->erased_blocks;
40005d04: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
return rtems_fdisk_seg_write (fd, sc,
page * fd->block_size, buffer, fd->block_size);
40005d08: 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;
40005d0c: 82 00 7f ff add %g1, -1, %g1
return rtems_fdisk_seg_write (fd, sc,
40005d10: 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;
40005d14: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
return rtems_fdisk_seg_write (fd, sc,
40005d18: 7f ff f2 28 call 400025b8 <.umul>
40005d1c: 92 10 00 1c mov %i4, %o1
40005d20: 7f ff ff b1 call 40005be4 <rtems_fdisk_seg_write>
40005d24: 95 e8 00 08 restore %g0, %o0, %o2
page * fd->block_size, buffer, fd->block_size);
}
40005d28: 81 c7 e0 08 ret <== NOT EXECUTED
40005d2c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40005c7c <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)
{
40005c7c: 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))
40005c80: c2 06 20 08 ld [ %i0 + 8 ], %g1
40005c84: 80 88 60 08 btst 8, %g1
40005c88: 02 80 00 0a be 40005cb0 <rtems_fdisk_seg_write_page_desc+0x34><== NEVER TAKEN
40005c8c: b5 2e a0 03 sll %i2, 3, %i2
{
int ret = rtems_fdisk_seg_blank_check (fd, sc,
40005c90: 90 10 00 18 mov %i0, %o0
40005c94: 92 10 00 19 mov %i1, %o1
40005c98: 94 10 00 1a mov %i2, %o2
40005c9c: 7f ff ff b1 call 40005b60 <rtems_fdisk_seg_blank_check>
40005ca0: 96 10 20 08 mov 8, %o3
offset,
sizeof (rtems_fdisk_page_desc));
if (ret)
40005ca4: 80 a2 20 00 cmp %o0, 0
40005ca8: 12 80 00 04 bne 40005cb8 <rtems_fdisk_seg_write_page_desc+0x3c><== NEVER TAKEN
40005cac: 01 00 00 00 nop
return ret;
}
return rtems_fdisk_seg_write (fd, sc, offset,
40005cb0: 7f ff ff cd call 40005be4 <rtems_fdisk_seg_write>
40005cb4: 99 e8 20 08 restore %g0, 8, %o4
page_desc, sizeof (rtems_fdisk_page_desc));
}
40005cb8: 81 c7 e0 08 ret <== NOT EXECUTED
40005cbc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40005fb0 <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)
40005fb0: 80 a2 60 00 cmp %o1, 0
40005fb4: 02 80 00 12 be 40005ffc <rtems_fdisk_segment_queue_insert_before+0x4c><== NEVER TAKEN
40005fb8: 80 a2 a0 00 cmp %o2, 0
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
40005fbc: c4 02 00 00 ld [ %o0 ], %g2
while (it)
40005fc0: 80 a0 a0 00 cmp %g2, 0
40005fc4: 02 80 00 0d be 40005ff8 <rtems_fdisk_segment_queue_insert_before+0x48><== NEVER TAKEN
40005fc8: 80 a2 40 02 cmp %o1, %g2
{
if (item == it)
40005fcc: 32 80 00 08 bne,a 40005fec <rtems_fdisk_segment_queue_insert_before+0x3c>
40005fd0: c2 00 80 00 ld [ %g2 ], %g1
rtems_fdisk_segment_ctl* item,
rtems_fdisk_segment_ctl* sc)
{
if (item)
{
rtems_fdisk_segment_ctl** prev = &queue->head;
40005fd4: 10 80 00 18 b 40006034 <rtems_fdisk_segment_queue_insert_before+0x84>
40005fd8: 84 10 00 08 mov %o0, %g2
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
{
if (item == it)
40005fdc: 22 80 00 17 be,a 40006038 <rtems_fdisk_segment_queue_insert_before+0x88><== ALWAYS TAKEN
40005fe0: c2 02 20 08 ld [ %o0 + 8 ], %g1
40005fe4: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED
queue->count++;
return;
}
prev = &it->next;
it = it->next;
40005fe8: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED
if (item)
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
40005fec: 80 a0 60 00 cmp %g1, 0
40005ff0: 12 bf ff fb bne 40005fdc <rtems_fdisk_segment_queue_insert_before+0x2c><== ALWAYS TAKEN
40005ff4: 80 a2 40 01 cmp %o1, %g1
*/
static void
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
40005ff8: 80 a2 a0 00 cmp %o2, 0 <== NOT EXECUTED
40005ffc: 02 80 00 0c be 4000602c <rtems_fdisk_segment_queue_insert_before+0x7c><== NOT EXECUTED
40006000: 01 00 00 00 nop <== NOT EXECUTED
{
sc->next = 0;
if (queue->head)
40006004: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
40006008: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000600c: 02 80 00 10 be 4000604c <rtems_fdisk_segment_queue_insert_before+0x9c><== NOT EXECUTED
40006010: c0 22 80 00 clr [ %o2 ] <== NOT EXECUTED
{
queue->tail->next = sc;
40006014: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED
40006018: d4 20 40 00 st %o2, [ %g1 ] <== NOT EXECUTED
queue->tail = sc;
4000601c: d4 22 20 04 st %o2, [ %o0 + 4 ] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
40006020: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED
40006024: 82 00 60 01 inc %g1 <== NOT EXECUTED
40006028: c2 22 20 08 st %g1, [ %o0 + 8 ] <== NOT EXECUTED
4000602c: 81 c3 e0 08 retl <== NOT EXECUTED
40006030: 01 00 00 00 nop <== NOT EXECUTED
{
if (item == it)
{
sc->next = item;
*prev = sc;
queue->count++;
40006034: c2 02 20 08 ld [ %o0 + 8 ], %g1
while (it)
{
if (item == it)
{
sc->next = item;
40006038: d2 22 80 00 st %o1, [ %o2 ]
*prev = sc;
4000603c: d4 20 80 00 st %o2, [ %g2 ]
queue->count++;
40006040: 82 00 60 01 inc %g1
return;
40006044: 81 c3 e0 08 retl
40006048: c2 22 20 08 st %g1, [ %o0 + 8 ]
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
4000604c: d4 22 20 04 st %o2, [ %o0 + 4 ] <== NOT EXECUTED
40006050: 10 bf ff f4 b 40006020 <rtems_fdisk_segment_queue_insert_before+0x70><== NOT EXECUTED
40006054: d4 22 00 00 st %o2, [ %o0 ] <== NOT EXECUTED
400057cc <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;
400057cc: c4 02 00 00 ld [ %o0 ], %g2
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
400057d0: 80 a0 a0 00 cmp %g2, 0
400057d4: 02 80 00 0d be 40005808 <rtems_fdisk_segment_queue_remove+0x3c>
400057d8: 80 a0 80 09 cmp %g2, %o1
{
if (sc == it)
400057dc: 32 80 00 08 bne,a 400057fc <rtems_fdisk_segment_queue_remove+0x30>
400057e0: c2 00 80 00 ld [ %g2 ], %g1
{
if (prev == 0)
{
queue->head = sc->next;
400057e4: 10 80 00 16 b 4000583c <rtems_fdisk_segment_queue_remove+0x70>
400057e8: c2 02 40 00 ld [ %o1 ], %g1
* Do not change sc->next as sc could be on another queue.
*/
while (it)
{
if (sc == it)
400057ec: 22 80 00 09 be,a 40005810 <rtems_fdisk_segment_queue_remove+0x44>
400057f0: c6 02 40 00 ld [ %o1 ], %g3
400057f4: 84 10 00 01 mov %g1, %g2
queue->count--;
break;
}
prev = it;
it = it->next;
400057f8: c2 00 80 00 ld [ %g2 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
400057fc: 80 a0 60 00 cmp %g1, 0
40005800: 12 bf ff fb bne 400057ec <rtems_fdisk_segment_queue_remove+0x20>
40005804: 80 a2 40 01 cmp %o1, %g1
40005808: 81 c3 e0 08 retl
4000580c: 01 00 00 00 nop
queue->tail = 0;
}
else
{
prev->next = sc->next;
if (queue->tail == sc)
40005810: c2 02 20 04 ld [ %o0 + 4 ], %g1
40005814: 80 a0 40 09 cmp %g1, %o1
40005818: 02 80 00 07 be 40005834 <rtems_fdisk_segment_queue_remove+0x68><== ALWAYS TAKEN
4000581c: c6 20 80 00 st %g3, [ %g2 ]
queue->tail = prev;
}
sc->next = 0;
queue->count--;
40005820: c2 02 20 08 ld [ %o0 + 8 ], %g1
{
prev->next = sc->next;
if (queue->tail == sc)
queue->tail = prev;
}
sc->next = 0;
40005824: c0 22 40 00 clr [ %o1 ]
queue->count--;
40005828: 82 00 7f ff add %g1, -1, %g1
break;
4000582c: 81 c3 e0 08 retl
40005830: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
else
{
prev->next = sc->next;
if (queue->tail == sc)
queue->tail = prev;
40005834: 10 bf ff fb b 40005820 <rtems_fdisk_segment_queue_remove+0x54>
40005838: c4 22 20 04 st %g2, [ %o0 + 4 ]
if (sc == it)
{
if (prev == 0)
{
queue->head = sc->next;
if (queue->head == 0)
4000583c: 80 a0 60 00 cmp %g1, 0
40005840: 12 bf ff f8 bne 40005820 <rtems_fdisk_segment_queue_remove+0x54>
40005844: c2 22 00 00 st %g1, [ %o0 ]
queue->tail = 0;
40005848: 10 bf ff f6 b 40005820 <rtems_fdisk_segment_queue_remove+0x54>
4000584c: c0 22 20 04 clr [ %o0 + 4 ]
40005d30 <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, ...)
{
40005d30: 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);
40005d34: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40005d38: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
40005d3c: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
40005d40: 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)
40005d44: c2 06 20 6c ld [ %i0 + 0x6c ], %g1 <== NOT EXECUTED
40005d48: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005d4c: 02 80 00 19 be 40005db0 <rtems_fdisk_warning+0x80> <== NOT EXECUTED
40005d50: b0 10 20 00 clr %i0 <== NOT EXECUTED
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
40005d54: 3b 10 00 e9 sethi %hi(0x4003a400), %i5 <== NOT EXECUTED
40005d58: c2 07 61 78 ld [ %i5 + 0x178 ], %g1 ! 4003a578 <_impure_ptr><== NOT EXECUTED
40005d5c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40005d60: d6 00 60 08 ld [ %g1 + 8 ], %o3 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
40005d64: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
40005d68: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
40005d6c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
40005d70: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED
40005d74: 40 00 7b 6d call 40024b28 <fwrite> <== NOT EXECUTED
40005d78: 90 12 20 00 mov %o0, %o0 ! 40035400 <Callbacks.6428+0x1b8><== NOT EXECUTED
ret = vfprintf (stdout, format, args);
40005d7c: c2 07 61 78 ld [ %i5 + 0x178 ], %g1 <== NOT EXECUTED
40005d80: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
40005d84: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
40005d88: 40 00 9c cd call 4002d0bc <vfprintf> <== NOT EXECUTED
40005d8c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
40005d90: c2 07 61 78 ld [ %i5 + 0x178 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
ret = vfprintf (stdout, format, args);
40005d94: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
40005d98: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
40005d9c: 40 00 79 82 call 400243a4 <fputc> <== NOT EXECUTED
40005da0: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
40005da4: c2 07 61 78 ld [ %i5 + 0x178 ], %g1 <== NOT EXECUTED
40005da8: 40 00 78 67 call 40023f44 <fflush> <== NOT EXECUTED
40005dac: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
40005db0: 81 c7 e0 08 ret <== NOT EXECUTED
40005db4: 81 e8 00 00 restore <== NOT EXECUTED
4000d510 <rtems_filesystem_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
4000d510: 9d e3 bf a0 save %sp, -96, %sp
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = geteuid();
4000d514: 7f ff fe fa call 4000d0fc <geteuid>
4000d518: b0 0e 20 07 and %i0, 7, %i0
if (task_uid == 0 || task_uid == node_uid) {
4000d51c: 91 2a 20 10 sll %o0, 0x10, %o0
4000d520: 91 32 20 10 srl %o0, 0x10, %o0
4000d524: 80 a2 00 1a cmp %o0, %i2
4000d528: 12 80 00 08 bne 4000d548 <rtems_filesystem_check_access+0x38>
4000d52c: 80 a2 20 00 cmp %o0, 0
perm_flags <<= RTEMS_FS_USR_SHIFT;
4000d530: b1 2e 20 06 sll %i0, 6, %i0
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
4000d534: b0 2e 00 19 andn %i0, %i1, %i0
}
4000d538: 80 a0 00 18 cmp %g0, %i0
4000d53c: b0 60 3f ff subx %g0, -1, %i0
4000d540: 81 c7 e0 08 ret
4000d544: 81 e8 00 00 restore
)
{
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = geteuid();
if (task_uid == 0 || task_uid == node_uid) {
4000d548: 22 bf ff fb be,a 4000d534 <rtems_filesystem_check_access+0x24>
4000d54c: b1 2e 20 06 sll %i0, 6, %i0
perm_flags <<= RTEMS_FS_USR_SHIFT;
} else {
gid_t task_gid = getegid();
4000d550: 7f ff fe e7 call 4000d0ec <getegid>
4000d554: 01 00 00 00 nop
if (task_gid == 0 || task_gid == node_gid) {
4000d558: 91 2a 20 10 sll %o0, 0x10, %o0
4000d55c: 91 32 20 10 srl %o0, 0x10, %o0
4000d560: 80 a2 00 1b cmp %o0, %i3
4000d564: 12 80 00 08 bne 4000d584 <rtems_filesystem_check_access+0x74>
4000d568: 80 a2 20 00 cmp %o0, 0
perm_flags <<= RTEMS_FS_GRP_SHIFT;
4000d56c: b1 2e 20 03 sll %i0, 3, %i0
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
4000d570: b0 2e 00 19 andn %i0, %i1, %i0
}
4000d574: 80 a0 00 18 cmp %g0, %i0
4000d578: b0 60 3f ff subx %g0, -1, %i0
4000d57c: 81 c7 e0 08 ret
4000d580: 81 e8 00 00 restore
if (task_uid == 0 || task_uid == node_uid) {
perm_flags <<= RTEMS_FS_USR_SHIFT;
} else {
gid_t task_gid = getegid();
if (task_gid == 0 || task_gid == node_gid) {
4000d584: 32 bf ff ed bne,a 4000d538 <rtems_filesystem_check_access+0x28><== ALWAYS TAKEN
4000d588: b0 2e 00 19 andn %i0, %i1, %i0
perm_flags <<= RTEMS_FS_GRP_SHIFT;
4000d58c: 10 bf ff f9 b 4000d570 <rtems_filesystem_check_access+0x60><== NOT EXECUTED
4000d590: b1 2e 20 03 sll %i0, 3, %i0 <== NOT EXECUTED
40005730 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40005730: 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 );
40005734: 3b 10 00 80 sethi %hi(0x40020000), %i5
40005738: d0 07 61 2c ld [ %i5 + 0x12c ], %o0 ! 4002012c <rtems_libio_semaphore>
4000573c: 92 10 20 00 clr %o1
40005740: 40 00 0b 93 call 4000858c <rtems_semaphore_obtain>
40005744: 94 10 20 00 clr %o2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40005748: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
4000574c: c2 06 20 04 ld [ %i0 + 4 ], %g1
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
40005750: d0 07 61 2c ld [ %i5 + 0x12c ], %o0
next->previous = previous;
40005754: c2 20 a0 04 st %g1, [ %g2 + 4 ]
40005758: 40 00 0b dc call 400086c8 <rtems_semaphore_release>
4000575c: 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);
40005760: 40 00 00 6d call 40005914 <rtems_filesystem_global_location_release>
40005764: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
(*mt_entry->ops->fsunmount_me_h)(mt_entry);
40005768: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000576c: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
40005770: 9f c0 40 00 call %g1
40005774: 90 10 00 18 mov %i0, %o0
if (mt_entry->unmount_task != 0) {
40005778: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
4000577c: 80 a2 20 00 cmp %o0, 0
40005780: 02 80 00 07 be 4000579c <rtems_filesystem_do_unmount+0x6c><== NEVER TAKEN
40005784: 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 );
40005788: 40 00 0b fb call 40008774 <rtems_event_system_send>
4000578c: 13 20 00 00 sethi %hi(0x80000000), %o1
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
40005790: 80 a2 20 00 cmp %o0, 0
40005794: 32 80 00 04 bne,a 400057a4 <rtems_filesystem_do_unmount+0x74><== NEVER TAKEN
40005798: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
4000579c: 7f ff fa 9b call 40004208 <free>
400057a0: 81 e8 00 00 restore
if (mt_entry->unmount_task != 0) {
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
400057a4: 40 00 0d 5f call 40008d20 <rtems_fatal_error_occurred> <== NOT EXECUTED
400057a8: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
4000d7c0 <rtems_filesystem_eval_path_eat_delimiter>:
void rtems_filesystem_eval_path_eat_delimiter(
rtems_filesystem_eval_path_context_t *ctx
)
{
const char *current = ctx->path;
4000d7c0: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
4000d7c4: c6 02 20 04 ld [ %o0 + 4 ], %g3
4000d7c8: 86 00 40 03 add %g1, %g3, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
4000d7cc: 80 a0 40 03 cmp %g1, %g3
4000d7d0: 32 80 00 08 bne,a 4000d7f0 <rtems_filesystem_eval_path_eat_delimiter+0x30><== ALWAYS TAKEN
4000d7d4: c4 48 40 00 ldsb [ %g1 ], %g2
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000d7d8: 10 80 00 0d b 4000d80c <rtems_filesystem_eval_path_eat_delimiter+0x4c><== NOT EXECUTED
4000d7dc: 86 20 c0 01 sub %g3, %g1, %g3 <== NOT EXECUTED
)
{
const char *current = ctx->path;
const char *end = current + ctx->pathlen;
while (current != end && rtems_filesystem_is_delimiter(*current)) {
4000d7e0: 80 a0 c0 01 cmp %g3, %g1
4000d7e4: 22 80 00 0a be,a 4000d80c <rtems_filesystem_eval_path_eat_delimiter+0x4c>
4000d7e8: 86 20 c0 01 sub %g3, %g1, %g3
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
4000d7ec: c4 48 40 00 ldsb [ %g1 ], %g2
4000d7f0: 80 a0 a0 5c cmp %g2, 0x5c
4000d7f4: 22 bf ff fb be,a 4000d7e0 <rtems_filesystem_eval_path_eat_delimiter+0x20>
4000d7f8: 82 00 60 01 inc %g1
4000d7fc: 80 a0 a0 2f cmp %g2, 0x2f
4000d800: 22 bf ff f8 be,a 4000d7e0 <rtems_filesystem_eval_path_eat_delimiter+0x20>
4000d804: 82 00 60 01 inc %g1
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000d808: 86 20 c0 01 sub %g3, %g1, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
4000d80c: c2 22 00 00 st %g1, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
4000d810: 81 c3 e0 08 retl
4000d814: c6 22 20 04 st %g3, [ %o0 + 4 ]
4000d5c8 <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
)
{
4000d5c8: 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);
4000d5cc: 03 10 00 79 sethi %hi(0x4001e400), %g1
rtems_filesystem_eval_path_error(ctx, EINVAL);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
rtems_filesystem_location_info_t *currentloc =
4000d5d0: b6 06 20 18 add %i0, 0x18, %i3
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
4000d5d4: a2 10 61 c8 or %g1, 0x1c8, %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);
4000d5d8: 03 10 00 77 sethi %hi(0x4001dc00), %g1
4000d5dc: a0 10 63 90 or %g1, 0x390, %l0 ! 4001df90 <rtems_filesystem_default_pathconf+0x3c>
rtems_filesystem_eval_path_context_t *ctx,
const char **token,
size_t *tokenlen
)
{
rtems_filesystem_eval_path_next_token(ctx);
4000d5e0: 40 00 00 8e call 4000d818 <rtems_filesystem_eval_path_next_token>
4000d5e4: 90 10 00 18 mov %i0, %o0
*token = ctx->token;
*tokenlen = ctx->tokenlen;
4000d5e8: fa 06 20 0c ld [ %i0 + 0xc ], %i5
const char *token;
size_t tokenlen;
rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
if (tokenlen > 0) {
4000d5ec: 80 a7 60 00 cmp %i5, 0
4000d5f0: 02 80 00 18 be 4000d650 <rtems_filesystem_eval_path_generic+0x88>
4000d5f4: f8 06 20 08 ld [ %i0 + 8 ], %i4
if ((*config->is_directory)(ctx, arg)) {
4000d5f8: c2 06 80 00 ld [ %i2 ], %g1
4000d5fc: 90 10 00 18 mov %i0, %o0
4000d600: 9f c0 40 00 call %g1
4000d604: 92 10 00 19 mov %i1, %o1
4000d608: 80 8a 20 ff btst 0xff, %o0
4000d60c: 02 80 00 13 be 4000d658 <rtems_filesystem_eval_path_generic+0x90>
4000d610: 80 a7 60 01 cmp %i5, 1
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
4000d614: 02 80 00 23 be 4000d6a0 <rtems_filesystem_eval_path_generic+0xd8>
4000d618: 80 a7 60 02 cmp %i5, 2
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
4000d61c: 22 80 00 2f be,a 4000d6d8 <rtems_filesystem_eval_path_generic+0x110>
4000d620: c2 4f 00 00 ldsb [ %i4 ], %g1
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
4000d624: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000d628: 90 10 00 18 mov %i0, %o0
4000d62c: 92 10 00 19 mov %i1, %o1
4000d630: 94 10 00 1c mov %i4, %o2
4000d634: 9f c0 40 00 call %g1
4000d638: 96 10 00 1d mov %i5, %o3
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
4000d63c: 80 a2 20 02 cmp %o0, 2
4000d640: 02 80 00 08 be 4000d660 <rtems_filesystem_eval_path_generic+0x98>
4000d644: 80 a2 20 00 cmp %o0, 0
)
{
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
4000d648: 02 bf ff e6 be 4000d5e0 <rtems_filesystem_eval_path_generic+0x18>
4000d64c: 01 00 00 00 nop
4000d650: 81 c7 e0 08 ret
4000d654: 81 e8 00 00 restore
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
4000d658: 7f ff de c5 call 4000516c <rtems_filesystem_eval_path_error>
4000d65c: 93 e8 20 14 restore %g0, 0x14, %o1
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
if (rtems_filesystem_eval_path_has_path(ctx)) {
4000d660: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000d664: 80 a0 60 00 cmp %g1, 0
4000d668: 02 bf ff fa be 4000d650 <rtems_filesystem_eval_path_generic+0x88>
4000d66c: 01 00 00 00 nop
int eval_flags;
rtems_filesystem_eval_path_eat_delimiter(ctx);
4000d670: 40 00 00 54 call 4000d7c0 <rtems_filesystem_eval_path_eat_delimiter>
4000d674: 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
4000d678: 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 (
4000d67c: 80 88 60 80 btst 0x80, %g1
4000d680: 02 80 00 06 be 4000d698 <rtems_filesystem_eval_path_generic+0xd0>
4000d684: 01 00 00 00 nop
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
|| rtems_filesystem_eval_path_has_path(ctx)
4000d688: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000d68c: 80 a0 60 00 cmp %g1, 0
4000d690: 02 bf ff f0 be 4000d650 <rtems_filesystem_eval_path_generic+0x88>
4000d694: 01 00 00 00 nop
) {
rtems_filesystem_eval_path_error(ctx, ENOENT);
4000d698: 7f ff de b5 call 4000516c <rtems_filesystem_eval_path_error>
4000d69c: 93 e8 20 02 restore %g0, 2, %o1
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
4000d6a0: c2 4f 00 00 ldsb [ %i4 ], %g1
4000d6a4: 80 a0 60 2e cmp %g1, 0x2e
4000d6a8: 32 bf ff e0 bne,a 4000d628 <rtems_filesystem_eval_path_generic+0x60>
4000d6ac: c2 06 a0 04 ld [ %i2 + 4 ], %g1
rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
if (tokenlen > 0) {
if ((*config->is_directory)(ctx, arg)) {
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
if (rtems_filesystem_eval_path_has_path(ctx)) {
4000d6b0: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000d6b4: 80 a0 60 00 cmp %g1, 0
4000d6b8: 32 80 00 2c bne,a 4000d768 <rtems_filesystem_eval_path_generic+0x1a0>
4000d6bc: c2 06 a0 04 ld [ %i2 + 4 ], %g1
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
4000d6c0: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
4000d6c4: 80 88 a1 00 btst 0x100, %g2
4000d6c8: 22 80 00 28 be,a 4000d768 <rtems_filesystem_eval_path_generic+0x1a0>
4000d6cc: c2 06 a0 04 ld [ %i2 + 4 ], %g1
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
rtems_filesystem_eval_path_error(ctx, EINVAL);
4000d6d0: 7f ff de a7 call 4000516c <rtems_filesystem_eval_path_error>
4000d6d4: 93 e8 20 16 restore %g0, 0x16, %o1
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
4000d6d8: 80 a0 60 2e cmp %g1, 0x2e
4000d6dc: 32 bf ff d3 bne,a 4000d628 <rtems_filesystem_eval_path_generic+0x60>
4000d6e0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000d6e4: c2 4f 20 01 ldsb [ %i4 + 1 ], %g1
4000d6e8: 80 a0 60 2e cmp %g1, 0x2e
4000d6ec: 32 bf ff cf bne,a 4000d628 <rtems_filesystem_eval_path_generic+0x60><== NEVER TAKEN
4000d6f0: c2 06 a0 04 ld [ %i2 + 4 ], %g1 <== NOT EXECUTED
const rtems_filesystem_eval_path_context_t *ctx,
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
4000d6f4: 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;
4000d6f8: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
return mt_entry == rootloc->mt_entry
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
4000d6fc: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
4000d700: 80 a0 80 01 cmp %g2, %g1
4000d704: 22 80 00 27 be,a 4000d7a0 <rtems_filesystem_eval_path_generic+0x1d8>
4000d708: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *mt_fs_root =
&mt_entry->mt_fs_root->location;
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
4000d70c: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
4000d710: d2 00 a0 24 ld [ %g2 + 0x24 ], %o1
4000d714: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000d718: 9f c0 40 00 call %g1
4000d71c: 90 10 00 1b mov %i3, %o0
rtems_filesystem_eval_path_get_currentloc( ctx );
if (is_eval_path_root(ctx, currentloc)) {
/* This prevents the escape from a chroot() environment */
status = (*config->eval_token)(ctx, arg, ".", 1);
} else if (is_fs_root(currentloc)) {
4000d720: 80 8a 20 ff btst 0xff, %o0
4000d724: 22 80 00 18 be,a 4000d784 <rtems_filesystem_eval_path_generic+0x1bc>
4000d728: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (currentloc->mt_entry->mt_point_node != NULL) {
4000d72c: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
4000d730: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
4000d734: 80 a0 a0 00 cmp %g2, 0
4000d738: 22 80 00 0c be,a 4000d768 <rtems_filesystem_eval_path_generic+0x1a0><== NEVER TAKEN
4000d73c: 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;
4000d740: c4 06 20 0c ld [ %i0 + 0xc ], %g2
ctx->path -= tokenlen;
4000d744: c6 06 00 00 ld [ %i0 ], %g3
ctx->pathlen += tokenlen;
4000d748: c8 06 20 04 ld [ %i0 + 4 ], %g4
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
4000d74c: 86 20 c0 02 sub %g3, %g2, %g3
ctx->pathlen += tokenlen;
ctx->tokenlen = 0;
4000d750: c0 26 20 0c clr [ %i0 + 0xc ]
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
ctx->pathlen += tokenlen;
4000d754: 84 01 00 02 add %g4, %g2, %g2
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
4000d758: c6 26 00 00 st %g3, [ %i0 ]
ctx->pathlen += tokenlen;
4000d75c: c4 26 20 04 st %g2, [ %i0 + 4 ]
rtems_filesystem_eval_path_put_back_token(ctx);
rtems_filesystem_eval_path_restart(
4000d760: 7f ff df 92 call 400055a8 <rtems_filesystem_eval_path_restart>
4000d764: 93 e8 60 20 restore %g1, 0x20, %o1
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc( ctx );
if (is_eval_path_root(ctx, currentloc)) {
/* This prevents the escape from a chroot() environment */
status = (*config->eval_token)(ctx, arg, ".", 1);
4000d768: 90 10 00 18 mov %i0, %o0
4000d76c: 92 10 00 19 mov %i1, %o1
4000d770: 94 10 00 10 mov %l0, %o2
4000d774: 9f c0 40 00 call %g1
4000d778: 96 10 20 01 mov 1, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
4000d77c: 10 bf ff b1 b 4000d640 <rtems_filesystem_eval_path_generic+0x78>
4000d780: 80 a2 20 02 cmp %o0, 2
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
4000d784: 90 10 00 18 mov %i0, %o0
4000d788: 92 10 00 19 mov %i1, %o1
4000d78c: 94 10 00 11 mov %l1, %o2
4000d790: 9f c0 40 00 call %g1
4000d794: 96 10 20 02 mov 2, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
4000d798: 10 bf ff aa b 4000d640 <rtems_filesystem_eval_path_generic+0x78>
4000d79c: 80 a2 20 02 cmp %o0, 2
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
return mt_entry == rootloc->mt_entry
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
4000d7a0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000d7a4: 9f c0 40 00 call %g1
4000d7a8: 90 10 00 1b mov %i3, %o0
4000d7ac: 80 8a 20 ff btst 0xff, %o0
4000d7b0: 32 bf ff ee bne,a 4000d768 <rtems_filesystem_eval_path_generic+0x1a0>
4000d7b4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000d7b8: 10 bf ff d5 b 4000d70c <rtems_filesystem_eval_path_generic+0x144>
4000d7bc: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
4000d818 <rtems_filesystem_eval_path_next_token>:
void rtems_filesystem_eval_path_eat_delimiter(
rtems_filesystem_eval_path_context_t *ctx
)
{
const char *current = ctx->path;
4000d818: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
4000d81c: c8 02 20 04 ld [ %o0 + 4 ], %g4
4000d820: 88 00 40 04 add %g1, %g4, %g4
while (current != end && rtems_filesystem_is_delimiter(*current)) {
4000d824: 80 a0 40 04 cmp %g1, %g4
4000d828: 22 80 00 10 be,a 4000d868 <rtems_filesystem_eval_path_next_token+0x50>
4000d82c: 88 21 00 01 sub %g4, %g1, %g4
4000d830: c4 48 40 00 ldsb [ %g1 ], %g2
4000d834: 80 a0 a0 2f cmp %g2, 0x2f
4000d838: 22 80 00 08 be,a 4000d858 <rtems_filesystem_eval_path_next_token+0x40>
4000d83c: 82 00 60 01 inc %g1
4000d840: 10 80 00 38 b 4000d920 <rtems_filesystem_eval_path_next_token+0x108>
4000d844: 80 a0 a0 5c cmp %g2, 0x5c
4000d848: 80 a0 a0 5c cmp %g2, 0x5c
4000d84c: 12 80 00 26 bne 4000d8e4 <rtems_filesystem_eval_path_next_token+0xcc>
4000d850: 80 a0 a0 2f cmp %g2, 0x2f
++current;
4000d854: 82 00 60 01 inc %g1
)
{
const char *current = ctx->path;
const char *end = current + ctx->pathlen;
while (current != end && rtems_filesystem_is_delimiter(*current)) {
4000d858: 80 a1 00 01 cmp %g4, %g1
4000d85c: 32 bf ff fb bne,a 4000d848 <rtems_filesystem_eval_path_next_token+0x30>
4000d860: c4 48 40 00 ldsb [ %g1 ], %g2
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000d864: 88 21 00 01 sub %g4, %g1, %g4
while (current != end && rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
4000d868: c2 22 00 00 st %g1, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
4000d86c: c8 22 20 04 st %g4, [ %o0 + 4 ]
}
static void next_token(rtems_filesystem_eval_path_context_t *ctx)
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
4000d870: 88 00 40 04 add %g1, %g4, %g4
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
4000d874: 80 a1 00 01 cmp %g4, %g1
4000d878: 02 80 00 27 be 4000d914 <rtems_filesystem_eval_path_next_token+0xfc>
4000d87c: 9a 10 00 01 mov %g1, %o5
4000d880: c4 48 40 00 ldsb [ %g1 ], %g2
4000d884: 80 a0 a0 5c cmp %g2, 0x5c
4000d888: 02 80 00 23 be 4000d914 <rtems_filesystem_eval_path_next_token+0xfc><== NEVER TAKEN
4000d88c: 80 a0 a0 2f cmp %g2, 0x2f
4000d890: 02 80 00 22 be 4000d918 <rtems_filesystem_eval_path_next_token+0x100><== NEVER TAKEN
4000d894: 84 10 00 01 mov %g1, %g2
++current;
4000d898: 10 80 00 08 b 4000d8b8 <rtems_filesystem_eval_path_next_token+0xa0>
4000d89c: 84 00 a0 01 inc %g2
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
4000d8a0: 80 a0 e0 5c cmp %g3, 0x5c
4000d8a4: 02 80 00 14 be 4000d8f4 <rtems_filesystem_eval_path_next_token+0xdc>
4000d8a8: 80 a0 e0 2f cmp %g3, 0x2f
4000d8ac: 02 80 00 13 be 4000d8f8 <rtems_filesystem_eval_path_next_token+0xe0>
4000d8b0: 9a 10 00 02 mov %g2, %o5
++current;
4000d8b4: 84 00 a0 01 inc %g2
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
4000d8b8: 80 a1 00 02 cmp %g4, %g2
4000d8bc: 32 bf ff f9 bne,a 4000d8a0 <rtems_filesystem_eval_path_next_token+0x88>
4000d8c0: c6 48 80 00 ldsb [ %g2 ], %g3
4000d8c4: 9a 10 00 04 mov %g4, %o5
4000d8c8: 86 21 00 01 sub %g4, %g1, %g3
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000d8cc: 88 21 00 0d sub %g4, %o5, %g4
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
4000d8d0: c4 22 00 00 st %g2, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
4000d8d4: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->token = begin;
4000d8d8: c2 22 20 08 st %g1, [ %o0 + 8 ]
ctx->tokenlen = (size_t) (current - begin);
4000d8dc: 81 c3 e0 08 retl
4000d8e0: c6 22 20 0c st %g3, [ %o0 + 0xc ]
)
{
const char *current = ctx->path;
const char *end = current + ctx->pathlen;
while (current != end && rtems_filesystem_is_delimiter(*current)) {
4000d8e4: 22 bf ff dd be,a 4000d858 <rtems_filesystem_eval_path_next_token+0x40>
4000d8e8: 82 00 60 01 inc %g1
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000d8ec: 10 bf ff df b 4000d868 <rtems_filesystem_eval_path_next_token+0x50>
4000d8f0: 88 21 00 01 sub %g4, %g1, %g4
4000d8f4: 9a 10 00 02 mov %g2, %o5
4000d8f8: 86 20 80 01 sub %g2, %g1, %g3
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000d8fc: 88 21 00 0d sub %g4, %o5, %g4
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
4000d900: c4 22 00 00 st %g2, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
4000d904: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->token = begin;
4000d908: c2 22 20 08 st %g1, [ %o0 + 8 ]
ctx->tokenlen = (size_t) (current - begin);
4000d90c: 81 c3 e0 08 retl
4000d910: c6 22 20 0c st %g3, [ %o0 + 0xc ]
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
4000d914: 84 10 00 01 mov %g1, %g2
4000d918: 10 bf ff ed b 4000d8cc <rtems_filesystem_eval_path_next_token+0xb4>
4000d91c: 86 10 20 00 clr %g3
)
{
const char *current = ctx->path;
const char *end = current + ctx->pathlen;
while (current != end && rtems_filesystem_is_delimiter(*current)) {
4000d920: 22 bf ff ce be,a 4000d858 <rtems_filesystem_eval_path_next_token+0x40>
4000d924: 82 00 60 01 inc %g1
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000d928: 10 bf ff d0 b 4000d868 <rtems_filesystem_eval_path_next_token+0x50>
4000d92c: 88 21 00 01 sub %g4, %g1, %g4
4000560c <rtems_filesystem_eval_path_recursive>:
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
4000560c: 9d e3 bf a0 save %sp, -96, %sp
if (pathlen > 0) {
40005610: 80 a6 a0 00 cmp %i2, 0
40005614: 02 80 00 22 be 4000569c <rtems_filesystem_eval_path_recursive+0x90><== NEVER TAKEN
40005618: ba 10 00 18 mov %i0, %i5
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
4000561c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40005620: 80 a0 60 1f cmp %g1, 0x1f
40005624: 14 80 00 25 bg 400056b8 <rtems_filesystem_eval_path_recursive+0xac>
40005628: 01 00 00 00 nop
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
4000562c: c4 4e 40 00 ldsb [ %i1 ], %g2
const char *saved_path = ctx->path;
40005630: f6 06 00 00 ld [ %i0 ], %i3
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
40005634: 80 a0 a0 5c cmp %g2, 0x5c
40005638: 02 80 00 1b be 400056a4 <rtems_filesystem_eval_path_recursive+0x98><== NEVER TAKEN
4000563c: f8 06 20 04 ld [ %i0 + 4 ], %i4
40005640: 80 a0 a0 2f cmp %g2, 0x2f
40005644: 02 80 00 19 be 400056a8 <rtems_filesystem_eval_path_recursive+0x9c>
40005648: 90 10 00 1d mov %i5, %o0
}
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
4000564c: 82 00 60 01 inc %g1
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
}
ctx->path = path;
40005650: f2 27 40 00 st %i1, [ %i5 ]
ctx->pathlen = pathlen;
40005654: f4 27 60 04 st %i2, [ %i5 + 4 ]
++ctx->recursionlevel;
40005658: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
4000565c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40005660: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40005664: c2 00 60 08 ld [ %g1 + 8 ], %g1
40005668: 9f c0 40 00 call %g1
4000566c: 90 10 00 1d mov %i5, %o0
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
40005670: c2 07 60 04 ld [ %i5 + 4 ], %g1
40005674: 80 a0 60 00 cmp %g1, 0
40005678: 32 bf ff fa bne,a 40005660 <rtems_filesystem_eval_path_recursive+0x54>
4000567c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
40005680: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
ctx->path = saved_path;
40005684: f6 27 40 00 st %i3, [ %i5 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
40005688: 82 00 7f ff add %g1, -1, %g1
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
4000568c: 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;
40005690: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
40005694: 81 c7 e0 08 ret
40005698: 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);
4000569c: 7f ff fe b4 call 4000516c <rtems_filesystem_eval_path_error><== NOT EXECUTED
400056a0: 93 e8 20 02 restore %g0, 2, %o1 <== NOT EXECUTED
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
const char *saved_path = ctx->path;
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
400056a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400056a8: 7f ff ff c0 call 400055a8 <rtems_filesystem_eval_path_restart>
400056ac: 92 07 60 30 add %i5, 0x30, %o1
400056b0: 10 bf ff e7 b 4000564c <rtems_filesystem_eval_path_recursive+0x40>
400056b4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
--ctx->recursionlevel;
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
400056b8: 7f ff fe ad call 4000516c <rtems_filesystem_eval_path_error>
400056bc: 93 e8 20 5c restore %g0, 0x5c, %o1
40005474 <rtems_filesystem_eval_path_start_with_parent>:
const char *path,
int eval_flags,
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
40005474: 9d e3 bf a0 save %sp, -96, %sp
size_t pathlen = strlen(path);
40005478: 40 00 32 97 call 40011ed4 <strlen>
4000547c: 90 10 00 19 mov %i1, %o0
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
40005480: 80 a2 20 00 cmp %o0, 0
40005484: 02 80 00 32 be 4000554c <rtems_filesystem_eval_path_start_with_parent+0xd8>
40005488: 92 10 00 19 mov %i1, %o1
size_t i = pathlen - 1;
4000548c: 94 02 3f ff add %o0, -1, %o2
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
40005490: c2 4e 40 0a ldsb [ %i1 + %o2 ], %g1
if (rtems_filesystem_is_delimiter(path [i])) {
40005494: 80 a0 60 5c cmp %g1, 0x5c
40005498: 02 80 00 2a be 40005540 <rtems_filesystem_eval_path_start_with_parent+0xcc><== NEVER TAKEN
4000549c: 80 a0 60 2f cmp %g1, 0x2f
400054a0: 12 80 00 08 bne 400054c0 <rtems_filesystem_eval_path_start_with_parent+0x4c>
400054a4: 80 a2 a0 00 cmp %o2, 0
400054a8: 10 80 00 27 b 40005544 <rtems_filesystem_eval_path_start_with_parent+0xd0>
400054ac: 94 10 00 08 mov %o0, %o2
400054b0: 02 80 00 0b be 400054dc <rtems_filesystem_eval_path_start_with_parent+0x68>
400054b4: a0 22 00 0a sub %o0, %o2, %l0
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
size_t i = pathlen - 1;
400054b8: 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) {
400054bc: 80 a2 a0 00 cmp %o2, 0
400054c0: 02 80 00 1a be 40005528 <rtems_filesystem_eval_path_start_with_parent+0xb4>
400054c4: 82 02 bf ff add %o2, -1, %g1
400054c8: c4 4e 40 01 ldsb [ %i1 + %g1 ], %g2
size_t i = pathlen - 1;
if (rtems_filesystem_is_delimiter(path [i])) {
400054cc: 80 a0 a0 5c cmp %g2, 0x5c
400054d0: 12 bf ff f8 bne 400054b0 <rtems_filesystem_eval_path_start_with_parent+0x3c><== ALWAYS TAKEN
400054d4: 80 a0 a0 2f cmp %g2, 0x2f
400054d8: a0 22 00 0a sub %o0, %o2, %l0 <== NOT EXECUTED
parentpath = ".";
parentpathlen = 1;
name = path;
namelen = pathlen;
} else {
name = path + parentpathlen;
400054dc: 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;
400054e0: 92 10 00 19 mov %i1, %o1
currentloc = eval_path_start(
ctx,
parentpath,
parentpathlen,
parent_eval_flags,
&rtems_filesystem_root,
400054e4: 03 10 00 7d sethi %hi(0x4001f400), %g1
400054e8: da 00 61 f0 ld [ %g1 + 0x1f0 ], %o5 ! 4001f5f0 <rtems_current_user_env>
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
}
}
currentloc = eval_path_start(
400054ec: 96 10 00 1c mov %i4, %o3
400054f0: 98 03 60 04 add %o5, 4, %o4
400054f4: 7f ff ff 7a call 400052dc <eval_path_start>
400054f8: 90 10 00 18 mov %i0, %o0
400054fc: 92 10 00 08 mov %o0, %o1
parent_eval_flags,
&rtems_filesystem_root,
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
40005500: 40 00 1e b2 call 4000cfc8 <rtems_filesystem_location_clone>
40005504: 90 10 00 1b mov %i3, %o0
ctx->path = name;
ctx->pathlen = namelen;
ctx->flags = eval_flags;
rtems_filesystem_eval_path_continue(ctx);
40005508: 90 10 00 18 mov %i0, %o0
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
ctx->path = name;
4000550c: fa 26 00 00 st %i5, [ %i0 ]
ctx->pathlen = namelen;
40005510: e0 26 20 04 st %l0, [ %i0 + 4 ]
ctx->flags = eval_flags;
40005514: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
rtems_filesystem_eval_path_continue(ctx);
40005518: 7f ff ff 54 call 40005268 <rtems_filesystem_eval_path_continue>
4000551c: b0 06 20 18 add %i0, 0x18, %i0
40005520: 81 c7 e0 08 ret
40005524: 81 e8 00 00 restore
size_t namelen = 0;
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
40005528: 13 10 00 77 sethi %hi(0x4001dc00), %o1
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
4000552c: a0 10 00 08 mov %o0, %l0
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
parentpathlen = 1;
name = path;
40005530: ba 10 00 19 mov %i1, %i5
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
parentpathlen = 1;
40005534: 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 = ".";
40005538: 10 bf ff eb b 400054e4 <rtems_filesystem_eval_path_start_with_parent+0x70>
4000553c: 92 12 63 90 or %o1, 0x390, %o1
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
size_t i = pathlen - 1;
if (rtems_filesystem_is_delimiter(path [i])) {
40005540: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40005544: 10 bf ff e6 b 400054dc <rtems_filesystem_eval_path_start_with_parent+0x68>
40005548: a0 10 20 00 clr %l0
{
size_t pathlen = strlen(path);
const char *parentpath = path;
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
4000554c: 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;
40005550: ba 10 20 00 clr %i5
}
pathlen = i;
}
return 0;
40005554: 10 bf ff e4 b 400054e4 <rtems_filesystem_eval_path_start_with_parent+0x70>
40005558: 94 10 20 00 clr %o2
4000d32c <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
4000d32c: 9d e3 bf 98 save %sp, -104, %sp
find_arg fa = {
4000d330: f0 27 bf f8 st %i0, [ %fp + -8 ]
4000d334: c0 27 bf fc clr [ %fp + -4 ]
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
4000d338: 82 10 00 18 mov %i0, %g1
find_arg fa = {
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
4000d33c: 80 a0 60 00 cmp %g1, 0
4000d340: 02 80 00 07 be 4000d35c <rtems_filesystem_get_mount_handler+0x30><== NEVER TAKEN
4000d344: b0 10 20 00 clr %i0
rtems_filesystem_iterate( find_handler, &fa );
4000d348: 92 07 bf f8 add %fp, -8, %o1
4000d34c: 11 10 00 34 sethi %hi(0x4000d000), %o0
4000d350: 7f ff ff c9 call 4000d274 <rtems_filesystem_iterate>
4000d354: 90 12 22 40 or %o0, 0x240, %o0 ! 4000d240 <find_handler>
4000d358: f0 07 bf fc ld [ %fp + -4 ], %i0
}
return fa.mount_h;
}
4000d35c: 81 c7 e0 08 ret
4000d360: 81 e8 00 00 restore
40005994 <rtems_filesystem_global_location_obtain>:
}
rtems_filesystem_global_location_t *rtems_filesystem_global_location_obtain(
rtems_filesystem_global_location_t *const *global_loc_ptr
)
{
40005994: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_mt_entry_declare_lock_context(lock_context);
rtems_filesystem_global_location_t *global_loc;
if (deferred_released_global_locations != NULL) {
40005998: 37 10 00 7f sethi %hi(0x4001fc00), %i3
4000599c: c2 06 e1 30 ld [ %i3 + 0x130 ], %g1 ! 4001fd30 <deferred_released_global_locations>
400059a0: 80 a0 60 00 cmp %g1, 0
400059a4: 02 80 00 1e be 40005a1c <rtems_filesystem_global_location_obtain+0x88>
400059a8: 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;
400059ac: 39 10 00 80 sethi %hi(0x40020000), %i4
400059b0: c2 07 22 b0 ld [ %i4 + 0x2b0 ], %g1 ! 400202b0 <_Thread_Dispatch_disable_level>
++level;
400059b4: 82 00 60 01 inc %g1
_Thread_Dispatch_disable_level = level;
400059b8: c2 27 22 b0 st %g1, [ %i4 + 0x2b0 ]
do {
int count = 0;
_Thread_Disable_dispatch();
current = deferred_released_global_locations;
400059bc: fa 06 e1 30 ld [ %i3 + 0x130 ], %i5
if (current != NULL) {
400059c0: 80 a7 60 00 cmp %i5, 0
400059c4: 02 80 00 14 be 40005a14 <rtems_filesystem_global_location_obtain+0x80><== NEVER TAKEN
400059c8: 01 00 00 00 nop
400059cc: b6 16 e1 30 or %i3, 0x130, %i3
400059d0: b8 17 22 b0 or %i4, 0x2b0, %i4
deferred_released_global_locations = current->deferred_released_next;
400059d4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
count = current->deferred_released_count;
400059d8: f4 07 60 20 ld [ %i5 + 0x20 ], %i2
int count = 0;
_Thread_Disable_dispatch();
current = deferred_released_global_locations;
if (current != NULL) {
deferred_released_global_locations = current->deferred_released_next;
400059dc: c2 26 c0 00 st %g1, [ %i3 ]
count = current->deferred_released_count;
current->deferred_released_next = NULL;
400059e0: c0 27 60 1c clr [ %i5 + 0x1c ]
current->deferred_released_count = 0;
}
_Thread_Enable_dispatch();
400059e4: 40 00 15 b9 call 4000b0c8 <_Thread_Enable_dispatch>
400059e8: c0 27 60 20 clr [ %i5 + 0x20 ]
if (current != NULL) {
release_with_count(current, count);
400059ec: 90 10 00 1d mov %i5, %o0
400059f0: 7f ff ff 9e call 40005868 <release_with_count>
400059f4: 92 10 00 1a mov %i2, %o1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
400059f8: c2 07 00 00 ld [ %i4 ], %g1
++level;
400059fc: 82 00 60 01 inc %g1
_Thread_Dispatch_disable_level = level;
40005a00: c2 27 00 00 st %g1, [ %i4 ]
do {
int count = 0;
_Thread_Disable_dispatch();
current = deferred_released_global_locations;
40005a04: fa 06 c0 00 ld [ %i3 ], %i5
if (current != NULL) {
40005a08: 80 a7 60 00 cmp %i5, 0
40005a0c: 32 bf ff f3 bne,a 400059d8 <rtems_filesystem_global_location_obtain+0x44><== NEVER TAKEN
40005a10: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
count = current->deferred_released_count;
current->deferred_released_next = NULL;
current->deferred_released_count = 0;
}
_Thread_Enable_dispatch();
40005a14: 40 00 15 ad call 4000b0c8 <_Thread_Enable_dispatch>
40005a18: 01 00 00 00 nop
if (deferred_released_global_locations != NULL) {
deferred_release();
}
rtems_filesystem_mt_entry_lock(lock_context);
40005a1c: 7f ff f2 ad call 400024d0 <sparc_disable_interrupts>
40005a20: 01 00 00 00 nop
40005a24: ba 10 00 08 mov %o0, %i5
global_loc = *global_loc_ptr;
40005a28: f0 06 00 00 ld [ %i0 ], %i0
if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
40005a2c: 80 a6 20 00 cmp %i0, 0
40005a30: 02 80 00 07 be 40005a4c <rtems_filesystem_global_location_obtain+0xb8>
40005a34: 01 00 00 00 nop
40005a38: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40005a3c: c2 08 60 28 ldub [ %g1 + 0x28 ], %g1
40005a40: 80 a0 60 00 cmp %g1, 0
40005a44: 32 80 00 08 bne,a 40005a64 <rtems_filesystem_global_location_obtain+0xd0>
40005a48: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
global_loc = &rtems_filesystem_global_location_null;
errno = ENXIO;
40005a4c: 40 00 2b bd call 40010940 <__errno>
40005a50: 31 10 00 7d sethi %hi(0x4001f400), %i0
40005a54: 82 10 20 06 mov 6, %g1
40005a58: c2 22 00 00 st %g1, [ %o0 ]
}
rtems_filesystem_mt_entry_lock(lock_context);
global_loc = *global_loc_ptr;
if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
global_loc = &rtems_filesystem_global_location_null;
40005a5c: b0 16 22 20 or %i0, 0x220, %i0
errno = ENXIO;
}
++global_loc->reference_count;
40005a60: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40005a64: 82 00 60 01 inc %g1
40005a68: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
rtems_filesystem_mt_entry_unlock(lock_context);
40005a6c: 7f ff f2 9d call 400024e0 <sparc_enable_interrupts>
40005a70: 90 10 00 1d mov %i5, %o0
40005a74: 81 c7 e0 08 ret
40005a78: 81 e8 00 00 restore
40003ee4 <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
40003ee4: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
40003ee8: 05 10 00 75 sethi %hi(0x4001d400), %g2
40003eec: 82 10 a2 64 or %g2, 0x264, %g1 ! 4001d664 <rtems_filesystem_root_configuration>
40003ef0: d0 00 a2 64 ld [ %g2 + 0x264 ], %o0
40003ef4: d2 00 60 04 ld [ %g1 + 4 ], %o1
40003ef8: d4 00 60 08 ld [ %g1 + 8 ], %o2
40003efc: d6 00 60 0c ld [ %g1 + 0xc ], %o3
40003f00: 40 00 02 22 call 40004788 <mount>
40003f04: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
40003f08: 80 a2 20 00 cmp %o0, 0
40003f0c: 12 80 00 0a bne 40003f34 <rtems_filesystem_initialize+0x50><== NEVER TAKEN
40003f10: 92 10 21 ff mov 0x1ff, %o1
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
rv = mkdir( "/dev", 0777);
40003f14: 11 10 00 76 sethi %hi(0x4001d800), %o0
40003f18: 40 00 01 d3 call 40004664 <mkdir>
40003f1c: 90 12 22 20 or %o0, 0x220, %o0 ! 4001da20 <IMFS_node_control_default+0x58>
if ( rv != 0 )
40003f20: 80 a2 20 00 cmp %o0, 0
40003f24: 12 80 00 07 bne 40003f40 <rtems_filesystem_initialize+0x5c><== NEVER TAKEN
40003f28: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
40003f2c: 81 c7 e0 08 ret
40003f30: 81 e8 00 00 restore
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
rtems_fatal_error_occurred( 0xABCD0002 );
40003f34: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
40003f38: 40 00 13 7a call 40008d20 <rtems_fatal_error_occurred> <== NOT EXECUTED
40003f3c: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <LEON_REG+0x2bcd0002><== NOT EXECUTED
* created that way by the IMFS.
*/
rv = mkdir( "/dev", 0777);
if ( rv != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
40003f40: 40 00 13 78 call 40008d20 <rtems_fatal_error_occurred> <== NOT EXECUTED
40003f44: 90 12 20 03 or %o0, 3, %o0 <== NOT EXECUTED
4000d274 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
4000d274: 9d e3 bf a0 save %sp, -96, %sp
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
4000d278: 3b 10 00 75 sethi %hi(0x4001d400), %i5
4000d27c: c2 07 62 78 ld [ %i5 + 0x278 ], %g1 ! 4001d678 <rtems_filesystem_table>
4000d280: 80 a0 60 00 cmp %g1, 0
4000d284: 12 80 00 06 bne 4000d29c <rtems_filesystem_iterate+0x28> <== ALWAYS TAKEN
4000d288: ba 17 62 78 or %i5, 0x278, %i5
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000d28c: 10 80 00 0e b 4000d2c4 <rtems_filesystem_iterate+0x50> <== NOT EXECUTED
4000d290: 35 10 00 80 sethi %hi(0x40020000), %i2 <== NOT EXECUTED
4000d294: 12 80 00 24 bne 4000d324 <rtems_filesystem_iterate+0xb0>
4000d298: 01 00 00 00 nop
stop = (*routine)( table_entry, routine_arg );
4000d29c: 90 10 00 1d mov %i5, %o0
4000d2a0: 9f c6 00 00 call %i0
4000d2a4: 92 10 00 19 mov %i1, %o1
++table_entry;
4000d2a8: ba 07 60 08 add %i5, 8, %i5
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
4000d2ac: c2 07 40 00 ld [ %i5 ], %g1
4000d2b0: 80 a0 60 00 cmp %g1, 0
4000d2b4: 12 bf ff f8 bne 4000d294 <rtems_filesystem_iterate+0x20>
4000d2b8: b8 8a 20 ff andcc %o0, 0xff, %i4
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
4000d2bc: 12 80 00 1a bne 4000d324 <rtems_filesystem_iterate+0xb0>
4000d2c0: 35 10 00 80 sethi %hi(0x40020000), %i2
4000d2c4: d0 06 a1 2c ld [ %i2 + 0x12c ], %o0 ! 4002012c <rtems_libio_semaphore>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000d2c8: 37 10 00 7d sethi %hi(0x4001f400), %i3
4000d2cc: 92 10 20 00 clr %o1
4000d2d0: 7f ff ec af call 4000858c <rtems_semaphore_obtain>
4000d2d4: 94 10 20 00 clr %o2
4000d2d8: fa 06 e2 a0 ld [ %i3 + 0x2a0 ], %i5
4000d2dc: b6 16 e2 a0 or %i3, 0x2a0, %i3
rtems_libio_lock();
for (
4000d2e0: b6 06 e0 04 add %i3, 4, %i3
4000d2e4: 80 a7 40 1b cmp %i5, %i3
4000d2e8: 12 80 00 05 bne 4000d2fc <rtems_filesystem_iterate+0x88>
4000d2ec: b8 10 20 00 clr %i4
4000d2f0: 30 80 00 0b b,a 4000d31c <rtems_filesystem_iterate+0xa8>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
4000d2f4: 12 80 00 0a bne 4000d31c <rtems_filesystem_iterate+0xa8> <== NEVER TAKEN
4000d2f8: 01 00 00 00 nop
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
4000d2fc: 90 07 60 08 add %i5, 8, %o0
4000d300: 9f c6 00 00 call %i0
4000d304: 92 10 00 19 mov %i1, %o1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
4000d308: fa 07 40 00 ld [ %i5 ], %i5
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
4000d30c: 80 a7 40 1b cmp %i5, %i3
4000d310: 12 bf ff f9 bne 4000d2f4 <rtems_filesystem_iterate+0x80>
4000d314: b8 8a 20 ff andcc %o0, 0xff, %i4
4000d318: b8 0a 20 ff and %o0, 0xff, %i4
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4000d31c: 7f ff ec eb call 400086c8 <rtems_semaphore_release>
4000d320: d0 06 a1 2c ld [ %i2 + 0x12c ], %o0
}
rtems_libio_unlock();
}
return stop;
}
4000d324: 81 c7 e0 08 ret
4000d328: 91 e8 00 1c restore %g0, %i4, %o0
4000cfc8 <rtems_filesystem_location_clone>:
void rtems_filesystem_location_clone(
rtems_filesystem_location_info_t *clone,
const rtems_filesystem_location_info_t *master
)
{
4000cfc8: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
clone = rtems_filesystem_location_copy( clone, master );
4000cfcc: 92 10 00 19 mov %i1, %o1
4000cfd0: 7f ff e1 bc call 400056c0 <rtems_filesystem_location_copy>
4000cfd4: 90 10 00 18 mov %i0, %o0
rv = (*clone->mt_entry->ops->clonenod_h)( clone );
4000cfd8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000cfdc: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000cfe0: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
4000cfe4: 9f c0 40 00 call %g1
4000cfe8: b0 10 00 08 mov %o0, %i0
if ( rv != 0 ) {
4000cfec: 80 a2 20 00 cmp %o0, 0
4000cff0: 12 80 00 04 bne 4000d000 <rtems_filesystem_location_clone+0x38><== NEVER TAKEN
4000cff4: 90 10 00 18 mov %i0, %o0
4000cff8: 81 c7 e0 08 ret
4000cffc: 81 e8 00 00 restore
rtems_filesystem_location_remove_from_mt_entry( clone );
4000d000: 7f ff e1 ec call 400057b0 <rtems_filesystem_location_remove_from_mt_entry><== NOT EXECUTED
4000d004: 33 10 00 7d sethi %hi(0x4001f400), %i1 <== NOT EXECUTED
static inline rtems_filesystem_location_info_t *
rtems_filesystem_location_initialize_to_null(
rtems_filesystem_location_info_t *loc
)
{
return rtems_filesystem_location_copy(
4000d008: 7f ff e1 ae call 400056c0 <rtems_filesystem_location_copy><== NOT EXECUTED
4000d00c: 93 ee 62 20 restore %i1, 0x220, %o1 <== NOT EXECUTED
400057b0 <rtems_filesystem_location_remove_from_mt_entry>:
}
void rtems_filesystem_location_remove_from_mt_entry(
rtems_filesystem_location_info_t *loc
)
{
400057b0: 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);
400057b4: 7f ff f3 47 call 400024d0 <sparc_disable_interrupts>
400057b8: 01 00 00 00 nop
rtems_chain_extract_unprotected(&loc->mt_entry_node);
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
400057bc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
400057c0: c6 06 00 00 ld [ %i0 ], %g3
previous = the_node->previous;
400057c4: c4 06 20 04 ld [ %i0 + 4 ], %g2
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
&& mt_entry->mt_fs_root->reference_count == 1;
400057c8: c8 08 60 28 ldub [ %g1 + 0x28 ], %g4
next->previous = previous;
400057cc: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
400057d0: c6 20 80 00 st %g3, [ %g2 ]
400057d4: 80 a1 20 00 cmp %g4, 0
400057d8: 12 80 00 07 bne 400057f4 <rtems_filesystem_location_remove_from_mt_entry+0x44>
400057dc: ba 10 20 00 clr %i5
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
400057e0: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
400057e4: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
400057e8: 80 a0 c0 02 cmp %g3, %g2
400057ec: 22 80 00 0b be,a 40005818 <rtems_filesystem_location_remove_from_mt_entry+0x68>
400057f0: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
rtems_filesystem_mt_entry_unlock(lock_context);
400057f4: 7f ff f3 3b call 400024e0 <sparc_enable_interrupts>
400057f8: 01 00 00 00 nop
if (do_unmount) {
400057fc: 80 8f 60 ff btst 0xff, %i5
40005800: 32 80 00 04 bne,a 40005810 <rtems_filesystem_location_remove_from_mt_entry+0x60><== NEVER TAKEN
40005804: f0 06 20 14 ld [ %i0 + 0x14 ], %i0 <== NOT EXECUTED
40005808: 81 c7 e0 08 ret
4000580c: 81 e8 00 00 restore
rtems_filesystem_do_unmount(loc->mt_entry);
40005810: 7f ff ff c8 call 40005730 <rtems_filesystem_do_unmount> <== NOT EXECUTED
40005814: 81 e8 00 00 restore <== NOT EXECUTED
&& mt_entry->mt_fs_root->reference_count == 1;
40005818: c4 00 a0 18 ld [ %g2 + 0x18 ], %g2
4000581c: 80 a0 a0 01 cmp %g2, 1
40005820: 12 bf ff f5 bne 400057f4 <rtems_filesystem_location_remove_from_mt_entry+0x44><== ALWAYS TAKEN
40005824: 84 00 60 14 add %g1, 0x14, %g2
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
40005828: 86 00 60 18 add %g1, 0x18, %g3 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
4000582c: c0 20 60 18 clr [ %g1 + 0x18 ] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
40005830: c6 20 60 14 st %g3, [ %g1 + 0x14 ] <== NOT EXECUTED
head->previous = NULL;
tail->previous = head;
40005834: c4 20 60 1c st %g2, [ %g1 + 0x1c ] <== NOT EXECUTED
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
40005838: 10 bf ff ef b 400057f4 <rtems_filesystem_location_remove_from_mt_entry+0x44><== NOT EXECUTED
4000583c: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
40005a7c <rtems_filesystem_location_transform_to_global>:
}
rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global(
rtems_filesystem_location_info_t *loc
)
{
40005a7c: 9d e3 bf 98 save %sp, -104, %sp
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
40005a80: 7f ff fa bc call 40004570 <malloc>
40005a84: 90 10 20 24 mov 0x24, %o0
if (global_loc != NULL) {
40005a88: ba 92 20 00 orcc %o0, 0, %i5
40005a8c: 02 80 00 0c be 40005abc <rtems_filesystem_location_transform_to_global+0x40><== NEVER TAKEN
40005a90: 82 10 20 01 mov 1, %g1
global_loc->reference_count = 1;
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
rtems_filesystem_location_copy(&global_loc->location, loc);
40005a94: 92 10 00 18 mov %i0, %o1
)
{
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
if (global_loc != NULL) {
global_loc->reference_count = 1;
40005a98: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
global_loc->deferred_released_next = NULL;
40005a9c: c0 27 60 1c clr [ %i5 + 0x1c ]
global_loc->deferred_released_count = 0;
rtems_filesystem_location_copy(&global_loc->location, loc);
40005aa0: 7f ff ff 08 call 400056c0 <rtems_filesystem_location_copy>
40005aa4: c0 27 60 20 clr [ %i5 + 0x20 ]
rtems_filesystem_location_remove_from_mt_entry(loc);
40005aa8: 90 10 00 18 mov %i0, %o0
40005aac: 7f ff ff 41 call 400057b0 <rtems_filesystem_location_remove_from_mt_entry>
40005ab0: b0 10 00 1d mov %i5, %i0
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
}
return global_loc;
}
40005ab4: 81 c7 e0 08 ret
40005ab8: 81 e8 00 00 restore
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
rtems_filesystem_location_copy(&global_loc->location, loc);
rtems_filesystem_location_remove_from_mt_entry(loc);
} else {
rtems_filesystem_location_free(loc);
40005abc: 40 00 1d 55 call 4000d010 <rtems_filesystem_location_free><== NOT EXECUTED
40005ac0: 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 );
40005ac4: 90 07 bf fc add %fp, -4, %o0 <== NOT EXECUTED
40005ac8: 7f ff ff b3 call 40005994 <rtems_filesystem_global_location_obtain><== NOT EXECUTED
40005acc: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
40005ad0: 40 00 2b 9c call 40010940 <__errno> <== NOT EXECUTED
40005ad4: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
40005ad8: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40005adc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return global_loc;
}
40005ae0: 81 c7 e0 08 ret <== NOT EXECUTED
40005ae4: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
40004680 <rtems_filesystem_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40004680: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
40004684: 03 10 00 7d sethi %hi(0x4001f400), %g1
40004688: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 4001f5f0 <rtems_current_user_env>
switch (mode & S_IFMT) {
4000468c: 05 00 00 10 sethi %hi(0x4000), %g2
dev_t dev
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
40004690: d6 00 60 08 ld [ %g1 + 8 ], %o3
switch (mode & S_IFMT) {
40004694: 03 00 00 3c sethi %hi(0xf000), %g1
dev_t dev
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
40004698: 96 2e c0 0b andn %i3, %o3, %o3
switch (mode & S_IFMT) {
4000469c: 82 0a c0 01 and %o3, %g1, %g1
400046a0: 80 a0 40 02 cmp %g1, %g2
400046a4: 22 80 00 18 be,a 40004704 <rtems_filesystem_mknod+0x84>
400046a8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400046ac: 08 80 00 0f bleu 400046e8 <rtems_filesystem_mknod+0x68>
400046b0: 05 00 00 04 sethi %hi(0x1000), %g2
400046b4: 05 00 00 18 sethi %hi(0x6000), %g2
400046b8: 80 a0 40 02 cmp %g1, %g2
400046bc: 02 80 00 11 be 40004700 <rtems_filesystem_mknod+0x80>
400046c0: 05 00 00 20 sethi %hi(0x8000), %g2
400046c4: 80 a0 40 02 cmp %g1, %g2
400046c8: 22 80 00 0f be,a 40004704 <rtems_filesystem_mknod+0x84> <== ALWAYS TAKEN
400046cc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
case S_IFDIR:
case S_IFIFO:
case S_IFREG:
break;
default:
errno = EINVAL;
400046d0: 40 00 30 9c call 40010940 <__errno>
400046d4: b0 10 3f ff mov -1, %i0
400046d8: 82 10 20 16 mov 0x16, %g1
400046dc: c2 22 00 00 st %g1, [ %o0 ]
400046e0: 81 c7 e0 08 ret
400046e4: 81 e8 00 00 restore
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
switch (mode & S_IFMT) {
400046e8: 80 a0 40 02 cmp %g1, %g2
400046ec: 02 80 00 05 be 40004700 <rtems_filesystem_mknod+0x80>
400046f0: 05 00 00 08 sethi %hi(0x2000), %g2
400046f4: 80 a0 40 02 cmp %g1, %g2
400046f8: 12 bf ff f6 bne 400046d0 <rtems_filesystem_mknod+0x50>
400046fc: 01 00 00 00 nop
rv = -1;
break;
}
if ( rv == 0 ) {
const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
40004700: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
40004704: 90 10 00 18 mov %i0, %o0
40004708: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000470c: 92 10 00 19 mov %i1, %o1
40004710: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40004714: 94 10 00 1a mov %i2, %o2
40004718: 98 10 00 1c mov %i4, %o4
4000471c: 9f c0 40 00 call %g1
40004720: 9a 10 00 1d mov %i5, %o5
}
return rv;
}
40004724: 81 c7 e0 08 ret
40004728: 91 e8 00 08 restore %g0, %o0, %o0
4000d430 <rtems_filesystem_unregister>:
int
rtems_filesystem_unregister(
const char *type
)
{
4000d430: 9d e3 bf a0 save %sp, -96, %sp
rtems_chain_node *node = NULL;
if ( type == NULL ) {
4000d434: 80 a6 20 00 cmp %i0, 0
4000d438: 02 80 00 29 be 4000d4dc <rtems_filesystem_unregister+0xac>
4000d43c: 37 10 00 80 sethi %hi(0x40020000), %i3
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000d440: d0 06 e1 2c ld [ %i3 + 0x12c ], %o0 ! 4002012c <rtems_libio_semaphore>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4000d444: 39 10 00 7d sethi %hi(0x4001f400), %i4
4000d448: 92 10 20 00 clr %o1
4000d44c: 7f ff ec 50 call 4000858c <rtems_semaphore_obtain>
4000d450: 94 10 20 00 clr %o2
4000d454: fa 07 22 a0 ld [ %i4 + 0x2a0 ], %i5
4000d458: b8 17 22 a0 or %i4, 0x2a0, %i4
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
4000d45c: b8 07 20 04 add %i4, 4, %i4
4000d460: 80 a7 40 1c cmp %i5, %i4
4000d464: 32 80 00 08 bne,a 4000d484 <rtems_filesystem_unregister+0x54>
4000d468: d0 07 60 08 ld [ %i5 + 8 ], %o0
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
4000d46c: 10 80 00 14 b 4000d4bc <rtems_filesystem_unregister+0x8c>
4000d470: d0 06 e1 2c ld [ %i3 + 0x12c ], %o0
4000d474: 80 a7 40 1c cmp %i5, %i4
4000d478: 02 80 00 11 be 4000d4bc <rtems_filesystem_unregister+0x8c><== ALWAYS TAKEN
4000d47c: d0 06 e1 2c ld [ %i3 + 0x12c ], %o0
!rtems_chain_is_tail( &filesystem_chain, node );
node = rtems_chain_next( node )
) {
filesystem_node *fsn = (filesystem_node *) node;
if ( strcmp( fsn->entry.type, type ) == 0 ) {
4000d480: d0 07 60 08 ld [ %i5 + 8 ], %o0 <== NOT EXECUTED
4000d484: 40 00 10 c9 call 400117a8 <strcmp>
4000d488: 92 10 00 18 mov %i0, %o1
4000d48c: 80 a2 20 00 cmp %o0, 0
4000d490: 32 bf ff f9 bne,a 4000d474 <rtems_filesystem_unregister+0x44>
4000d494: fa 07 40 00 ld [ %i5 ], %i5
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4000d498: 40 00 04 40 call 4000e598 <_Chain_Extract>
4000d49c: 90 10 00 1d mov %i5, %o0
rtems_chain_extract( node );
free( fsn );
4000d4a0: 7f ff db 5a call 40004208 <free>
4000d4a4: 90 10 00 1d mov %i5, %o0
4000d4a8: d0 06 e1 2c ld [ %i3 + 0x12c ], %o0
4000d4ac: 7f ff ec 87 call 400086c8 <rtems_semaphore_release>
4000d4b0: b0 10 20 00 clr %i0
4000d4b4: 81 c7 e0 08 ret
4000d4b8: 81 e8 00 00 restore
4000d4bc: 7f ff ec 83 call 400086c8 <rtems_semaphore_release>
4000d4c0: b0 10 3f ff mov -1, %i0
return 0;
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
4000d4c4: 40 00 0d 1f call 40010940 <__errno>
4000d4c8: 01 00 00 00 nop
4000d4cc: 82 10 20 02 mov 2, %g1 ! 2 <PROM_START+0x2>
4000d4d0: c2 22 00 00 st %g1, [ %o0 ]
}
4000d4d4: 81 c7 e0 08 ret
4000d4d8: 81 e8 00 00 restore
)
{
rtems_chain_node *node = NULL;
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
4000d4dc: 40 00 0d 19 call 40010940 <__errno>
4000d4e0: b0 10 3f ff mov -1, %i0
4000d4e4: 82 10 20 16 mov 0x16, %g1
4000d4e8: c2 22 00 00 st %g1, [ %o0 ]
4000d4ec: 81 c7 e0 08 ret
4000d4f0: 81 e8 00 00 restore
400047d0 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
400047d0: 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 ) );
400047d4: 40 00 01 0c call 40004c04 <malloc>
400047d8: 90 10 20 08 mov 8, %o0
*key = new_key;
new_key->val = NULL;
400047dc: c0 22 00 00 clr [ %o0 ]
* We have to to this, because the others functions on this interface
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
*key = new_key;
400047e0: 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 ) );
400047e4: ba 10 00 08 mov %o0, %i5
*key = new_key;
new_key->val = NULL;
new_key->dtor = dtor;
400047e8: 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 );
400047ec: 92 10 00 1d mov %i5, %o1
400047f0: 90 10 20 00 clr %o0
400047f4: 94 10 00 19 mov %i1, %o2
400047f8: 40 00 12 8c call 40009228 <rtems_task_variable_add>
400047fc: b0 10 20 00 clr %i0
if ( status == RTEMS_SUCCESSFUL )
40004800: 80 a2 20 00 cmp %o0, 0
40004804: 02 80 00 04 be 40004814 <rtems_gxx_key_create+0x44> <== ALWAYS TAKEN
40004808: 90 10 00 1d mov %i5, %o0
return 0;
free( new_key );
4000480c: 7f ff ff 81 call 40004610 <free> <== NOT EXECUTED
40004810: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
}
40004814: 81 c7 e0 08 ret
40004818: 81 e8 00 00 restore
40004828 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
40004828: 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 );
4000482c: 90 10 20 00 clr %o0
40004830: 40 00 12 b0 call 400092f0 <rtems_task_variable_delete>
40004834: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
40004838: 80 a2 20 00 cmp %o0, 0
4000483c: 12 80 00 06 bne 40004854 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
40004840: 80 a6 20 00 cmp %i0, 0
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
40004844: 02 80 00 04 be 40004854 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
40004848: 01 00 00 00 nop
4000484c: 7f ff ff 71 call 40004610 <free>
40004850: d0 06 00 00 ld [ %i0 ], %o0
return 0;
}
key = NULL;
return 0;
}
40004854: 81 c7 e0 08 ret
40004858: 91 e8 20 00 restore %g0, 0, %o0
40004760 <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))
{
40004760: 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 ) {
40004764: c2 06 00 00 ld [ %i0 ], %g1
40004768: 80 a0 60 00 cmp %g1, 0
4000476c: 02 80 00 04 be 4000477c <rtems_gxx_once+0x1c>
40004770: 92 10 21 00 mov 0x100, %o1
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
if ( o == 0 )
(*func)();
}
return 0;
}
40004774: 81 c7 e0 08 ret
40004778: 91 e8 20 00 restore %g0, 0, %o0
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
4000477c: 94 07 bf fc add %fp, -4, %o2
40004780: 40 00 12 20 call 40009000 <rtems_task_mode>
40004784: 90 10 21 00 mov 0x100, %o0
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
40004788: c2 06 00 00 ld [ %i0 ], %g1
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
4000478c: d0 07 bf fc ld [ %fp + -4 ], %o0
40004790: 92 10 21 00 mov 0x100, %o1
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
40004794: 80 a0 60 00 cmp %g1, 0
40004798: 12 80 00 0a bne 400047c0 <rtems_gxx_once+0x60> <== NEVER TAKEN
4000479c: 94 07 bf fc add %fp, -4, %o2
*(volatile __gthread_once_t *)once = 1;
400047a0: 82 10 20 01 mov 1, %g1
400047a4: c2 26 00 00 st %g1, [ %i0 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
400047a8: 40 00 12 16 call 40009000 <rtems_task_mode>
400047ac: b0 10 20 00 clr %i0
if ( o == 0 )
(*func)();
400047b0: 9f c6 40 00 call %i1
400047b4: 01 00 00 00 nop
}
return 0;
}
400047b8: 81 c7 e0 08 ret
400047bc: 81 e8 00 00 restore
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
400047c0: 40 00 12 10 call 40009000 <rtems_task_mode> <== NOT EXECUTED
400047c4: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( o == 0 )
(*func)();
}
return 0;
}
400047c8: 81 c7 e0 08 ret <== NOT EXECUTED
400047cc: 81 e8 00 00 restore <== NOT EXECUTED
400048c4 <rtems_gxx_setspecific>:
#endif
return p;
}
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
400048c4: 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 );
400048c8: d4 06 20 04 ld [ %i0 + 4 ], %o2
400048cc: 90 10 20 00 clr %o0
400048d0: 40 00 12 56 call 40009228 <rtems_task_variable_add>
400048d4: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
400048d8: 80 a2 20 00 cmp %o0, 0
400048dc: 12 80 00 05 bne 400048f0 <rtems_gxx_setspecific+0x2c> <== NEVER TAKEN
400048e0: 01 00 00 00 nop
/* now let's set the proper value */
key->val = (void *)ptr;
400048e4: f2 26 00 00 st %i1, [ %i0 ]
return 0;
400048e8: 81 c7 e0 08 ret
400048ec: 91 e8 20 00 restore %g0, 0, %o0
}
return -1;
}
400048f0: 81 c7 e0 08 ret <== NOT EXECUTED
400048f4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
400097d4 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
400097d4: 9d e3 bf a0 save %sp, -96, %sp
if (
400097d8: 03 10 00 9e sethi %hi(0x40027800), %g1
400097dc: c2 00 62 f8 ld [ %g1 + 0x2f8 ], %g1 ! 40027af8 <_System_state_Current>
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
400097e0: ba 10 00 18 mov %i0, %i5
400097e4: b8 10 00 19 mov %i1, %i4
if (
400097e8: 80 a0 60 03 cmp %g1, 3
400097ec: 02 80 00 08 be 4000980c <rtems_heap_allocate_aligned_with_boundary+0x38><== ALWAYS TAKEN
400097f0: b6 10 00 1a mov %i2, %i3
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
400097f4: 7f ff fb d4 call 40008744 <malloc_deferred_frees_process>
400097f8: b2 10 00 1d mov %i5, %i1
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
400097fc: 03 10 00 97 sethi %hi(0x40025c00), %g1
40009800: f0 00 63 b4 ld [ %g1 + 0x3b4 ], %i0 ! 40025fb4 <RTEMS_Malloc_Heap>
40009804: 40 00 19 77 call 4000fde0 <_Protected_heap_Allocate_aligned_with_boundary>
40009808: 95 e8 00 1c restore %g0, %i4, %o2
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
4000980c: 7f ff fb c1 call 40008710 <malloc_is_system_state_OK>
40009810: 01 00 00 00 nop
40009814: 80 8a 20 ff btst 0xff, %o0
40009818: 12 bf ff f7 bne 400097f4 <rtems_heap_allocate_aligned_with_boundary+0x20>
4000981c: b0 10 20 00 clr %i0
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
40009820: 81 c7 e0 08 ret
40009824: 81 e8 00 00 restore
40004dc8 <rtems_heap_extend_via_sbrk>:
void *rtems_heap_extend_via_sbrk(
Heap_Control *heap,
size_t alloc_size
)
{
40004dc8: 9d e3 bf a0 save %sp, -96, %sp
ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;
40004dcc: 03 10 00 60 sethi %hi(0x40018000), %g1
40004dd0: f8 00 60 90 ld [ %g1 + 0x90 ], %i4 ! 40018090 <RTEMS_Malloc_Sbrk_amount>
ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;
ptrdiff_t misaligned = sbrk_size % sbrk_amount;
40004dd4: 90 10 00 19 mov %i1, %o0
40004dd8: 92 10 00 1c mov %i4, %o1
40004ddc: 40 00 3c fc call 400141cc <.rem>
40004de0: ba 10 00 19 mov %i1, %i5
void *return_this = NULL;
if ( misaligned != 0 ) {
40004de4: 80 a2 20 00 cmp %o0, 0
40004de8: 02 80 00 05 be 40004dfc <rtems_heap_extend_via_sbrk+0x34>
40004dec: 80 a7 60 00 cmp %i5, 0
sbrk_size += sbrk_amount - misaligned;
40004df0: ba 27 00 08 sub %i4, %o0, %i5
40004df4: ba 06 40 1d add %i1, %i5, %i5
}
if ( sbrk_size > 0 && sbrk_amount > 0 ) {
40004df8: 80 a7 60 00 cmp %i5, 0
40004dfc: 04 80 00 17 ble 40004e58 <rtems_heap_extend_via_sbrk+0x90><== NEVER TAKEN
40004e00: 80 a7 20 00 cmp %i4, 0
40004e04: 04 80 00 15 ble 40004e58 <rtems_heap_extend_via_sbrk+0x90><== NEVER TAKEN
40004e08: 01 00 00 00 nop
void *area_begin = sbrk( sbrk_size );
40004e0c: 7f ff f1 b5 call 400014e0 <sbrk>
40004e10: 90 10 00 1d mov %i5, %o0
if ( area_begin != (void *) -1 ) {
40004e14: 80 a2 3f ff cmp %o0, -1
40004e18: 02 80 00 10 be 40004e58 <rtems_heap_extend_via_sbrk+0x90>
40004e1c: 92 10 00 08 mov %o0, %o1
bool ok = _Protected_heap_Extend( heap, area_begin, sbrk_size );
40004e20: 90 10 00 18 mov %i0, %o0
40004e24: 40 00 14 ad call 4000a0d8 <_Protected_heap_Extend>
40004e28: 94 10 00 1d mov %i5, %o2
if ( ok ) {
40004e2c: 80 8a 20 ff btst 0xff, %o0
40004e30: 02 80 00 08 be 40004e50 <rtems_heap_extend_via_sbrk+0x88>
40004e34: 03 10 00 60 sethi %hi(0x40018000), %g1
MSBUMP( space_available, sbrk_size );
40004e38: c4 00 60 60 ld [ %g1 + 0x60 ], %g2 ! 40018060 <rtems_malloc_statistics>
40004e3c: b4 10 20 00 clr %i2
40004e40: ba 07 40 02 add %i5, %g2, %i5
40004e44: fa 20 60 60 st %i5, [ %g1 + 0x60 ]
40004e48: 40 00 14 96 call 4000a0a0 <_Protected_heap_Allocate_aligned_with_boundary>
40004e4c: 97 e8 20 00 restore %g0, 0, %o3
return_this = _Protected_heap_Allocate( heap, alloc_size );
} else {
sbrk( -sbrk_size );
40004e50: 7f ff f1 a4 call 400014e0 <sbrk>
40004e54: 90 20 00 1d neg %i5, %o0
}
}
}
return return_this;
}
40004e58: 81 c7 e0 08 ret
40004e5c: 91 e8 20 00 restore %g0, 0, %o0
400050c0 <rtems_heap_null_extend>:
Heap_Control *heap __attribute__((unused)),
size_t alloc_size __attribute__((unused))
)
{
return NULL;
}
400050c0: 81 c3 e0 08 retl
400050c4: 90 10 20 00 clr %o0
40005ba8 <rtems_ide_part_table_free>:
* N/A
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
{
partition_table_free( disk_desc );
40005ba8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40005bac: 7f ff fe bb call 40005698 <partition_table_free> <== NOT EXECUTED
40005bb0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40005bb4 <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 );
40005bb4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40005bb8: 7f ff ff 89 call 400059dc <partition_table_get> <== NOT EXECUTED
40005bbc: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40005bc0 <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)
{
40005bc0: 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));
40005bc4: 90 10 20 01 mov 1, %o0
40005bc8: 92 10 21 28 mov 0x128, %o1
40005bcc: 40 00 02 2c call 4000647c <calloc>
40005bd0: b2 10 00 18 mov %i0, %i1
if (disk_desc == NULL)
{
return RTEMS_NO_MEMORY;
40005bd4: b0 10 20 1a mov 0x1a, %i0
/* logical device name /dev/hdxyy */
char name[RTEMS_IDE_PARTITION_DEV_NAME_LENGTH_MAX];
disk_desc = (rtems_disk_desc_t *) calloc(1, sizeof(rtems_disk_desc_t));
if (disk_desc == NULL)
40005bd8: 80 a2 20 00 cmp %o0, 0
40005bdc: 02 80 00 33 be 40005ca8 <rtems_ide_part_table_initialize+0xe8><== NEVER TAKEN
40005be0: b4 10 00 08 mov %o0, %i2
{
return RTEMS_NO_MEMORY;
}
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
40005be4: 90 10 00 19 mov %i1, %o0
40005be8: 7f ff ff 7d call 400059dc <partition_table_get>
40005bec: 92 10 00 1a mov %i2, %o1
if (rc != RTEMS_SUCCESSFUL)
40005bf0: b0 92 20 00 orcc %o0, 0, %i0
40005bf4: 12 80 00 36 bne 40005ccc <rtems_ide_part_table_initialize+0x10c><== NEVER TAKEN
40005bf8: ba 10 20 00 clr %i5
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
40005bfc: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1
{
sprintf(name, "%s%d", dev_name, part_num + 1);
40005c00: b6 07 bf f0 add %fp, -16, %i3
40005c04: 21 10 00 99 sethi %hi(0x40026400), %l0
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
40005c08: 27 10 00 99 sethi %hi(0x40026400), %l3
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
{
sprintf(name, "%s%d", dev_name, part_num + 1);
40005c0c: a0 14 22 a0 or %l0, 0x2a0, %l0
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
40005c10: 80 a7 40 01 cmp %i5, %g1
/* To avoid device numbers conflicts we have to use for logic disk the same
* device major number as ATA device has, and minor number that equals to
* sum of logic disk partition number and the minor number of physical disk
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
40005c14: e4 06 80 00 ld [ %i2 ], %l2
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
{
sprintf(name, "%s%d", dev_name, part_num + 1);
40005c18: ba 07 60 01 inc %i5
/* To avoid device numbers conflicts we have to use for logic disk the same
* device major number as ATA device has, and minor number that equals to
* sum of logic disk partition number and the minor number of physical disk
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
40005c1c: e2 06 a0 04 ld [ %i2 + 4 ], %l1
* RTEMS_SUCCESSFUL if success,
* RTEMS_NO_MEMOTY if cannot have not enough memory,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
rtems_status_code
rtems_ide_part_table_initialize(const char *dev_name)
40005c20: b8 06 a0 28 add %i2, 0x28, %i4
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
40005c24: 29 10 00 9e sethi %hi(0x40027800), %l4
40005c28: a6 14 e2 a8 or %l3, 0x2a8, %l3
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
{
sprintf(name, "%s%d", dev_name, part_num + 1);
40005c2c: 92 10 00 10 mov %l0, %o1
40005c30: 94 10 00 19 mov %i1, %o2
40005c34: 90 10 00 1b mov %i3, %o0
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
40005c38: 16 80 00 1a bge 40005ca0 <rtems_ide_part_table_initialize+0xe0><== NEVER TAKEN
40005c3c: 96 10 00 1d mov %i5, %o3
{
sprintf(name, "%s%d", dev_name, part_num + 1);
40005c40: 40 00 46 13 call 4001748c <sprintf>
40005c44: 01 00 00 00 nop
dev = rtems_filesystem_make_dev_t(major, ++minor);
part_desc = disk_desc->partitions[part_num];
40005c48: c2 07 00 00 ld [ %i4 ], %g1
if (part_desc == NULL)
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
40005c4c: 90 10 00 12 mov %l2, %o0
{
sprintf(name, "%s%d", dev_name, part_num + 1);
dev = rtems_filesystem_make_dev_t(major, ++minor);
part_desc = disk_desc->partitions[part_num];
if (part_desc == NULL)
40005c50: 80 a0 60 00 cmp %g1, 0
40005c54: 02 80 00 0a be 40005c7c <rtems_ide_part_table_initialize+0xbc>
40005c58: 92 07 40 11 add %i5, %l1, %o1
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
40005c5c: d8 00 60 04 ld [ %g1 + 4 ], %o4
40005c60: da 00 60 08 ld [ %g1 + 8 ], %o5
40005c64: d4 1e 80 00 ldd [ %i2 ], %o2
40005c68: 7f ff fd 47 call 40005184 <rtems_disk_create_log>
40005c6c: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
40005c70: 96 92 20 00 orcc %o0, 0, %o3
40005c74: 12 80 00 0f bne 40005cb0 <rtems_ide_part_table_initialize+0xf0><== NEVER TAKEN
40005c78: c2 05 21 c8 ld [ %l4 + 0x1c8 ], %g1
40005c7c: b8 07 20 04 add %i4, 4, %i4
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
40005c80: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1
{
sprintf(name, "%s%d", dev_name, part_num + 1);
40005c84: 92 10 00 10 mov %l0, %o1
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
40005c88: 80 a7 40 01 cmp %i5, %g1
{
sprintf(name, "%s%d", dev_name, part_num + 1);
40005c8c: 94 10 00 19 mov %i1, %o2
40005c90: ba 07 60 01 inc %i5
40005c94: 90 10 00 1b mov %i3, %o0
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
40005c98: 06 bf ff ea bl 40005c40 <rtems_ide_part_table_initialize+0x80>
40005c9c: 96 10 00 1d mov %i5, %o3
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
continue;
}
}
partition_table_free(disk_desc);
40005ca0: 7f ff fe 7e call 40005698 <partition_table_free>
40005ca4: 90 10 00 1a mov %i2, %o0
return RTEMS_SUCCESSFUL;
}
40005ca8: 81 c7 e0 08 ret
40005cac: 81 e8 00 00 restore
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
40005cb0: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
40005cb4: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
40005cb8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
40005cbc: 40 00 43 e5 call 40016c50 <fprintf> <== NOT EXECUTED
40005cc0: b8 07 20 04 add %i4, 4, %i4 <== NOT EXECUTED
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
40005cc4: 10 bf ff f0 b 40005c84 <rtems_ide_part_table_initialize+0xc4><== NOT EXECUTED
40005cc8: c2 06 a0 24 ld [ %i2 + 0x24 ], %g1 <== NOT EXECUTED
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
if (rc != RTEMS_SUCCESSFUL)
{
free(disk_desc);
40005ccc: 40 00 02 23 call 40006558 <free> <== NOT EXECUTED
40005cd0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
40005cd4: 81 c7 e0 08 ret <== NOT EXECUTED
40005cd8: 81 e8 00 00 restore <== NOT EXECUTED
4000a204 <rtems_io_register_driver>:
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
4000a204: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
4000a208: 03 10 00 73 sethi %hi(0x4001cc00), %g1
4000a20c: c4 00 63 b8 ld [ %g1 + 0x3b8 ], %g2 ! 4001cfb8 <_Per_CPU_Information+0x8>
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
4000a210: ba 10 00 18 mov %i0, %i5
rtems_device_major_number major_limit = _IO_Number_of_drivers;
4000a214: 03 10 00 74 sethi %hi(0x4001d000), %g1
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
4000a218: 86 10 00 19 mov %i1, %g3
rtems_device_major_number major_limit = _IO_Number_of_drivers;
4000a21c: c8 00 63 f8 ld [ %g1 + 0x3f8 ], %g4
if ( rtems_interrupt_is_in_progress() )
4000a220: 80 a0 a0 00 cmp %g2, 0
4000a224: 12 80 00 1f bne 4000a2a0 <rtems_io_register_driver+0x9c>
4000a228: b0 10 20 12 mov 0x12, %i0
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
4000a22c: 80 a6 a0 00 cmp %i2, 0
4000a230: 02 80 00 21 be 4000a2b4 <rtems_io_register_driver+0xb0>
4000a234: 80 a6 60 00 cmp %i1, 0
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
4000a238: 02 80 00 1f be 4000a2b4 <rtems_io_register_driver+0xb0>
4000a23c: c8 26 80 00 st %g4, [ %i2 ]
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
4000a240: c4 06 40 00 ld [ %i1 ], %g2
4000a244: 80 a0 a0 00 cmp %g2, 0
4000a248: 22 80 00 18 be,a 4000a2a8 <rtems_io_register_driver+0xa4>
4000a24c: c4 06 60 04 ld [ %i1 + 4 ], %g2
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
4000a250: 80 a1 00 1d cmp %g4, %i5
4000a254: 08 80 00 13 bleu 4000a2a0 <rtems_io_register_driver+0x9c>
4000a258: b0 10 20 0a mov 0xa, %i0
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
4000a25c: 05 10 00 72 sethi %hi(0x4001c800), %g2
4000a260: c8 00 a2 a0 ld [ %g2 + 0x2a0 ], %g4 ! 4001caa0 <_Thread_Dispatch_disable_level>
++level;
4000a264: 88 01 20 01 inc %g4
_Thread_Dispatch_disable_level = level;
4000a268: c8 20 a2 a0 st %g4, [ %g2 + 0x2a0 ]
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
4000a26c: 80 a7 60 00 cmp %i5, 0
4000a270: 02 80 00 13 be 4000a2bc <rtems_io_register_driver+0xb8>
4000a274: 39 10 00 74 sethi %hi(0x4001d000), %i4
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
4000a278: c8 07 23 fc ld [ %i4 + 0x3fc ], %g4 ! 4001d3fc <_IO_Driver_address_table>
4000a27c: 85 2f 60 03 sll %i5, 3, %g2
4000a280: b7 2f 60 05 sll %i5, 5, %i3
4000a284: 82 26 c0 02 sub %i3, %g2, %g1
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
4000a288: f2 01 00 01 ld [ %g4 + %g1 ], %i1
4000a28c: 80 a6 60 00 cmp %i1, 0
4000a290: 02 80 00 3a be 4000a378 <rtems_io_register_driver+0x174>
4000a294: 82 01 00 01 add %g4, %g1, %g1
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
4000a298: 40 00 08 ec call 4000c648 <_Thread_Enable_dispatch>
4000a29c: b0 10 20 0c mov 0xc, %i0
return RTEMS_RESOURCE_IN_USE;
4000a2a0: 81 c7 e0 08 ret
4000a2a4: 81 e8 00 00 restore
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
4000a2a8: 80 a0 a0 00 cmp %g2, 0
4000a2ac: 12 bf ff ea bne 4000a254 <rtems_io_register_driver+0x50>
4000a2b0: 80 a1 00 1d cmp %g4, %i5
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
4000a2b4: 81 c7 e0 08 ret
4000a2b8: 91 e8 20 09 restore %g0, 9, %o0
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
4000a2bc: c8 00 63 f8 ld [ %g1 + 0x3f8 ], %g4
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
4000a2c0: 80 a1 20 00 cmp %g4, 0
4000a2c4: 02 80 00 33 be 4000a390 <rtems_io_register_driver+0x18c> <== NEVER TAKEN
4000a2c8: c2 07 23 fc ld [ %i4 + 0x3fc ], %g1
4000a2cc: 30 80 00 04 b,a 4000a2dc <rtems_io_register_driver+0xd8>
4000a2d0: 80 a7 40 04 cmp %i5, %g4
4000a2d4: 02 80 00 24 be 4000a364 <rtems_io_register_driver+0x160>
4000a2d8: 82 00 60 18 add %g1, 0x18, %g1
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
4000a2dc: c4 00 40 00 ld [ %g1 ], %g2
4000a2e0: 80 a0 a0 00 cmp %g2, 0
4000a2e4: 32 bf ff fb bne,a 4000a2d0 <rtems_io_register_driver+0xcc>
4000a2e8: ba 07 60 01 inc %i5
4000a2ec: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000a2f0: 80 a0 a0 00 cmp %g2, 0
4000a2f4: 32 bf ff f7 bne,a 4000a2d0 <rtems_io_register_driver+0xcc>
4000a2f8: ba 07 60 01 inc %i5
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
4000a2fc: fa 26 80 00 st %i5, [ %i2 ]
4000a300: 85 2f 60 03 sll %i5, 3, %g2
if ( m != n )
4000a304: 80 a1 00 1d cmp %g4, %i5
4000a308: 02 80 00 18 be 4000a368 <rtems_io_register_driver+0x164> <== NEVER TAKEN
4000a30c: b7 2f 60 05 sll %i5, 5, %i3
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
4000a310: c8 00 c0 00 ld [ %g3 ], %g4
4000a314: c2 07 23 fc ld [ %i4 + 0x3fc ], %g1
4000a318: 84 26 c0 02 sub %i3, %g2, %g2
4000a31c: c8 20 40 02 st %g4, [ %g1 + %g2 ]
4000a320: c8 00 e0 04 ld [ %g3 + 4 ], %g4
4000a324: 82 00 40 02 add %g1, %g2, %g1
4000a328: c8 20 60 04 st %g4, [ %g1 + 4 ]
4000a32c: c4 00 e0 08 ld [ %g3 + 8 ], %g2
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
4000a330: b2 10 20 00 clr %i1
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
4000a334: c4 20 60 08 st %g2, [ %g1 + 8 ]
4000a338: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
4000a33c: b4 10 20 00 clr %i2
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
4000a340: c4 20 60 0c st %g2, [ %g1 + 0xc ]
4000a344: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
4000a348: b0 10 00 1d mov %i5, %i0
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
4000a34c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
4000a350: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2
_Thread_Enable_dispatch();
4000a354: 40 00 08 bd call 4000c648 <_Thread_Enable_dispatch>
4000a358: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
return rtems_io_initialize( major, 0, NULL );
4000a35c: 40 00 22 97 call 40012db8 <rtems_io_initialize>
4000a360: 81 e8 00 00 restore
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
4000a364: fa 26 80 00 st %i5, [ %i2 ]
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
4000a368: 40 00 08 b8 call 4000c648 <_Thread_Enable_dispatch>
4000a36c: b0 10 20 05 mov 5, %i0
return sc;
4000a370: 81 c7 e0 08 ret
4000a374: 81 e8 00 00 restore
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
4000a378: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000a37c: 80 a0 60 00 cmp %g1, 0
4000a380: 12 bf ff c6 bne 4000a298 <rtems_io_register_driver+0x94>
4000a384: 01 00 00 00 nop
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
4000a388: 10 bf ff e2 b 4000a310 <rtems_io_register_driver+0x10c>
4000a38c: fa 26 80 00 st %i5, [ %i2 ]
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
4000a390: 10 bf ff f6 b 4000a368 <rtems_io_register_driver+0x164> <== NOT EXECUTED
4000a394: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
4000b360 <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)
{
4000b360: 9d e3 bf a0 save %sp, -96, %sp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
4000b364: 80 a6 20 00 cmp %i0, 0
4000b368: 02 80 00 20 be 4000b3e8 <rtems_iterate_over_all_threads+0x88><== NEVER TAKEN
4000b36c: 37 10 00 8b sethi %hi(0x40022c00), %i3
4000b370: b6 16 e2 48 or %i3, 0x248, %i3 ! 40022e48 <_Objects_Information_table+0x4>
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
4000b374: b4 06 e0 0c add %i3, 0xc, %i2
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
4000b378: c2 06 c0 00 ld [ %i3 ], %g1
4000b37c: f8 00 60 04 ld [ %g1 + 4 ], %i4
if ( !information )
4000b380: 80 a7 20 00 cmp %i4, 0
4000b384: 22 80 00 16 be,a 4000b3dc <rtems_iterate_over_all_threads+0x7c>
4000b388: b6 06 e0 04 add %i3, 4, %i3
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
4000b38c: c2 17 20 10 lduh [ %i4 + 0x10 ], %g1
4000b390: 86 90 60 00 orcc %g1, 0, %g3
4000b394: 22 80 00 12 be,a 4000b3dc <rtems_iterate_over_all_threads+0x7c>
4000b398: b6 06 e0 04 add %i3, 4, %i3
4000b39c: ba 10 20 01 mov 1, %i5
the_thread = (Thread_Control *)information->local_table[ i ];
4000b3a0: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
4000b3a4: 83 2f 60 02 sll %i5, 2, %g1
4000b3a8: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( !the_thread )
4000b3ac: 90 90 60 00 orcc %g1, 0, %o0
4000b3b0: 02 80 00 05 be 4000b3c4 <rtems_iterate_over_all_threads+0x64><== NEVER TAKEN
4000b3b4: ba 07 60 01 inc %i5
continue;
(*routine)(the_thread);
4000b3b8: 9f c6 00 00 call %i0
4000b3bc: 01 00 00 00 nop
4000b3c0: c6 17 20 10 lduh [ %i4 + 0x10 ], %g3
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
4000b3c4: 83 28 e0 10 sll %g3, 0x10, %g1
4000b3c8: 83 30 60 10 srl %g1, 0x10, %g1
4000b3cc: 80 a0 40 1d cmp %g1, %i5
4000b3d0: 3a bf ff f5 bcc,a 4000b3a4 <rtems_iterate_over_all_threads+0x44>
4000b3d4: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
4000b3d8: b6 06 e0 04 add %i3, 4, %i3
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
4000b3dc: 80 a6 c0 1a cmp %i3, %i2
4000b3e0: 32 bf ff e7 bne,a 4000b37c <rtems_iterate_over_all_threads+0x1c>
4000b3e4: c2 06 c0 00 ld [ %i3 ], %g1
4000b3e8: 81 c7 e0 08 ret
4000b3ec: 81 e8 00 00 restore
40004358 <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 )
{
40004358: 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)
4000435c: 03 10 00 7d sethi %hi(0x4001f400), %g1
40004360: fa 00 61 a4 ld [ %g1 + 0x1a4 ], %i5 ! 4001f5a4 <rtems_libio_number_iops>
40004364: 80 a7 60 00 cmp %i5, 0
40004368: 02 80 00 1b be 400043d4 <rtems_libio_init+0x7c> <== NEVER TAKEN
4000436c: 92 10 20 01 mov 1, %o1
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
40004370: 90 10 00 1d mov %i5, %o0
40004374: 7f ff fe f6 call 40003f4c <calloc>
40004378: 92 10 20 38 mov 0x38, %o1
4000437c: 03 10 00 80 sethi %hi(0x40020000), %g1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
40004380: 80 a2 20 00 cmp %o0, 0
40004384: 02 80 00 28 be 40004424 <rtems_libio_init+0xcc>
40004388: d0 20 61 24 st %o0, [ %g1 + 0x124 ]
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
4000438c: 03 10 00 80 sethi %hi(0x40020000), %g1
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
40004390: 80 a7 60 01 cmp %i5, 1
40004394: 08 80 00 0e bleu 400043cc <rtems_libio_init+0x74>
40004398: d0 20 61 28 st %o0, [ %g1 + 0x128 ]
4000439c: 82 10 00 08 mov %o0, %g1
400043a0: 84 10 20 01 mov 1, %g2
iop->data1 = iop + 1;
400043a4: 82 00 60 38 add %g1, 0x38, %g1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
400043a8: 84 00 a0 01 inc %g2
400043ac: 80 a0 80 1d cmp %g2, %i5
400043b0: 12 bf ff fd bne 400043a4 <rtems_libio_init+0x4c>
400043b4: c2 20 7f f8 st %g1, [ %g1 + -8 ]
rtems_id rtems_libio_semaphore;
rtems_libio_t *rtems_libio_iops;
rtems_libio_t *rtems_libio_iop_freelist;
void rtems_libio_init( void )
400043b8: 84 00 bf ff add %g2, -1, %g2
400043bc: 83 28 a0 03 sll %g2, 3, %g1
400043c0: 85 28 a0 06 sll %g2, 6, %g2
400043c4: 84 20 80 01 sub %g2, %g1, %g2
400043c8: 90 02 00 02 add %o0, %g2, %o0
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
iop->data1 = iop + 1;
iop->data1 = NULL;
400043cc: c0 22 20 30 clr [ %o0 + 0x30 ]
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
400043d0: 92 10 20 01 mov 1, %o1
400043d4: 11 13 10 92 sethi %hi(0x4c424800), %o0
400043d8: 94 10 20 54 mov 0x54, %o2
400043dc: 90 12 21 4f or %o0, 0x14f, %o0
400043e0: 96 10 20 00 clr %o3
400043e4: 19 10 00 80 sethi %hi(0x40020000), %o4
400043e8: 40 00 0f c1 call 400082ec <rtems_semaphore_create>
400043ec: 98 13 21 2c or %o4, 0x12c, %o4 ! 4002012c <rtems_libio_semaphore>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
400043f0: 80 a2 20 00 cmp %o0, 0
400043f4: 12 80 00 0a bne 4000441c <rtems_libio_init+0xc4> <== NEVER TAKEN
400043f8: 03 10 00 7d sethi %hi(0x4001f400), %g1
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
400043fc: c2 00 61 a8 ld [ %g1 + 0x1a8 ], %g1 ! 4001f5a8 <rtems_fs_init_helper>
40004400: 80 a0 60 00 cmp %g1, 0
40004404: 02 80 00 04 be 40004414 <rtems_libio_init+0xbc>
40004408: 01 00 00 00 nop
(* rtems_fs_init_helper)();
4000440c: 9f c0 40 00 call %g1
40004410: 01 00 00 00 nop
40004414: 81 c7 e0 08 ret
40004418: 81 e8 00 00 restore
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
rtems_fatal_error_occurred( rc );
4000441c: 40 00 12 41 call 40008d20 <rtems_fatal_error_occurred> <== NOT EXECUTED
40004420: 01 00 00 00 nop <== NOT EXECUTED
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
40004424: 40 00 12 3f call 40008d20 <rtems_fatal_error_occurred>
40004428: 90 10 20 1a mov 0x1a, %o0 ! 1a <PROM_START+0x1a>
4000564c <rtems_libio_set_private_env>:
}
rtems_status_code rtems_libio_set_private_env(void)
{
4000564c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
40005650: 40 00 06 73 call 4000701c <rtems_task_self>
40005654: 37 10 00 4d sethi %hi(0x40013400), %i3
rtems_user_env_t *old_env = rtems_current_user_env;
40005658: fa 06 e2 08 ld [ %i3 + 0x208 ], %i5 ! 40013608 <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;
4000565c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
if (uses_global_env || uses_shared_env) {
40005660: 80 a0 40 08 cmp %g1, %o0
40005664: 12 80 00 07 bne 40005680 <rtems_libio_set_private_env+0x34>
40005668: b8 10 00 08 mov %o0, %i4
rtems_status_code rtems_libio_set_private_env(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
rtems_user_env_t *old_env = rtems_current_user_env;
bool uses_global_env = old_env == &rtems_global_user_env;
4000566c: 03 10 00 4d sethi %hi(0x40013400), %g1
40005670: 82 10 62 0c or %g1, 0x20c, %g1 ! 4001360c <rtems_global_user_env>
bool uses_shared_env = old_env->task_id != self_task_id;
if (uses_global_env || uses_shared_env) {
40005674: 80 a7 40 01 cmp %i5, %g1
40005678: 12 80 00 2a bne 40005720 <rtems_libio_set_private_env+0xd4><== ALWAYS TAKEN
4000567c: b0 10 20 00 clr %i0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
40005680: 90 10 20 01 mov 1, %o0
40005684: 92 10 20 2c mov 0x2c, %o1
40005688: 40 00 14 a6 call 4000a920 <calloc>
4000568c: b0 10 20 1a mov 0x1a, %i0
if (new_env != NULL) {
40005690: 80 a2 20 00 cmp %o0, 0
40005694: 02 80 00 23 be 40005720 <rtems_libio_set_private_env+0xd4>
40005698: b4 10 00 08 mov %o0, %i2
*new_env = *old_env;
4000569c: 92 10 00 1d mov %i5, %o1
400056a0: 40 00 20 b0 call 4000d960 <memcpy>
400056a4: 94 10 20 2c mov 0x2c, %o2
new_env->reference_count = 1;
400056a8: 82 10 20 01 mov 1, %g1
new_env->task_id = self_task_id;
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
400056ac: 90 07 60 04 add %i5, 4, %o0
if (uses_global_env || uses_shared_env) {
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
if (new_env != NULL) {
*new_env = *old_env;
new_env->reference_count = 1;
400056b0: c2 26 a0 28 st %g1, [ %i2 + 0x28 ]
new_env->task_id = self_task_id;
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
400056b4: 40 00 03 10 call 400062f4 <rtems_filesystem_global_location_obtain>
400056b8: f8 26 a0 24 st %i4, [ %i2 + 0x24 ]
if (new_env != NULL) {
*new_env = *old_env;
new_env->reference_count = 1;
new_env->task_id = self_task_id;
new_env->root_directory =
400056bc: d0 26 a0 04 st %o0, [ %i2 + 4 ]
rtems_filesystem_global_location_obtain(&old_env->root_directory);
new_env->current_directory =
rtems_filesystem_global_location_obtain(&old_env->current_directory);
400056c0: 40 00 03 0d call 400062f4 <rtems_filesystem_global_location_obtain>
400056c4: 90 10 00 1d mov %i5, %o0
static inline bool rtems_filesystem_location_is_null(
const rtems_filesystem_location_info_t *loc
)
{
return loc->handlers == &rtems_filesystem_null_handlers;
400056c8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
*new_env = *old_env;
new_env->reference_count = 1;
new_env->task_id = self_task_id;
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
new_env->current_directory =
400056cc: d0 26 80 00 st %o0, [ %i2 ]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
if (
400056d0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
400056d4: 03 10 00 4b sethi %hi(0x40012c00), %g1
400056d8: 82 10 62 d4 or %g1, 0x2d4, %g1 ! 40012ed4 <rtems_filesystem_null_handlers>
400056dc: 80 a0 80 01 cmp %g2, %g1
400056e0: 22 80 00 0e be,a 40005718 <rtems_libio_set_private_env+0xcc>
400056e4: 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)
400056e8: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
400056ec: 80 a0 80 01 cmp %g2, %g1
400056f0: 02 80 00 0e be 40005728 <rtems_libio_set_private_env+0xdc><== NEVER TAKEN
400056f4: 90 10 20 00 clr %o0
) {
sc = rtems_task_variable_add(
400056f8: 92 16 e2 08 or %i3, 0x208, %o1
400056fc: 15 10 00 15 sethi %hi(0x40005400), %o2
40005700: 40 00 06 69 call 400070a4 <rtems_task_variable_add>
40005704: 94 12 a1 dc or %o2, 0x1dc, %o2 ! 400055dc <free_user_env>
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
40005708: b0 92 20 00 orcc %o0, 0, %i0
4000570c: 02 80 00 09 be 40005730 <rtems_libio_set_private_env+0xe4>
40005710: 01 00 00 00 nop
free_user_env_protected(old_env);
rtems_current_user_env = new_env;
} else {
sc = RTEMS_TOO_MANY;
40005714: b0 10 20 05 mov 5, %i0 ! 5 <PROM_START+0x5>
} else {
sc = RTEMS_UNSATISFIED;
}
if (sc != RTEMS_SUCCESSFUL) {
free_user_env(new_env);
40005718: 7f ff ff b1 call 400055dc <free_user_env>
4000571c: 90 10 00 1a mov %i2, %o0
sc = RTEMS_NO_MEMORY;
}
}
return sc;
}
40005720: 81 c7 e0 08 ret
40005724: 81 e8 00 00 restore
rtems_current_user_env = new_env;
} else {
sc = RTEMS_TOO_MANY;
}
} else {
sc = RTEMS_UNSATISFIED;
40005728: 10 bf ff fc b 40005718 <rtems_libio_set_private_env+0xcc> <== NOT EXECUTED
4000572c: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
free_user_env_protected(old_env);
40005730: 7f ff ff be call 40005628 <free_user_env_protected>
40005734: 90 10 00 1d mov %i5, %o0
rtems_current_user_env = new_env;
40005738: 03 10 00 4d sethi %hi(0x40013400), %g1
4000573c: f4 20 62 08 st %i2, [ %g1 + 0x208 ] ! 40013608 <rtems_current_user_env>
40005740: 81 c7 e0 08 ret
40005744: 81 e8 00 00 restore
40005748 <rtems_libio_share_private_env>:
return sc;
}
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
40005748: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
4000574c: 40 00 06 34 call 4000701c <rtems_task_self>
40005750: 01 00 00 00 nop
if (task_id != RTEMS_SELF && self_task_id != task_id) {
40005754: 80 a2 00 18 cmp %o0, %i0
40005758: 12 80 00 04 bne 40005768 <rtems_libio_share_private_env+0x20>
4000575c: 80 a6 20 00 cmp %i0, 0
return sc;
}
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
40005760: 81 c7 e0 08 ret
40005764: 91 e8 20 00 restore %g0, 0, %o0
rtems_id self_task_id = rtems_task_self();
if (task_id != RTEMS_SELF && self_task_id != task_id) {
40005768: 02 bf ff fe be 40005760 <rtems_libio_share_private_env+0x18>
4000576c: 03 10 00 50 sethi %hi(0x40014000), %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;
40005770: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 400140f0 <_Thread_Dispatch_disable_level>
++level;
40005774: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40005778: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ]
/*
* We have to disable the thread dispatching to prevent deletion of the
* environment in the meantime.
*/
_Thread_Disable_dispatch();
sc = rtems_task_variable_get(
4000577c: 3b 10 00 4d sethi %hi(0x40013400), %i5
40005780: 90 10 00 18 mov %i0, %o0
40005784: 92 17 62 08 or %i5, 0x208, %o1
40005788: 40 00 06 a7 call 40007224 <rtems_task_variable_get>
4000578c: 94 07 bf fc add %fp, -4, %o2
task_id,
(void *) &rtems_current_user_env,
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
40005790: 80 a2 20 00 cmp %o0, 0
40005794: 12 80 00 14 bne 400057e4 <rtems_libio_share_private_env+0x9c>
40005798: c2 07 bf fc ld [ %fp + -4 ], %g1
++env->reference_count;
4000579c: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
400057a0: 84 00 a0 01 inc %g2
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
400057a4: 40 00 0f 1c call 40009414 <_Thread_Enable_dispatch>
400057a8: c4 20 60 28 st %g2, [ %g1 + 0x28 ]
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_task_variable_add(
400057ac: 90 10 20 00 clr %o0
400057b0: 92 17 62 08 or %i5, 0x208, %o1
400057b4: 15 10 00 15 sethi %hi(0x40005400), %o2
400057b8: 40 00 06 3b call 400070a4 <rtems_task_variable_add>
400057bc: 94 12 a1 dc or %o2, 0x1dc, %o2 ! 400055dc <free_user_env>
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
400057c0: b0 92 20 00 orcc %o0, 0, %i0
400057c4: 12 80 00 0c bne 400057f4 <rtems_libio_share_private_env+0xac><== NEVER TAKEN
400057c8: d0 07 bf fc ld [ %fp + -4 ], %o0
free_user_env_protected(rtems_current_user_env);
400057cc: 7f ff ff 97 call 40005628 <free_user_env_protected>
400057d0: d0 07 62 08 ld [ %i5 + 0x208 ], %o0
rtems_current_user_env = env;
400057d4: c2 07 bf fc ld [ %fp + -4 ], %g1
400057d8: c2 27 62 08 st %g1, [ %i5 + 0x208 ]
400057dc: 81 c7 e0 08 ret
400057e0: 81 e8 00 00 restore
if (sc == RTEMS_SUCCESSFUL) {
++env->reference_count;
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
400057e4: 40 00 0f 0c call 40009414 <_Thread_Enable_dispatch>
400057e8: b0 10 20 0d mov 0xd, %i0
}
}
}
return sc;
}
400057ec: 81 c7 e0 08 ret
400057f0: 81 e8 00 00 restore
);
if (sc == RTEMS_SUCCESSFUL) {
free_user_env_protected(rtems_current_user_env);
rtems_current_user_env = env;
} else {
free_user_env_protected(env);
400057f4: 7f ff ff 8d call 40005628 <free_user_env_protected> <== NOT EXECUTED
400057f8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
400057fc: 81 c7 e0 08 ret <== NOT EXECUTED
40005800: 81 e8 00 00 restore <== NOT EXECUTED
4000d140 <rtems_libio_to_fcntl_flags>:
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
4000d140: 82 10 00 08 mov %o0, %g1
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
4000d144: 84 08 60 06 and %g1, 6, %g2
4000d148: 80 a0 a0 06 cmp %g2, 6
4000d14c: 02 80 00 05 be 4000d160 <rtems_libio_to_fcntl_flags+0x20>
4000d150: 90 10 20 02 mov 2, %o0
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
4000d154: 80 88 60 02 btst 2, %g1
4000d158: 02 80 00 0e be 4000d190 <rtems_libio_to_fcntl_flags+0x50> <== NEVER TAKEN
4000d15c: 90 10 20 00 clr %o0
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
4000d160: 80 88 60 01 btst 1, %g1
4000d164: 02 80 00 04 be 4000d174 <rtems_libio_to_fcntl_flags+0x34>
4000d168: 80 88 62 00 btst 0x200, %g1
fcntl_flags |= O_NONBLOCK;
4000d16c: 05 00 00 10 sethi %hi(0x4000), %g2
4000d170: 90 12 00 02 or %o0, %g2, %o0
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
4000d174: 32 80 00 02 bne,a 4000d17c <rtems_libio_to_fcntl_flags+0x3c>
4000d178: 90 12 20 08 or %o0, 8, %o0
fcntl_flags |= O_APPEND;
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
4000d17c: 80 88 64 00 btst 0x400, %g1
4000d180: 32 80 00 02 bne,a 4000d188 <rtems_libio_to_fcntl_flags+0x48>
4000d184: 90 12 22 00 or %o0, 0x200, %o0
fcntl_flags |= O_CREAT;
}
return fcntl_flags;
}
4000d188: 81 c3 e0 08 retl
4000d18c: 01 00 00 00 nop
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
4000d190: 91 30 60 02 srl %g1, 2, %o0 <== NOT EXECUTED
4000d194: 10 bf ff f3 b 4000d160 <rtems_libio_to_fcntl_flags+0x20> <== NOT EXECUTED
4000d198: 90 0a 20 01 and %o0, 1, %o0 <== NOT EXECUTED
40005804 <rtems_libio_use_global_env>:
return sc;
}
void rtems_libio_use_global_env(void)
{
40005804: 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) {
40005808: 3b 10 00 4d sethi %hi(0x40013400), %i5
4000580c: c2 07 62 08 ld [ %i5 + 0x208 ], %g1 ! 40013608 <rtems_current_user_env>
40005810: 39 10 00 4d sethi %hi(0x40013400), %i4
40005814: b8 17 22 0c or %i4, 0x20c, %i4 ! 4001360c <rtems_global_user_env>
40005818: 80 a0 40 1c cmp %g1, %i4
4000581c: 02 80 00 08 be 4000583c <rtems_libio_use_global_env+0x38>
40005820: 92 17 62 08 or %i5, 0x208, %o1
sc = rtems_task_variable_delete(
40005824: 40 00 06 52 call 4000716c <rtems_task_variable_delete>
40005828: 90 10 20 00 clr %o0
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
4000582c: 80 a2 20 00 cmp %o0, 0
40005830: 12 80 00 05 bne 40005844 <rtems_libio_use_global_env+0x40><== NEVER TAKEN
40005834: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
}
rtems_current_user_env = &rtems_global_user_env;
40005838: f8 27 62 08 st %i4, [ %i5 + 0x208 ]
4000583c: 81 c7 e0 08 ret
40005840: 81 e8 00 00 restore
sc = rtems_task_variable_delete(
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
40005844: 40 00 07 0c call 40007474 <rtems_fatal_error_occurred> <== NOT EXECUTED
40005848: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
40008aa0 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
40008aa0: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
40008aa4: 03 10 00 97 sethi %hi(0x40025c00), %g1
40008aa8: d0 00 63 b4 ld [ %g1 + 0x3b4 ], %o0 ! 40025fb4 <RTEMS_Malloc_Heap>
40008aac: 92 10 00 18 mov %i0, %o1
40008ab0: 40 00 1c f7 call 4000fe8c <_Protected_heap_Get_block_size>
40008ab4: 94 07 bf fc add %fp, -4, %o2
40008ab8: 80 8a 20 ff btst 0xff, %o0
40008abc: 02 80 00 08 be 40008adc <rtems_malloc_statistics_at_free+0x3c><== NEVER TAKEN
40008ac0: 03 10 00 9d sethi %hi(0x40027400), %g1
MSBUMP(lifetime_freed, size);
40008ac4: c8 07 bf fc ld [ %fp + -4 ], %g4
40008ac8: 82 10 60 68 or %g1, 0x68, %g1
40008acc: c4 18 60 28 ldd [ %g1 + 0x28 ], %g2
40008ad0: 86 80 c0 04 addcc %g3, %g4, %g3
40008ad4: 84 40 a0 00 addx %g2, 0, %g2
40008ad8: c4 38 60 28 std %g2, [ %g1 + 0x28 ]
40008adc: 81 c7 e0 08 ret
40008ae0: 81 e8 00 00 restore
40008ae4 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
40008ae4: 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 )
40008ae8: 80 a6 20 00 cmp %i0, 0
40008aec: 02 80 00 14 be 40008b3c <rtems_malloc_statistics_at_malloc+0x58><== NEVER TAKEN
40008af0: c0 27 bf fc clr [ %fp + -4 ]
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
40008af4: 03 10 00 97 sethi %hi(0x40025c00), %g1
40008af8: d0 00 63 b4 ld [ %g1 + 0x3b4 ], %o0 ! 40025fb4 <RTEMS_Malloc_Heap>
40008afc: 92 10 00 18 mov %i0, %o1
40008b00: 40 00 1c e3 call 4000fe8c <_Protected_heap_Get_block_size>
40008b04: 94 07 bf fc add %fp, -4, %o2
MSBUMP(lifetime_allocated, actual_size);
40008b08: 03 10 00 9d sethi %hi(0x40027400), %g1
40008b0c: f8 07 bf fc ld [ %fp + -4 ], %i4
40008b10: 82 10 60 68 or %g1, 0x68, %g1
40008b14: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
40008b18: fa 00 60 2c ld [ %g1 + 0x2c ], %i5
if (current_depth > s->max_depth)
40008b1c: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
if ( !pointer )
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
MSBUMP(lifetime_allocated, actual_size);
40008b20: 86 80 c0 1c addcc %g3, %i4, %g3
40008b24: 84 40 a0 00 addx %g2, 0, %g2
40008b28: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
40008b2c: 84 20 c0 1d sub %g3, %i5, %g2
if (current_depth > s->max_depth)
40008b30: 80 a0 80 04 cmp %g2, %g4
40008b34: 38 80 00 02 bgu,a 40008b3c <rtems_malloc_statistics_at_malloc+0x58>
40008b38: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
40008b3c: 81 c7 e0 08 ret
40008b40: 81 e8 00 00 restore
40011a14 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
40011a14: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
40011a18: ba 96 20 00 orcc %i0, 0, %i5
40011a1c: 02 80 00 21 be 40011aa0 <rtems_memalign+0x8c>
40011a20: 03 10 00 73 sethi %hi(0x4001cc00), %g1
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
40011a24: c2 00 63 a8 ld [ %g1 + 0x3a8 ], %g1 ! 4001cfa8 <_System_state_Current>
40011a28: 80 a0 60 03 cmp %g1, 3
40011a2c: 02 80 00 18 be 40011a8c <rtems_memalign+0x78>
40011a30: c0 27 40 00 clr [ %i5 ]
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
40011a34: 7f ff cf 4b call 40005760 <malloc_deferred_frees_process>
40011a38: b0 10 20 0c mov 0xc, %i0
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
40011a3c: 03 10 00 6f sethi %hi(0x4001bc00), %g1
40011a40: d0 00 60 c8 ld [ %g1 + 0xc8 ], %o0 ! 4001bcc8 <RTEMS_Malloc_Heap>
40011a44: 92 10 00 1a mov %i2, %o1
40011a48: 94 10 00 19 mov %i1, %o2
40011a4c: 7f ff e7 c7 call 4000b968 <_Protected_heap_Allocate_aligned_with_boundary>
40011a50: 96 10 20 00 clr %o3
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
40011a54: 80 a2 20 00 cmp %o0, 0
40011a58: 02 80 00 14 be 40011aa8 <rtems_memalign+0x94>
40011a5c: b8 10 00 08 mov %o0, %i4
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
40011a60: 03 10 00 70 sethi %hi(0x4001c000), %g1
40011a64: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 4001c3d0 <rtems_malloc_statistics_helpers>
40011a68: 80 a0 60 00 cmp %g1, 0
40011a6c: 22 80 00 06 be,a 40011a84 <rtems_memalign+0x70>
40011a70: f8 27 40 00 st %i4, [ %i5 ]
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
40011a74: c2 00 60 04 ld [ %g1 + 4 ], %g1
40011a78: 9f c0 40 00 call %g1
40011a7c: 90 10 00 1d mov %i5, %o0
*pointer = return_this;
40011a80: f8 27 40 00 st %i4, [ %i5 ]
return 0;
}
40011a84: 81 c7 e0 08 ret
40011a88: 91 e8 20 00 restore %g0, 0, %o0
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
40011a8c: 7f ff cf 28 call 4000572c <malloc_is_system_state_OK>
40011a90: 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()) &&
40011a94: 80 8a 20 ff btst 0xff, %o0
40011a98: 12 bf ff e7 bne 40011a34 <rtems_memalign+0x20> <== ALWAYS TAKEN
40011a9c: 01 00 00 00 nop
/*
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
40011aa0: 81 c7 e0 08 ret
40011aa4: 91 e8 20 16 restore %g0, 0x16, %o0
40011aa8: 81 c7 e0 08 ret
40011aac: 81 e8 00 00 restore
4000a56c <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
4000a56c: 9d e3 bf 58 save %sp, -168, %sp
int success = 0;
char *dup_path = strdup(path);
4000a570: 40 00 6d b5 call 40025c44 <strdup>
4000a574: 90 10 00 18 mov %i0, %o0
if (dup_path != NULL) {
4000a578: b6 92 20 00 orcc %o0, 0, %i3
4000a57c: 02 80 00 69 be 4000a720 <rtems_mkdir+0x1b4>
4000a580: 01 00 00 00 nop
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
4000a584: c2 0e c0 00 ldub [ %i3 ], %g1
4000a588: 83 28 60 18 sll %g1, 0x18, %g1
4000a58c: 85 38 60 18 sra %g1, 0x18, %g2
4000a590: 80 a0 a0 2f cmp %g2, 0x2f
4000a594: 02 80 00 57 be 4000a6f0 <rtems_mkdir+0x184>
4000a598: ba 10 00 1b mov %i3, %i5
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
4000a59c: 83 38 60 18 sra %g1, 0x18, %g1
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
4000a5a0: b4 10 20 00 clr %i2
4000a5a4: 84 10 20 01 mov 1, %g2
retval = 0;
break;
}
}
if (!last)
*p = '/';
4000a5a8: b0 10 20 2f mov 0x2f, %i0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
4000a5ac: 23 00 00 3c sethi %hi(0xf000), %l1
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
4000a5b0: 80 a0 60 00 cmp %g1, 0
4000a5b4: 02 80 00 0b be 4000a5e0 <rtems_mkdir+0x74> <== NEVER TAKEN
4000a5b8: 21 00 00 10 sethi %hi(0x4000), %l0
last = 1;
else if (p[0] != '/')
4000a5bc: 80 a0 60 2f cmp %g1, 0x2f
4000a5c0: 22 80 00 2f be,a 4000a67c <rtems_mkdir+0x110>
4000a5c4: c2 4f 60 01 ldsb [ %i5 + 1 ], %g1
4000a5c8: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
4000a5cc: 83 28 60 18 sll %g1, 0x18, %g1
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
4000a5d0: 83 38 60 18 sra %g1, 0x18, %g1
4000a5d4: 80 a0 60 00 cmp %g1, 0
4000a5d8: 12 bf ff f9 bne 4000a5bc <rtems_mkdir+0x50>
4000a5dc: ba 07 60 01 inc %i5
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
4000a5e0: c0 2f 40 00 clrb [ %i5 ]
4000a5e4: b8 10 20 01 mov 1, %i4
if (!last && p[1] == '\0')
last = 1;
if (first) {
4000a5e8: 80 a0 a0 00 cmp %g2, 0
4000a5ec: 12 80 00 1d bne 4000a660 <rtems_mkdir+0xf4>
4000a5f0: 01 00 00 00 nop
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
4000a5f4: 80 a7 20 00 cmp %i4, 0
4000a5f8: 12 80 00 0a bne 4000a620 <rtems_mkdir+0xb4>
4000a5fc: 90 10 00 1b mov %i3, %o0
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4000a600: 7f ff fc a4 call 40009890 <mkdir>
4000a604: 92 10 21 ff mov 0x1ff, %o1
4000a608: 80 a2 20 00 cmp %o0, 0
4000a60c: 06 80 00 20 bl 4000a68c <rtems_mkdir+0x120>
4000a610: 01 00 00 00 nop
retval = 0;
break;
}
}
if (!last)
*p = '/';
4000a614: f0 2f 40 00 stb %i0, [ %i5 ]
4000a618: 10 bf ff ec b 4000a5c8 <rtems_mkdir+0x5c>
4000a61c: 84 10 20 00 clr %g2
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
4000a620: 40 00 0a a8 call 4000d0c0 <umask>
4000a624: 90 10 00 1a mov %i2, %o0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4000a628: 90 10 00 1b mov %i3, %o0
4000a62c: 7f ff fc 99 call 40009890 <mkdir>
4000a630: 92 10 00 19 mov %i1, %o1
4000a634: 80 a2 20 00 cmp %o0, 0
4000a638: 06 80 00 15 bl 4000a68c <rtems_mkdir+0x120>
4000a63c: 01 00 00 00 nop
4000a640: ba 10 20 01 mov 1, %i5 ! 1 <PROM_START+0x1>
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
4000a644: 7f ff fa b9 call 40009128 <free>
4000a648: 90 10 00 1b mov %i3, %o0
}
return success != 0 ? 0 : -1;
4000a64c: 80 a7 60 00 cmp %i5, 0
4000a650: 02 80 00 34 be 4000a720 <rtems_mkdir+0x1b4> <== NEVER TAKEN
4000a654: b0 10 20 00 clr %i0
}
4000a658: 81 c7 e0 08 ret
4000a65c: 81 e8 00 00 restore
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
4000a660: 40 00 0a 98 call 4000d0c0 <umask>
4000a664: 90 10 20 00 clr %o0
4000a668: b4 10 00 08 mov %o0, %i2
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
4000a66c: 40 00 0a 95 call 4000d0c0 <umask>
4000a670: 90 0a 3f 3f and %o0, -193, %o0
first = 0;
}
if (last)
4000a674: 10 bf ff e1 b 4000a5f8 <rtems_mkdir+0x8c>
4000a678: 80 a7 20 00 cmp %i4, 0
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
4000a67c: c0 2f 40 00 clrb [ %i5 ]
4000a680: 80 a0 00 01 cmp %g0, %g1
4000a684: 10 bf ff d9 b 4000a5e8 <rtems_mkdir+0x7c>
4000a688: b8 60 3f ff subx %g0, -1, %i4
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
4000a68c: 40 00 65 2b call 40023b38 <__errno>
4000a690: 01 00 00 00 nop
4000a694: c2 02 00 00 ld [ %o0 ], %g1
4000a698: 80 a0 60 11 cmp %g1, 0x11
4000a69c: 02 80 00 08 be 4000a6bc <rtems_mkdir+0x150>
4000a6a0: 90 10 00 1b mov %i3, %o0
4000a6a4: 40 00 65 25 call 40023b38 <__errno>
4000a6a8: 01 00 00 00 nop
4000a6ac: c2 02 00 00 ld [ %o0 ], %g1
4000a6b0: 80 a0 60 15 cmp %g1, 0x15
4000a6b4: 12 80 00 28 bne 4000a754 <rtems_mkdir+0x1e8> <== ALWAYS TAKEN
4000a6b8: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
4000a6bc: 40 00 00 2a call 4000a764 <stat>
4000a6c0: 92 07 bf b8 add %fp, -72, %o1
4000a6c4: 80 a2 20 00 cmp %o0, 0
4000a6c8: 06 80 00 23 bl 4000a754 <rtems_mkdir+0x1e8> <== NEVER TAKEN
4000a6cc: c2 07 bf c4 ld [ %fp + -60 ], %g1
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
4000a6d0: 82 08 40 11 and %g1, %l1, %g1
4000a6d4: 80 a0 40 10 cmp %g1, %l0
4000a6d8: 12 80 00 0a bne 4000a700 <rtems_mkdir+0x194>
4000a6dc: 80 a7 20 00 cmp %i4, 0
else
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
4000a6e0: 22 bf ff ce be,a 4000a618 <rtems_mkdir+0xac>
4000a6e4: f0 2f 40 00 stb %i0, [ %i5 ]
retval = 2;
4000a6e8: 10 bf ff d7 b 4000a644 <rtems_mkdir+0xd8>
4000a6ec: ba 10 20 02 mov 2, %i5
4000a6f0: c2 0e e0 01 ldub [ %i3 + 1 ], %g1
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
4000a6f4: ba 06 e0 01 add %i3, 1, %i5
4000a6f8: 10 bf ff a9 b 4000a59c <rtems_mkdir+0x30>
4000a6fc: 83 28 60 18 sll %g1, 0x18, %g1
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
4000a700: 02 80 00 0a be 4000a728 <rtems_mkdir+0x1bc>
4000a704: 01 00 00 00 nop
errno = EEXIST;
4000a708: 40 00 65 0c call 40023b38 <__errno>
4000a70c: 01 00 00 00 nop
4000a710: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
4000a714: c2 22 00 00 st %g1, [ %o0 ]
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
4000a718: 7f ff fa 84 call 40009128 <free>
4000a71c: 90 10 00 1b mov %i3, %o0
}
return success != 0 ? 0 : -1;
4000a720: 81 c7 e0 08 ret
4000a724: 91 e8 3f ff restore %g0, -1, %o0
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
4000a728: 40 00 65 04 call 40023b38 <__errno>
4000a72c: 01 00 00 00 nop
4000a730: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
4000a734: c2 22 00 00 st %g1, [ %o0 ]
}
if (!last)
*p = '/';
}
if (!first && !last)
(void)umask(oumask);
4000a738: 40 00 0a 62 call 4000d0c0 <umask>
4000a73c: 90 10 00 1a mov %i2, %o0
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
4000a740: 90 10 00 1b mov %i3, %o0
4000a744: 7f ff fa 79 call 40009128 <free>
4000a748: b0 10 3f ff mov -1, %i0
4000a74c: 81 c7 e0 08 ret
4000a750: 81 e8 00 00 restore
}
}
if (!last)
*p = '/';
}
if (!first && !last)
4000a754: 80 a7 20 00 cmp %i4, 0
4000a758: 02 bf ff f8 be 4000a738 <rtems_mkdir+0x1cc> <== NEVER TAKEN
4000a75c: 90 10 00 1b mov %i3, %o0
4000a760: 30 bf ff f9 b,a 4000a744 <rtems_mkdir+0x1d8>
40009f68 <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
int the_api,
int the_class,
rtems_object_api_class_information *info
)
{
40009f68: 9d e3 bf a0 save %sp, -96, %sp
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
40009f6c: 80 a6 a0 00 cmp %i2, 0
40009f70: 02 80 00 21 be 40009ff4 <rtems_object_get_class_information+0x8c>
40009f74: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
40009f78: 93 2e 60 10 sll %i1, 0x10, %o1
40009f7c: 90 10 00 18 mov %i0, %o0
40009f80: 40 00 07 cc call 4000beb0 <_Objects_Get_information>
40009f84: 93 32 60 10 srl %o1, 0x10, %o1
if ( !obj_info )
40009f88: 80 a2 20 00 cmp %o0, 0
40009f8c: 02 80 00 1a be 40009ff4 <rtems_object_get_class_information+0x8c>
40009f90: 82 10 20 0a mov 0xa, %g1
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
40009f94: c8 12 20 10 lduh [ %o0 + 0x10 ], %g4
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
40009f98: c6 02 20 08 ld [ %o0 + 8 ], %g3
info->maximum_id = obj_info->maximum_id;
40009f9c: c4 02 20 0c ld [ %o0 + 0xc ], %g2
info->auto_extend = obj_info->auto_extend;
40009fa0: c2 0a 20 12 ldub [ %o0 + 0x12 ], %g1
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
40009fa4: c6 26 80 00 st %g3, [ %i2 ]
info->maximum_id = obj_info->maximum_id;
40009fa8: c4 26 a0 04 st %g2, [ %i2 + 4 ]
info->auto_extend = obj_info->auto_extend;
40009fac: c2 2e a0 0c stb %g1, [ %i2 + 0xc ]
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
40009fb0: 80 a1 20 00 cmp %g4, 0
40009fb4: 02 80 00 12 be 40009ffc <rtems_object_get_class_information+0x94><== NEVER TAKEN
40009fb8: c8 26 a0 08 st %g4, [ %i2 + 8 ]
40009fbc: fa 02 20 1c ld [ %o0 + 0x1c ], %i5
40009fc0: 86 10 20 01 mov 1, %g3
40009fc4: 82 10 20 01 mov 1, %g1
40009fc8: 84 10 20 00 clr %g2
if ( !obj_info->local_table[i] )
40009fcc: 87 28 e0 02 sll %g3, 2, %g3
40009fd0: c6 07 40 03 ld [ %i5 + %g3 ], %g3
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
40009fd4: 82 00 60 01 inc %g1
if ( !obj_info->local_table[i] )
unallocated++;
40009fd8: 80 a0 00 03 cmp %g0, %g3
40009fdc: 84 60 bf ff subx %g2, -1, %g2
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
40009fe0: 80 a1 00 01 cmp %g4, %g1
40009fe4: 1a bf ff fa bcc 40009fcc <rtems_object_get_class_information+0x64>
40009fe8: 86 10 00 01 mov %g1, %g3
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
40009fec: c4 26 a0 10 st %g2, [ %i2 + 0x10 ]
return RTEMS_SUCCESSFUL;
40009ff0: 82 10 20 00 clr %g1
}
40009ff4: 81 c7 e0 08 ret
40009ff8: 91 e8 00 01 restore %g0, %g1, %o0
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
40009ffc: 84 10 20 00 clr %g2 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
4000a000: 82 10 20 00 clr %g1 <== NOT EXECUTED
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
4000a004: 10 bf ff fc b 40009ff4 <rtems_object_get_class_information+0x8c><== NOT EXECUTED
4000a008: c4 26 a0 10 st %g2, [ %i2 + 0x10 ] <== NOT EXECUTED
400041b4 <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
400041b4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
400041b8: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
400041bc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
400041c0: 94 10 00 01 mov %g1, %o2 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
400041c4: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
400041c8: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
400041cc: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
400041d0: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
400041d4: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
400041d8: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
400041dc: 7f ff ff 77 call 40003fb8 <rtems_verror> <== NOT EXECUTED
400041e0: 11 08 00 00 sethi %hi(0x20000000), %o0 <== NOT EXECUTED
va_end(arglist);
rtems_error(0, "fatal error, exiting");
400041e4: 90 10 20 00 clr %o0 <== NOT EXECUTED
400041e8: 13 10 00 76 sethi %hi(0x4001d800), %o1 <== NOT EXECUTED
400041ec: 7f ff ff d0 call 4000412c <rtems_error> <== NOT EXECUTED
400041f0: 92 12 62 68 or %o1, 0x268, %o1 ! 4001da68 <IMFS_node_control_default+0xa0><== NOT EXECUTED
_exit(errno);
400041f4: 40 00 31 d3 call 40010940 <__errno> <== NOT EXECUTED
400041f8: 01 00 00 00 nop <== NOT EXECUTED
400041fc: 40 00 02 50 call 40004b3c <_exit> <== NOT EXECUTED
40004200: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40009a04 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
40009a04: 9d e3 bf a0 save %sp, -96, %sp
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
40009a08: 80 a6 20 00 cmp %i0, 0
40009a0c: 12 80 00 04 bne 40009a1c <rtems_partition_create+0x18>
40009a10: 82 10 20 03 mov 3, %g1
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
40009a14: 81 c7 e0 08 ret
40009a18: 91 e8 00 01 restore %g0, %g1, %o0
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
40009a1c: 80 a6 60 00 cmp %i1, 0
40009a20: 02 bf ff fd be 40009a14 <rtems_partition_create+0x10>
40009a24: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !id )
40009a28: 80 a7 60 00 cmp %i5, 0
40009a2c: 02 bf ff fa be 40009a14 <rtems_partition_create+0x10> <== NEVER TAKEN
40009a30: 80 a6 e0 00 cmp %i3, 0
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
40009a34: 02 bf ff f8 be 40009a14 <rtems_partition_create+0x10>
40009a38: 82 10 20 08 mov 8, %g1
40009a3c: 80 a6 a0 00 cmp %i2, 0
40009a40: 02 bf ff f5 be 40009a14 <rtems_partition_create+0x10>
40009a44: 80 a6 80 1b cmp %i2, %i3
40009a48: 0a bf ff f3 bcs 40009a14 <rtems_partition_create+0x10>
40009a4c: 80 8e e0 07 btst 7, %i3
40009a50: 12 bf ff f1 bne 40009a14 <rtems_partition_create+0x10>
40009a54: 80 8e 60 07 btst 7, %i1
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
40009a58: 12 bf ff ef bne 40009a14 <rtems_partition_create+0x10>
40009a5c: 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;
40009a60: 03 10 00 93 sethi %hi(0x40024c00), %g1
40009a64: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 40024cb0 <_Thread_Dispatch_disable_level>
++level;
40009a68: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40009a6c: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ]
* 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 );
40009a70: 23 10 00 92 sethi %hi(0x40024800), %l1
40009a74: 40 00 07 6f call 4000b830 <_Objects_Allocate>
40009a78: 90 14 62 ac or %l1, 0x2ac, %o0 ! 40024aac <_Partition_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
40009a7c: a0 92 20 00 orcc %o0, 0, %l0
40009a80: 02 80 00 1a be 40009ae8 <rtems_partition_create+0xe4>
40009a84: 92 10 00 1b mov %i3, %o1
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
40009a88: f8 24 20 1c st %i4, [ %l0 + 0x1c ]
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
40009a8c: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
the_partition->length = length;
40009a90: f4 24 20 14 st %i2, [ %l0 + 0x14 ]
the_partition->buffer_size = buffer_size;
40009a94: f6 24 20 18 st %i3, [ %l0 + 0x18 ]
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
40009a98: c0 24 20 20 clr [ %l0 + 0x20 ]
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
40009a9c: 40 00 47 d1 call 4001b9e0 <.udiv>
40009aa0: 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,
40009aa4: 92 10 00 19 mov %i1, %o1
length / buffer_size, buffer_size );
40009aa8: 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,
40009aac: 96 10 00 1b mov %i3, %o3
40009ab0: b8 04 20 24 add %l0, 0x24, %i4
40009ab4: 40 00 04 a5 call 4000ad48 <_Chain_Initialize>
40009ab8: 90 10 00 1c mov %i4, %o0
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
40009abc: c4 14 20 0a lduh [ %l0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40009ac0: a2 14 62 ac or %l1, 0x2ac, %l1
40009ac4: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
40009ac8: c2 04 20 08 ld [ %l0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40009acc: 85 28 a0 02 sll %g2, 2, %g2
40009ad0: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
40009ad4: f0 24 20 0c st %i0, [ %l0 + 0xc ]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
40009ad8: 40 00 0c a2 call 4000cd60 <_Thread_Enable_dispatch>
40009adc: c2 27 40 00 st %g1, [ %i5 ]
return RTEMS_SUCCESSFUL;
40009ae0: 10 bf ff cd b 40009a14 <rtems_partition_create+0x10>
40009ae4: 82 10 20 00 clr %g1
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
40009ae8: 40 00 0c 9e call 4000cd60 <_Thread_Enable_dispatch>
40009aec: 01 00 00 00 nop
return RTEMS_TOO_MANY;
40009af0: 10 bf ff c9 b 40009a14 <rtems_partition_create+0x10>
40009af4: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5>
400161dc <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
400161dc: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
400161e0: 11 10 00 f9 sethi %hi(0x4003e400), %o0
400161e4: 92 10 00 18 mov %i0, %o1
400161e8: 90 12 22 5c or %o0, 0x25c, %o0
400161ec: 40 00 15 26 call 4001b684 <_Objects_Get>
400161f0: 94 07 bf fc add %fp, -4, %o2
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
400161f4: c2 07 bf fc ld [ %fp + -4 ], %g1
400161f8: 80 a0 60 00 cmp %g1, 0
400161fc: 12 80 00 19 bne 40016260 <rtems_partition_return_buffer+0x84>
40016200: ba 10 00 08 mov %o0, %i5
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
40016204: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
40016208: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001620c: 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 ) &&
40016210: 80 a6 40 01 cmp %i1, %g1
40016214: 18 80 00 15 bgu 40016268 <rtems_partition_return_buffer+0x8c><== NEVER TAKEN
40016218: 80 a6 40 08 cmp %i1, %o0
4001621c: 0a 80 00 13 bcs 40016268 <rtems_partition_return_buffer+0x8c>
40016220: 01 00 00 00 nop
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
40016224: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
40016228: 40 00 5a e1 call 4002cdac <.urem>
4001622c: 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 ) &&
40016230: 80 a2 20 00 cmp %o0, 0
40016234: 12 80 00 0d bne 40016268 <rtems_partition_return_buffer+0x8c>
40016238: 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 );
4001623c: 40 00 0d 11 call 40019680 <_Chain_Append>
40016240: 92 10 00 19 mov %i1, %o1
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
40016244: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
40016248: 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;
4001624c: 82 00 7f ff add %g1, -1, %g1
_Thread_Enable_dispatch();
40016250: 40 00 18 f0 call 4001c610 <_Thread_Enable_dispatch>
40016254: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
40016258: 81 c7 e0 08 ret
4001625c: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
40016260: 81 c7 e0 08 ret
40016264: 91 e8 20 04 restore %g0, 4, %o0
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
40016268: 40 00 18 ea call 4001c610 <_Thread_Enable_dispatch>
4001626c: b0 10 20 09 mov 9, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40016270: 81 c7 e0 08 ret
40016274: 81 e8 00 00 restore
40038b00 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
40038b00: 9d e3 bf 98 save %sp, -104, %sp
40038b04: 11 10 01 a8 sethi %hi(0x4006a000), %o0
40038b08: 92 10 00 18 mov %i0, %o1
40038b0c: 90 12 23 68 or %o0, 0x368, %o0
40038b10: 7f ff 44 18 call 40009b70 <_Objects_Get>
40038b14: 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 ) {
40038b18: c2 07 bf fc ld [ %fp + -4 ], %g1
40038b1c: 80 a0 60 00 cmp %g1, 0
40038b20: 12 80 00 0d bne 40038b54 <rtems_rate_monotonic_period+0x54>
40038b24: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
40038b28: c4 02 20 40 ld [ %o0 + 0x40 ], %g2
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
40038b2c: 39 10 01 a7 sethi %hi(0x40069c00), %i4
40038b30: b8 17 21 a0 or %i4, 0x1a0, %i4 ! 40069da0 <_Per_CPU_Information>
40038b34: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
40038b38: 80 a0 80 01 cmp %g2, %g1
40038b3c: 02 80 00 08 be 40038b5c <rtems_rate_monotonic_period+0x5c>
40038b40: 80 a6 60 00 cmp %i1, 0
_Thread_Enable_dispatch();
40038b44: 7f ff 47 c2 call 4000aa4c <_Thread_Enable_dispatch>
40038b48: b0 10 20 17 mov 0x17, %i0
40038b4c: 81 c7 e0 08 ret
40038b50: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40038b54: 81 c7 e0 08 ret
40038b58: 91 e8 20 04 restore %g0, 4, %o0
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
40038b5c: 12 80 00 0e bne 40038b94 <rtems_rate_monotonic_period+0x94>
40038b60: 01 00 00 00 nop
switch ( the_period->state ) {
40038b64: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
40038b68: 80 a0 60 04 cmp %g1, 4
40038b6c: 18 80 00 06 bgu 40038b84 <rtems_rate_monotonic_period+0x84><== NEVER TAKEN
40038b70: b0 10 20 00 clr %i0
40038b74: 83 28 60 02 sll %g1, 2, %g1
40038b78: 05 10 01 8d sethi %hi(0x40063400), %g2
40038b7c: 84 10 a1 50 or %g2, 0x150, %g2 ! 40063550 <CSWTCH.24>
40038b80: f0 00 80 01 ld [ %g2 + %g1 ], %i0
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
40038b84: 7f ff 47 b2 call 4000aa4c <_Thread_Enable_dispatch>
40038b88: 01 00 00 00 nop
40038b8c: 81 c7 e0 08 ret
40038b90: 81 e8 00 00 restore
}
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
40038b94: 7f ff 25 c3 call 400022a0 <sparc_disable_interrupts>
40038b98: 01 00 00 00 nop
40038b9c: b4 10 00 08 mov %o0, %i2
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
40038ba0: f6 07 60 38 ld [ %i5 + 0x38 ], %i3
40038ba4: 80 a6 e0 00 cmp %i3, 0
40038ba8: 02 80 00 1c be 40038c18 <rtems_rate_monotonic_period+0x118>
40038bac: 80 a6 e0 02 cmp %i3, 2
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
40038bb0: 02 80 00 2e be 40038c68 <rtems_rate_monotonic_period+0x168>
40038bb4: 80 a6 e0 04 cmp %i3, 4
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
40038bb8: 12 bf ff e5 bne 40038b4c <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
40038bbc: b0 10 20 04 mov 4, %i0
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
40038bc0: 7f ff ff 5e call 40038938 <_Rate_monotonic_Update_statistics>
40038bc4: 90 10 00 1d mov %i5, %o0
_ISR_Enable( level );
40038bc8: 7f ff 25 ba call 400022b0 <sparc_enable_interrupts>
40038bcc: 90 10 00 1a mov %i2, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
40038bd0: 82 10 20 02 mov 2, %g1
40038bd4: 92 07 60 10 add %i5, 0x10, %o1
40038bd8: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
40038bdc: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40038be0: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40038be4: 11 10 01 a6 sethi %hi(0x40069800), %o0
40038be8: 7f ff 4a d5 call 4000b73c <_Watchdog_Insert>
40038bec: 90 12 21 28 or %o0, 0x128, %o0 ! 40069928 <_Watchdog_Ticks_chain>
40038bf0: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
40038bf4: d2 07 60 3c ld [ %i5 + 0x3c ], %o1
40038bf8: 03 10 01 95 sethi %hi(0x40065400), %g1
40038bfc: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 ! 40065414 <_Scheduler+0x34>
40038c00: 9f c0 40 00 call %g1
40038c04: 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();
40038c08: 7f ff 47 91 call 4000aa4c <_Thread_Enable_dispatch>
40038c0c: 01 00 00 00 nop
40038c10: 81 c7 e0 08 ret
40038c14: 81 e8 00 00 restore
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
40038c18: 7f ff 25 a6 call 400022b0 <sparc_enable_interrupts>
40038c1c: 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 );
40038c20: 90 10 00 1d mov %i5, %o0
40038c24: 7f ff ff 94 call 40038a74 <_Rate_monotonic_Initiate_statistics>
40038c28: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
the_period->state = RATE_MONOTONIC_ACTIVE;
40038c2c: 82 10 20 02 mov 2, %g1
40038c30: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40038c34: 03 10 00 e3 sethi %hi(0x40038c00), %g1
40038c38: 82 10 60 dc or %g1, 0xdc, %g1 ! 40038cdc <_Rate_monotonic_Timeout>
the_watchdog->id = id;
40038c3c: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40038c40: 92 07 60 10 add %i5, 0x10, %o1
40038c44: 11 10 01 a6 sethi %hi(0x40069800), %o0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40038c48: c0 27 60 18 clr [ %i5 + 0x18 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40038c4c: 90 12 21 28 or %o0, 0x128, %o0
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
40038c50: c0 27 60 34 clr [ %i5 + 0x34 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40038c54: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40038c58: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40038c5c: 7f ff 4a b8 call 4000b73c <_Watchdog_Insert>
40038c60: b0 10 20 00 clr %i0
40038c64: 30 bf ff c8 b,a 40038b84 <rtems_rate_monotonic_period+0x84>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
40038c68: 7f ff ff 34 call 40038938 <_Rate_monotonic_Update_statistics>
40038c6c: 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;
40038c70: 82 10 20 01 mov 1, %g1
the_period->next_length = length;
40038c74: 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;
40038c78: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
_ISR_Enable( level );
40038c7c: 7f ff 25 8d call 400022b0 <sparc_enable_interrupts>
40038c80: 90 10 00 1a mov %i2, %o0
_Thread_Executing->Wait.id = the_period->Object.id;
40038c84: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
40038c88: c4 07 60 08 ld [ %i5 + 8 ], %g2
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40038c8c: 90 10 00 01 mov %g1, %o0
40038c90: 13 00 00 10 sethi %hi(0x4000), %o1
40038c94: 7f ff 49 be call 4000b38c <_Thread_Set_state>
40038c98: c4 20 60 20 st %g2, [ %g1 + 0x20 ]
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
40038c9c: 7f ff 25 81 call 400022a0 <sparc_disable_interrupts>
40038ca0: 01 00 00 00 nop
local_state = the_period->state;
40038ca4: f4 07 60 38 ld [ %i5 + 0x38 ], %i2
the_period->state = RATE_MONOTONIC_ACTIVE;
40038ca8: f6 27 60 38 st %i3, [ %i5 + 0x38 ]
_ISR_Enable( level );
40038cac: 7f ff 25 81 call 400022b0 <sparc_enable_interrupts>
40038cb0: 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 )
40038cb4: 80 a6 a0 03 cmp %i2, 3
40038cb8: 22 80 00 06 be,a 40038cd0 <rtems_rate_monotonic_period+0x1d0>
40038cbc: d0 07 20 10 ld [ %i4 + 0x10 ], %o0
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
40038cc0: 7f ff 47 63 call 4000aa4c <_Thread_Enable_dispatch>
40038cc4: b0 10 20 00 clr %i0
40038cc8: 81 c7 e0 08 ret
40038ccc: 81 e8 00 00 restore
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40038cd0: 7f ff 46 72 call 4000a698 <_Thread_Clear_state>
40038cd4: 13 00 00 10 sethi %hi(0x4000), %o1
40038cd8: 30 bf ff fa b,a 40038cc0 <rtems_rate_monotonic_period+0x1c0>
4002a580 <rtems_rate_monotonic_report_statistics_with_plugin>:
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
4002a580: 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 )
4002a584: 80 a6 60 00 cmp %i1, 0
4002a588: 02 80 00 48 be 4002a6a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x128><== NEVER TAKEN
4002a58c: 90 10 00 18 mov %i0, %o0
return;
(*print)( context, "Period information by period\n" );
4002a590: 13 10 01 82 sethi %hi(0x40060800), %o1
4002a594: 9f c6 40 00 call %i1
4002a598: 92 12 60 28 or %o1, 0x28, %o1 ! 40060828 <_TOD_Days_per_month+0x68>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
4002a59c: 90 10 00 18 mov %i0, %o0
4002a5a0: 13 10 01 82 sethi %hi(0x40060800), %o1
4002a5a4: 9f c6 40 00 call %i1
4002a5a8: 92 12 60 48 or %o1, 0x48, %o1 ! 40060848 <_TOD_Days_per_month+0x88>
(*print)( context, "--- Wall times are in seconds ---\n" );
4002a5ac: 90 10 00 18 mov %i0, %o0
4002a5b0: 13 10 01 82 sethi %hi(0x40060800), %o1
4002a5b4: 9f c6 40 00 call %i1
4002a5b8: 92 12 60 70 or %o1, 0x70, %o1 ! 40060870 <_TOD_Days_per_month+0xb0>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
4002a5bc: 90 10 00 18 mov %i0, %o0
4002a5c0: 13 10 01 82 sethi %hi(0x40060800), %o1
4002a5c4: 9f c6 40 00 call %i1
4002a5c8: 92 12 60 98 or %o1, 0x98, %o1 ! 40060898 <_TOD_Days_per_month+0xd8>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
4002a5cc: 90 10 00 18 mov %i0, %o0
4002a5d0: 13 10 01 82 sethi %hi(0x40060800), %o1
4002a5d4: 9f c6 40 00 call %i1
4002a5d8: 92 12 60 e8 or %o1, 0xe8, %o1 ! 400608e8 <_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 ;
4002a5dc: 39 10 01 a8 sethi %hi(0x4006a000), %i4
4002a5e0: b8 17 23 68 or %i4, 0x368, %i4 ! 4006a368 <_Rate_monotonic_Information>
4002a5e4: fa 07 20 08 ld [ %i4 + 8 ], %i5
4002a5e8: c2 07 20 0c ld [ %i4 + 0xc ], %g1
4002a5ec: 80 a7 40 01 cmp %i5, %g1
4002a5f0: 18 80 00 2e bgu 4002a6a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x128><== NEVER TAKEN
4002a5f4: 35 10 01 82 sethi %hi(0x40060800), %i2
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
(*print)( context,
4002a5f8: 27 10 01 82 sethi %hi(0x40060800), %l3
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
(*print)( context,
4002a5fc: 25 10 01 82 sethi %hi(0x40060800), %l2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
4002a600: 37 10 01 87 sethi %hi(0x40061c00), %i3
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
4002a604: b4 16 a1 38 or %i2, 0x138, %i2
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
(*print)( context,
4002a608: a6 14 e1 50 or %l3, 0x150, %l3
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
(*print)( context,
4002a60c: a4 14 a1 70 or %l2, 0x170, %l2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
4002a610: 10 80 00 06 b 4002a628 <rtems_rate_monotonic_report_statistics_with_plugin+0xa8>
4002a614: b6 16 e2 00 or %i3, 0x200, %i3
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
4002a618: 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 ;
4002a61c: 80 a0 40 1d cmp %g1, %i5
4002a620: 0a 80 00 22 bcs 4002a6a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x128>
4002a624: 01 00 00 00 nop
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
4002a628: 90 10 00 1d mov %i5, %o0
4002a62c: 40 00 37 df call 400385a8 <rtems_rate_monotonic_get_statistics>
4002a630: 92 07 bf c8 add %fp, -56, %o1
if ( status != RTEMS_SUCCESSFUL )
4002a634: 80 a2 20 00 cmp %o0, 0
4002a638: 32 bf ff f8 bne,a 4002a618 <rtems_rate_monotonic_report_statistics_with_plugin+0x98>
4002a63c: c2 07 20 0c ld [ %i4 + 0xc ], %g1
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
4002a640: 92 07 bf b0 add %fp, -80, %o1
4002a644: 40 00 38 4b call 40038770 <rtems_rate_monotonic_get_status>
4002a648: 90 10 00 1d mov %i5, %o0
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
4002a64c: d0 07 bf b0 ld [ %fp + -80 ], %o0
4002a650: 94 07 bf a0 add %fp, -96, %o2
4002a654: 7f ff 97 9e call 400104cc <rtems_object_get_name>
4002a658: 92 10 20 05 mov 5, %o1
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
4002a65c: d8 1f bf c8 ldd [ %fp + -56 ], %o4
4002a660: 92 10 00 1a mov %i2, %o1
4002a664: 94 10 00 1d mov %i5, %o2
4002a668: 90 10 00 18 mov %i0, %o0
4002a66c: 9f c6 40 00 call %i1
4002a670: 96 07 bf a0 add %fp, -96, %o3
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
4002a674: c2 07 bf c8 ld [ %fp + -56 ], %g1
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
4002a678: 94 07 bf a8 add %fp, -88, %o2
4002a67c: 90 07 bf e0 add %fp, -32, %o0
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
4002a680: 80 a0 60 00 cmp %g1, 0
4002a684: 12 80 00 0b bne 4002a6b0 <rtems_rate_monotonic_report_statistics_with_plugin+0x130>
4002a688: 92 10 00 1b mov %i3, %o1
(*print)( context, "\n" );
4002a68c: 9f c6 40 00 call %i1
4002a690: 90 10 00 18 mov %i0, %o0
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
4002a694: c2 07 20 0c ld [ %i4 + 0xc ], %g1
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
4002a698: 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 ;
4002a69c: 80 a0 40 1d cmp %g1, %i5
4002a6a0: 1a bf ff e3 bcc 4002a62c <rtems_rate_monotonic_report_statistics_with_plugin+0xac><== ALWAYS TAKEN
4002a6a4: 90 10 00 1d mov %i5, %o0
4002a6a8: 81 c7 e0 08 ret
4002a6ac: 81 e8 00 00 restore
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
4002a6b0: 40 00 03 5e call 4002b428 <_Timespec_Divide_by_integer>
4002a6b4: 92 10 00 01 mov %g1, %o1
(*print)( context,
4002a6b8: d0 07 bf d4 ld [ %fp + -44 ], %o0
4002a6bc: 40 00 ae e2 call 40056244 <.div>
4002a6c0: 92 10 23 e8 mov 0x3e8, %o1
4002a6c4: aa 10 00 08 mov %o0, %l5
4002a6c8: d0 07 bf dc ld [ %fp + -36 ], %o0
4002a6cc: 40 00 ae de call 40056244 <.div>
4002a6d0: 92 10 23 e8 mov 0x3e8, %o1
4002a6d4: c2 07 bf a8 ld [ %fp + -88 ], %g1
4002a6d8: a2 10 00 08 mov %o0, %l1
4002a6dc: d0 07 bf ac ld [ %fp + -84 ], %o0
4002a6e0: e0 07 bf d0 ld [ %fp + -48 ], %l0
4002a6e4: e8 07 bf d8 ld [ %fp + -40 ], %l4
4002a6e8: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4002a6ec: 40 00 ae d6 call 40056244 <.div>
4002a6f0: 92 10 23 e8 mov 0x3e8, %o1
4002a6f4: 96 10 00 15 mov %l5, %o3
4002a6f8: 98 10 00 14 mov %l4, %o4
4002a6fc: 9a 10 00 11 mov %l1, %o5
4002a700: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
4002a704: 92 10 00 13 mov %l3, %o1
4002a708: 94 10 00 10 mov %l0, %o2
4002a70c: 9f c6 40 00 call %i1
4002a710: 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);
4002a714: d2 07 bf c8 ld [ %fp + -56 ], %o1
4002a718: 94 07 bf a8 add %fp, -88, %o2
4002a71c: 40 00 03 43 call 4002b428 <_Timespec_Divide_by_integer>
4002a720: 90 07 bf f8 add %fp, -8, %o0
(*print)( context,
4002a724: d0 07 bf ec ld [ %fp + -20 ], %o0
4002a728: 40 00 ae c7 call 40056244 <.div>
4002a72c: 92 10 23 e8 mov 0x3e8, %o1
4002a730: a8 10 00 08 mov %o0, %l4
4002a734: d0 07 bf f4 ld [ %fp + -12 ], %o0
4002a738: 40 00 ae c3 call 40056244 <.div>
4002a73c: 92 10 23 e8 mov 0x3e8, %o1
4002a740: c2 07 bf a8 ld [ %fp + -88 ], %g1
4002a744: a0 10 00 08 mov %o0, %l0
4002a748: d0 07 bf ac ld [ %fp + -84 ], %o0
4002a74c: ea 07 bf e8 ld [ %fp + -24 ], %l5
4002a750: e2 07 bf f0 ld [ %fp + -16 ], %l1
4002a754: 92 10 23 e8 mov 0x3e8, %o1
4002a758: 40 00 ae bb call 40056244 <.div>
4002a75c: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4002a760: 92 10 00 12 mov %l2, %o1
4002a764: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
4002a768: 94 10 00 15 mov %l5, %o2
4002a76c: 90 10 00 18 mov %i0, %o0
4002a770: 96 10 00 14 mov %l4, %o3
4002a774: 98 10 00 11 mov %l1, %o4
4002a778: 9f c6 40 00 call %i1
4002a77c: 9a 10 00 10 mov %l0, %o5
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
4002a780: 10 bf ff a6 b 4002a618 <rtems_rate_monotonic_report_statistics_with_plugin+0x98>
4002a784: c2 07 20 0c ld [ %i4 + 0xc ], %g1
4002a7a0 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
4002a7a0: 9d e3 bf a0 save %sp, -96, %sp
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
4002a7a4: 03 10 01 a6 sethi %hi(0x40069800), %g1
4002a7a8: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 40069890 <_Thread_Dispatch_disable_level>
++level;
4002a7ac: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
4002a7b0: c4 20 60 90 st %g2, [ %g1 + 0x90 ]
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
4002a7b4: 39 10 01 a8 sethi %hi(0x4006a000), %i4
4002a7b8: b8 17 23 68 or %i4, 0x368, %i4 ! 4006a368 <_Rate_monotonic_Information>
4002a7bc: fa 07 20 08 ld [ %i4 + 8 ], %i5
4002a7c0: c2 07 20 0c ld [ %i4 + 0xc ], %g1
4002a7c4: 80 a7 40 01 cmp %i5, %g1
4002a7c8: 18 80 00 09 bgu 4002a7ec <rtems_rate_monotonic_reset_all_statistics+0x4c><== NEVER TAKEN
4002a7cc: 01 00 00 00 nop
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
4002a7d0: 40 00 00 09 call 4002a7f4 <rtems_rate_monotonic_reset_statistics>
4002a7d4: 90 10 00 1d mov %i5, %o0
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
4002a7d8: c2 07 20 0c ld [ %i4 + 0xc ], %g1
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
4002a7dc: ba 07 60 01 inc %i5
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
4002a7e0: 80 a0 40 1d cmp %g1, %i5
4002a7e4: 1a bf ff fb bcc 4002a7d0 <rtems_rate_monotonic_reset_all_statistics+0x30>
4002a7e8: 01 00 00 00 nop
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
4002a7ec: 7f ff 80 98 call 4000aa4c <_Thread_Enable_dispatch>
4002a7f0: 81 e8 00 00 restore
400094f4 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
400094f4: 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;
400094f8: 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;
400094fc: 90 10 00 19 mov %i1, %o0
40009500: 40 00 2f 87 call 4001531c <.urem>
40009504: 92 10 00 1d mov %i5, %o1
if (excess > 0) {
40009508: 80 a2 20 00 cmp %o0, 0
4000950c: 02 80 00 26 be 400095a4 <rtems_rbheap_allocate+0xb0> <== ALWAYS TAKEN
40009510: b6 10 00 19 mov %i1, %i3
value += alignment - excess;
40009514: ba 06 40 1d add %i1, %i5, %i5 <== NOT EXECUTED
40009518: b6 27 40 08 sub %i5, %o0, %i3 <== NOT EXECUTED
4000951c: 80 a6 c0 19 cmp %i3, %i1 <== NOT EXECUTED
40009520: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
40009524: 80 88 60 ff btst 0xff, %g1
40009528: 02 80 00 1d be 4000959c <rtems_rbheap_allocate+0xa8> <== NEVER TAKEN
4000952c: 80 a6 60 00 cmp %i1, 0
40009530: 02 80 00 1b be 4000959c <rtems_rbheap_allocate+0xa8>
40009534: 82 06 20 04 add %i0, 4, %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
40009538: fa 06 00 00 ld [ %i0 ], %i5
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
4000953c: 80 a7 40 01 cmp %i5, %g1
40009540: 02 80 00 17 be 4000959c <rtems_rbheap_allocate+0xa8>
40009544: 01 00 00 00 nop
rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;
if (free_chunk->size >= size) {
40009548: f8 07 60 1c ld [ %i5 + 0x1c ], %i4
4000954c: 80 a6 c0 1c cmp %i3, %i4
40009550: 38 80 00 10 bgu,a 40009590 <rtems_rbheap_allocate+0x9c>
40009554: fa 07 40 00 ld [ %i5 ], %i5
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
40009558: 80 a7 60 00 cmp %i5, 0
4000955c: 02 80 00 10 be 4000959c <rtems_rbheap_allocate+0xa8> <== NEVER TAKEN
40009560: 80 a7 00 1b cmp %i4, %i3
uintptr_t free_size = free_chunk->size;
if (free_size > aligned_size) {
40009564: 18 80 00 12 bgu 400095ac <rtems_rbheap_allocate+0xb8>
40009568: 01 00 00 00 nop
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4000956c: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
40009570: c2 07 60 04 ld [ %i5 + 4 ], %g1
ptr = (void *) new_chunk->begin;
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
40009574: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
next->previous = previous;
40009578: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
4000957c: c4 20 40 00 st %g2, [ %g1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
40009580: c0 27 60 04 clr [ %i5 + 4 ]
40009584: c0 27 40 00 clr [ %i5 ]
}
}
}
return ptr;
}
40009588: 81 c7 e0 08 ret
4000958c: 81 e8 00 00 restore
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
40009590: 80 a0 40 1d cmp %g1, %i5
40009594: 32 bf ff ee bne,a 4000954c <rtems_rbheap_allocate+0x58> <== NEVER TAKEN
40009598: f8 07 60 1c ld [ %i5 + 0x1c ], %i4 <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
4000959c: 81 c7 e0 08 ret
400095a0: 91 e8 20 00 restore %g0, 0, %o0
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
if (excess > 0) {
400095a4: 10 bf ff e0 b 40009524 <rtems_rbheap_allocate+0x30>
400095a8: 82 10 20 01 mov 1, %g1
if (free_chunk != NULL) {
uintptr_t free_size = free_chunk->size;
if (free_size > aligned_size) {
rtems_rbheap_chunk *new_chunk = get_chunk(control);
400095ac: 7f ff ff 46 call 400092c4 <get_chunk>
400095b0: 90 10 00 18 mov %i0, %o0
if (new_chunk != NULL) {
400095b4: b4 92 20 00 orcc %o0, 0, %i2
400095b8: 02 bf ff f9 be 4000959c <rtems_rbheap_allocate+0xa8> <== NEVER TAKEN
400095bc: b8 27 00 1b sub %i4, %i3, %i4
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
400095c0: 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;
400095c4: f8 27 60 1c st %i4, [ %i5 + 0x1c ]
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
400095c8: f6 26 a0 1c st %i3, [ %i2 + 0x1c ]
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
400095cc: b8 07 00 01 add %i4, %g1, %i4
400095d0: c0 26 a0 04 clr [ %i2 + 4 ]
400095d4: f8 26 a0 18 st %i4, [ %i2 + 0x18 ]
400095d8: c0 26 80 00 clr [ %i2 ]
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
400095dc: 90 06 20 18 add %i0, 0x18, %o0
400095e0: 40 00 06 fd call 4000b1d4 <_RBTree_Insert_unprotected>
400095e4: 92 06 a0 08 add %i2, 8, %o1
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
rtems_chain_set_off_chain(&new_chunk->chain_node);
insert_into_tree(chunk_tree, new_chunk);
ptr = (void *) new_chunk->begin;
400095e8: f0 06 a0 18 ld [ %i2 + 0x18 ], %i0
400095ec: 81 c7 e0 08 ret
400095f0: 81 e8 00 00 restore
40009738 <rtems_rbheap_extend_descriptors_with_malloc>:
/* Do nothing */
}
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
40009738: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
4000973c: 7f ff ec d6 call 40004a94 <malloc> <== NOT EXECUTED
40009740: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
if (chunk != NULL) {
40009744: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40009748: 02 80 00 07 be 40009764 <rtems_rbheap_extend_descriptors_with_malloc+0x2c><== NOT EXECUTED
4000974c: 84 06 20 0c add %i0, 0xc, %g2 <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
40009750: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
after_node->next = the_node;
40009754: d0 26 20 0c st %o0, [ %i0 + 0xc ] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
40009758: c4 22 20 04 st %g2, [ %o0 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
4000975c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
before_node->previous = the_node;
40009760: d0 20 60 04 st %o0, [ %g1 + 4 ] <== NOT EXECUTED
40009764: 81 c7 e0 08 ret <== NOT EXECUTED
40009768: 81 e8 00 00 restore <== NOT EXECUTED
400095f4 <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
400095f4: 9d e3 bf 80 save %sp, -128, %sp
400095f8: b4 10 00 18 mov %i0, %i2
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
400095fc: 80 a6 60 00 cmp %i1, 0
40009600: 02 80 00 2a be 400096a8 <rtems_rbheap_free+0xb4>
40009604: b0 10 20 00 clr %i0
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
40009608: fa 06 a0 1c ld [ %i2 + 0x1c ], %i5
#define NULL_PAGE rtems_rbheap_chunk_of_node(NULL)
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
4000960c: c0 27 bf fc clr [ %fp + -4 ]
40009610: c0 27 bf e0 clr [ %fp + -32 ]
40009614: c0 27 bf e4 clr [ %fp + -28 ]
40009618: c0 27 bf e8 clr [ %fp + -24 ]
4000961c: c0 27 bf ec clr [ %fp + -20 ]
40009620: c0 27 bf f0 clr [ %fp + -16 ]
40009624: c0 27 bf f4 clr [ %fp + -12 ]
40009628: f2 27 bf f8 st %i1, [ %fp + -8 ]
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
4000962c: 80 a7 60 00 cmp %i5, 0
40009630: 02 80 00 3e be 40009728 <rtems_rbheap_free+0x134> <== NEVER TAKEN
40009634: b8 06 a0 18 add %i2, 0x18, %i4
40009638: b6 10 20 00 clr %i3
compare_result = the_rbtree->compare_function(the_node, iter_node);
4000963c: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
40009640: 92 10 00 1d mov %i5, %o1
40009644: 9f c0 40 00 call %g1
40009648: 90 07 bf e8 add %fp, -24, %o0
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
4000964c: 83 3a 20 1f sra %o0, 0x1f, %g1
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
40009650: 80 a2 20 00 cmp %o0, 0
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
40009654: 82 20 40 08 sub %g1, %o0, %g1
40009658: 83 30 60 1f srl %g1, 0x1f, %g1
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
4000965c: 83 28 60 02 sll %g1, 2, %g1
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
40009660: 12 80 00 06 bne 40009678 <rtems_rbheap_free+0x84>
40009664: 82 07 40 01 add %i5, %g1, %g1
found = iter_node;
if ( the_rbtree->is_unique )
40009668: c4 0f 20 14 ldub [ %i4 + 0x14 ], %g2
4000966c: 80 a0 a0 00 cmp %g2, 0
40009670: 12 80 00 10 bne 400096b0 <rtems_rbheap_free+0xbc> <== ALWAYS TAKEN
40009674: b6 10 00 1d mov %i5, %i3
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
40009678: fa 00 60 04 ld [ %g1 + 4 ], %i5
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
4000967c: 80 a7 60 00 cmp %i5, 0
40009680: 32 bf ff f0 bne,a 40009640 <rtems_rbheap_free+0x4c>
40009684: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
return rtems_rbheap_chunk_of_node(
40009688: ba 06 ff f8 add %i3, -8, %i5
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
4000968c: 80 a7 7f f8 cmp %i5, -8
40009690: 02 80 00 06 be 400096a8 <rtems_rbheap_free+0xb4>
40009694: 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);
40009698: c2 06 ff f8 ld [ %i3 + -8 ], %g1
4000969c: 80 a0 60 00 cmp %g1, 0
400096a0: 02 80 00 06 be 400096b8 <rtems_rbheap_free+0xc4>
400096a4: b0 10 20 0e mov 0xe, %i0
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
400096a8: 81 c7 e0 08 ret
400096ac: 81 e8 00 00 restore
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
return rtems_rbheap_chunk_of_node(
400096b0: 10 bf ff f7 b 4000968c <rtems_rbheap_free+0x98>
400096b4: ba 06 ff f8 add %i3, -8, %i5
400096b8: c2 06 ff fc ld [ %i3 + -4 ], %g1
400096bc: 80 a0 60 00 cmp %g1, 0
400096c0: 12 bf ff fa bne 400096a8 <rtems_rbheap_free+0xb4> <== NEVER TAKEN
400096c4: 92 10 20 00 clr %o1
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
400096c8: 40 00 07 92 call 4000b510 <_RBTree_Next_unprotected>
400096cc: 90 10 00 1b mov %i3, %o0
400096d0: 92 10 20 01 mov 1, %o1
400096d4: b2 10 00 08 mov %o0, %i1
400096d8: 40 00 07 8e call 4000b510 <_RBTree_Next_unprotected>
400096dc: 90 10 00 1b mov %i3, %o0
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT);
rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT);
check_and_merge(free_chain, chunk_tree, chunk, succ);
400096e0: 92 10 00 1c mov %i4, %o1
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
400096e4: 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);
400096e8: 94 10 00 1d mov %i5, %o2
400096ec: 7f ff ff 10 call 4000932c <check_and_merge>
400096f0: 90 10 00 1a mov %i2, %o0
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
400096f4: c2 06 80 00 ld [ %i2 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
400096f8: f4 26 ff fc st %i2, [ %i3 + -4 ]
before_node = after_node->next;
after_node->next = the_node;
400096fc: fa 26 80 00 st %i5, [ %i2 ]
the_node->next = before_node;
40009700: c2 26 ff f8 st %g1, [ %i3 + -8 ]
before_node->previous = the_node;
40009704: fa 20 60 04 st %i5, [ %g1 + 4 ]
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
40009708: 90 10 00 1a mov %i2, %o0
4000970c: 92 10 00 1c mov %i4, %o1
40009710: 94 10 00 1d mov %i5, %o2
40009714: 96 06 7f f8 add %i1, -8, %o3
40009718: 7f ff ff 05 call 4000932c <check_and_merge>
4000971c: b0 10 20 00 clr %i0
40009720: 81 c7 e0 08 ret
40009724: 81 e8 00 00 restore
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
40009728: 81 c7 e0 08 ret <== NOT EXECUTED
4000972c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED
400093c4 <rtems_rbheap_initialize>:
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
400093c4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (alignment > 0) {
400093c8: 80 a6 e0 00 cmp %i3, 0
400093cc: 12 80 00 04 bne 400093dc <rtems_rbheap_initialize+0x18>
400093d0: 82 10 20 0a mov 0xa, %g1
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
400093d4: 81 c7 e0 08 ret
400093d8: 91 e8 00 01 restore %g0, %g1, %o0
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
400093dc: 90 10 00 19 mov %i1, %o0
400093e0: 92 10 00 1b mov %i3, %o1
400093e4: 40 00 2f ce call 4001531c <.urem>
400093e8: b4 06 40 1a add %i1, %i2, %i2
if (excess > 0) {
400093ec: 80 a2 20 00 cmp %o0, 0
400093f0: 32 80 00 09 bne,a 40009414 <rtems_rbheap_initialize+0x50>
400093f4: a0 06 40 1b add %i1, %i3, %l0
400093f8: 82 10 20 01 mov 1, %g1
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
uintptr_t aligned_begin = align_up(alignment, begin);
uintptr_t aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
400093fc: 80 88 60 ff btst 0xff, %g1
40009400: 12 80 00 0b bne 4000942c <rtems_rbheap_initialize+0x68> <== ALWAYS TAKEN
40009404: a0 10 00 19 mov %i1, %l0
insert_into_tree(chunk_tree, first);
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_INVALID_ADDRESS;
40009408: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
4000940c: 81 c7 e0 08 ret
40009410: 91 e8 00 01 restore %g0, %g1, %o0
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
if (excess > 0) {
value += alignment - excess;
40009414: a0 24 00 08 sub %l0, %o0, %l0
40009418: 80 a4 00 19 cmp %l0, %i1
4000941c: 82 60 3f ff subx %g0, -1, %g1
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
uintptr_t aligned_begin = align_up(alignment, begin);
uintptr_t aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
40009420: 80 88 60 ff btst 0xff, %g1
40009424: 02 bf ff fa be 4000940c <rtems_rbheap_initialize+0x48>
40009428: 82 10 20 09 mov 9, %g1
4000942c: 80 a6 40 1a cmp %i1, %i2
40009430: 1a bf ff f7 bcc 4000940c <rtems_rbheap_initialize+0x48>
40009434: 82 10 20 09 mov 9, %g1
return value;
}
static uintptr_t align_down(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
40009438: 90 10 00 1a mov %i2, %o0
4000943c: 40 00 2f b8 call 4001531c <.urem>
40009440: 92 10 00 1b mov %i3, %o1
return value - excess;
40009444: b4 26 80 08 sub %i2, %o0, %i2
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
uintptr_t aligned_begin = align_up(alignment, begin);
uintptr_t aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
40009448: 80 a4 00 1a cmp %l0, %i2
4000944c: 1a bf ff e2 bcc 400093d4 <rtems_rbheap_initialize+0x10>
40009450: 82 10 20 09 mov 9, %g1
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
40009454: 82 06 20 04 add %i0, 4, %g1
head->next = tail;
40009458: c2 26 00 00 st %g1, [ %i0 ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4000945c: 82 06 20 0c add %i0, 0xc, %g1
head->next = tail;
head->previous = NULL;
tail->previous = head;
40009460: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
the_rbtree->permanent_null = NULL;
the_rbtree->root = NULL;
the_rbtree->first[0] = NULL;
the_rbtree->first[1] = NULL;
the_rbtree->compare_function = compare_function;
the_rbtree->is_unique = is_unique;
40009464: 82 10 20 01 mov 1, %g1
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
40009468: 84 06 20 10 add %i0, 0x10, %g2
4000946c: c2 2e 20 2c stb %g1, [ %i0 + 0x2c ]
{
the_rbtree->permanent_null = NULL;
the_rbtree->root = NULL;
the_rbtree->first[0] = NULL;
the_rbtree->first[1] = NULL;
the_rbtree->compare_function = compare_function;
40009470: 03 10 00 24 sethi %hi(0x40009000), %g1
40009474: 82 10 62 b4 or %g1, 0x2b4, %g1 ! 400092b4 <chunk_compare>
head->next = tail;
head->previous = NULL;
40009478: c0 26 20 04 clr [ %i0 + 4 ]
4000947c: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
tail->previous = head;
40009480: f0 26 20 08 st %i0, [ %i0 + 8 ]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
40009484: c0 26 20 10 clr [ %i0 + 0x10 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
40009488: c4 26 20 0c st %g2, [ %i0 + 0xc ]
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
4000948c: c0 26 20 18 clr [ %i0 + 0x18 ]
the_rbtree->root = NULL;
40009490: c0 26 20 1c clr [ %i0 + 0x1c ]
the_rbtree->first[0] = NULL;
40009494: c0 26 20 20 clr [ %i0 + 0x20 ]
the_rbtree->first[1] = NULL;
40009498: c0 26 20 24 clr [ %i0 + 0x24 ]
rtems_rbheap_chunk *first = NULL;
rtems_chain_initialize_empty(free_chain);
rtems_chain_initialize_empty(&control->spare_descriptor_chain);
rtems_rbtree_initialize_empty(chunk_tree, chunk_compare, true);
control->alignment = alignment;
4000949c: f6 26 20 30 st %i3, [ %i0 + 0x30 ]
control->handler_arg = handler_arg;
400094a0: fa 26 20 38 st %i5, [ %i0 + 0x38 ]
control->extend_descriptors = extend_descriptors;
400094a4: f8 26 20 34 st %i4, [ %i0 + 0x34 ]
first = get_chunk(control);
400094a8: 7f ff ff 87 call 400092c4 <get_chunk>
400094ac: 90 10 00 18 mov %i0, %o0
first->begin = aligned_begin;
first->size = aligned_end - aligned_begin;
add_to_chain(free_chain, first);
insert_into_tree(chunk_tree, first);
} else {
sc = RTEMS_NO_MEMORY;
400094b0: 82 10 20 1a mov 0x1a, %g1
control->alignment = alignment;
control->handler_arg = handler_arg;
control->extend_descriptors = extend_descriptors;
first = get_chunk(control);
if (first != NULL) {
400094b4: 80 a2 20 00 cmp %o0, 0
400094b8: 02 bf ff c7 be 400093d4 <rtems_rbheap_initialize+0x10>
400094bc: 92 10 00 08 mov %o0, %o1
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
400094c0: c2 06 00 00 ld [ %i0 ], %g1
first->begin = aligned_begin;
first->size = aligned_end - aligned_begin;
400094c4: b4 26 80 10 sub %i2, %l0, %i2
control->handler_arg = handler_arg;
control->extend_descriptors = extend_descriptors;
first = get_chunk(control);
if (first != NULL) {
first->begin = aligned_begin;
400094c8: e0 22 20 18 st %l0, [ %o0 + 0x18 ]
first->size = aligned_end - aligned_begin;
400094cc: f4 22 20 1c st %i2, [ %o0 + 0x1c ]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
400094d0: f0 22 20 04 st %i0, [ %o0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
400094d4: d0 26 00 00 st %o0, [ %i0 ]
the_node->next = before_node;
400094d8: c2 22 00 00 st %g1, [ %o0 ]
before_node->previous = the_node;
400094dc: d0 20 60 04 st %o0, [ %g1 + 4 ]
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
400094e0: 92 02 60 08 add %o1, 8, %o1
400094e4: 40 00 07 3c call 4000b1d4 <_RBTree_Insert_unprotected>
400094e8: 90 06 20 18 add %i0, 0x18, %o0
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
400094ec: 10 bf ff ba b 400093d4 <rtems_rbheap_initialize+0x10>
400094f0: 82 10 20 00 clr %g1
4001c2e0 <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
4001c2e0: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
4001c2e4: 90 10 00 18 mov %i0, %o0
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
4001c2e8: ba 10 00 18 mov %i0, %i5
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
4001c2ec: 7f ff fe 32 call 4001bbb4 <rtems_rfs_bitmap_load_map>
4001c2f0: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
4001c2f4: b0 92 20 00 orcc %o0, 0, %i0
4001c2f8: 24 80 00 04 ble,a 4001c308 <rtems_rfs_bitmap_create_search+0x28>
4001c2fc: de 07 60 14 ld [ %i5 + 0x14 ], %o7
bit++;
map++;
}
return 0;
}
4001c300: 81 c7 e0 08 ret
4001c304: 81 e8 00 00 restore
if (rc > 0)
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
4001c308: f8 07 60 0c ld [ %i5 + 0xc ], %i4
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
4001c30c: c0 27 60 10 clr [ %i5 + 0x10 ]
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
4001c310: 82 10 3f ff mov -1, %g1
4001c314: c2 23 c0 00 st %g1, [ %o7 ]
4001c318: f4 07 bf fc ld [ %fp + -4 ], %i2
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
4001c31c: b2 10 20 00 clr %i1
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
4001c320: 98 10 20 20 mov 0x20, %o4
4001c324: 9a 10 3f ff mov -1, %o5
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
4001c328: 80 a7 20 00 cmp %i4, 0
4001c32c: 02 80 00 20 be 4001c3ac <rtems_rfs_bitmap_create_search+0xcc><== NEVER TAKEN
4001c330: b6 10 20 01 mov 1, %i3
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
4001c334: 80 a7 20 1f cmp %i4, 0x1f
4001c338: 38 80 00 1f bgu,a 4001c3b4 <rtems_rfs_bitmap_create_search+0xd4>
4001c33c: c6 06 80 00 ld [ %i2 ], %g3
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
4001c340: c2 06 80 00 ld [ %i2 ], %g1
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
4001c344: 86 23 00 1c sub %o4, %i4, %g3
if (size < rtems_rfs_bitmap_element_bits ())
{
bits = rtems_rfs_bitmap_merge (*map,
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask_section (0, size));
available = size;
4001c348: 88 10 00 1c mov %i4, %g4
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
4001c34c: 87 33 40 03 srl %o5, %g3, %g3
if (size < rtems_rfs_bitmap_element_bits ())
{
bits = rtems_rfs_bitmap_merge (*map,
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask_section (0, size));
available = size;
4001c350: b0 10 00 1c mov %i4, %i0
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
4001c354: 86 08 c0 01 and %g3, %g1, %g3
{
bits = *map;
available = rtems_rfs_bitmap_element_bits ();
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
4001c358: 80 a0 e0 00 cmp %g3, 0
4001c35c: 02 80 00 0e be 4001c394 <rtems_rfs_bitmap_create_search+0xb4>
4001c360: 80 a6 60 20 cmp %i1, 0x20
4001c364: 82 10 20 00 clr %g1
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
4001c368: 85 2e c0 01 sll %i3, %g1, %g2
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
4001c36c: 80 88 80 03 btst %g2, %g3
4001c370: 02 80 00 05 be 4001c384 <rtems_rfs_bitmap_create_search+0xa4>
4001c374: 82 00 60 01 inc %g1
control->free++;
4001c378: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4001c37c: 84 00 a0 01 inc %g2
4001c380: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
4001c384: 80 a1 00 01 cmp %g4, %g1
4001c388: 14 bf ff f9 bg 4001c36c <rtems_rfs_bitmap_create_search+0x8c>
4001c38c: 85 2e c0 01 sll %i3, %g1, %g2
control->free++;
}
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
4001c390: 80 a6 60 20 cmp %i1, 0x20
4001c394: 02 80 00 0b be 4001c3c0 <rtems_rfs_bitmap_create_search+0xe0>
4001c398: b8 27 00 18 sub %i4, %i0, %i4
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
else
bit++;
4001c39c: b2 06 60 01 inc %i1
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
4001c3a0: 80 a7 20 00 cmp %i4, 0
4001c3a4: 12 bf ff e4 bne 4001c334 <rtems_rfs_bitmap_create_search+0x54>
4001c3a8: b4 06 a0 04 add %i2, 4, %i2
else
bit++;
map++;
}
return 0;
4001c3ac: 81 c7 e0 08 ret
4001c3b0: 91 e8 20 00 restore %g0, 0, %o0
rtems_rfs_bitmap_mask_section (0, size));
available = size;
}
else
{
bits = *map;
4001c3b4: b0 10 20 20 mov 0x20, %i0
available = rtems_rfs_bitmap_element_bits ();
4001c3b8: 10 bf ff e8 b 4001c358 <rtems_rfs_bitmap_create_search+0x78>
4001c3bc: 88 10 20 20 mov 0x20, %g4
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
4001c3c0: 82 10 3f ff mov -1, %g1
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
4001c3c4: b2 10 20 00 clr %i1
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
4001c3c8: c2 23 e0 04 st %g1, [ %o7 + 4 ]
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
search_map++;
4001c3cc: 10 bf ff f5 b 4001c3a0 <rtems_rfs_bitmap_create_search+0xc0>
4001c3d0: 9e 03 e0 04 add %o7, 4, %o7
4001bbb4 <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)
{
4001bbb4: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (!control->buffer)
4001bbb8: 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)
{
4001bbbc: ba 10 00 18 mov %i0, %i5
int rc;
if (!control->buffer)
4001bbc0: 80 a0 60 00 cmp %g1, 0
4001bbc4: 02 80 00 0f be 4001bc00 <rtems_rfs_bitmap_load_map+0x4c>
4001bbc8: b0 10 20 06 mov 6, %i0
return ENXIO;
*map = NULL;
4001bbcc: c0 26 40 00 clr [ %i1 ]
rc = rtems_rfs_buffer_handle_request (control->fs,
4001bbd0: d4 07 60 08 ld [ %i5 + 8 ], %o2
4001bbd4: d0 07 60 04 ld [ %i5 + 4 ], %o0
4001bbd8: d2 07 40 00 ld [ %i5 ], %o1
4001bbdc: 40 00 07 11 call 4001d820 <rtems_rfs_buffer_handle_request>
4001bbe0: 96 10 20 01 mov 1, %o3
control->buffer,
control->block,
true);
if (rc)
4001bbe4: b0 92 20 00 orcc %o0, 0, %i0
4001bbe8: 12 80 00 06 bne 4001bc00 <rtems_rfs_bitmap_load_map+0x4c> <== NEVER TAKEN
4001bbec: 01 00 00 00 nop
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
4001bbf0: c2 07 40 00 ld [ %i5 ], %g1
4001bbf4: c2 00 60 08 ld [ %g1 + 8 ], %g1
4001bbf8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001bbfc: c2 26 40 00 st %g1, [ %i1 ]
return 0;
}
4001bc00: 81 c7 e0 08 ret
4001bc04: 81 e8 00 00 restore
4001c1f8 <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)
{
4001c1f8: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
4001c1fc: c0 2e 80 00 clrb [ %i2 ]
* of bits from the original seed above then below. That is search from the
* seed up then from the seed down a window number of bits, then repeat the
* process from the window distance from the seed, again above then
* below. Keep moving out until all bits have been searched.
*/
upper_seed = seed;
4001c200: ba 10 00 19 mov %i1, %i5
* we have searched all of the map. The seed may not be aligned to a window
* boundary so we may need to search a partial window and this may also not
* be balanced for the upper or lower seeds. We move to the limits, search
* then return false if no clear bits are found.
*/
while (((upper_seed >= 0) && (upper_seed < control->size))
4001c204: 80 a7 60 00 cmp %i5, 0
4001c208: 06 80 00 1f bl 4001c284 <rtems_rfs_bitmap_map_alloc+0x8c>
4001c20c: 80 a6 60 00 cmp %i1, 0
4001c210: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001c214: 80 a7 40 01 cmp %i5, %g1
4001c218: 1a 80 00 1b bcc 4001c284 <rtems_rfs_bitmap_map_alloc+0x8c>
4001c21c: 80 a6 60 00 cmp %i1, 0
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
{
*bit = upper_seed;
4001c220: fa 26 c0 00 st %i5, [ %i3 ]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
4001c224: 90 10 00 18 mov %i0, %o0
4001c228: 92 10 00 1b mov %i3, %o1
4001c22c: 94 10 00 1a mov %i2, %o2
4001c230: 7f ff fe 76 call 4001bc08 <rtems_rfs_search_map_for_clear_bit.constprop.1>
4001c234: 96 10 20 01 mov 1, %o3
window, 1);
if ((rc > 0) || *allocated)
4001c238: 80 a2 20 00 cmp %o0, 0
4001c23c: 14 80 00 27 bg 4001c2d8 <rtems_rfs_bitmap_map_alloc+0xe0> <== NEVER TAKEN
4001c240: 01 00 00 00 nop
4001c244: c2 0e 80 00 ldub [ %i2 ], %g1
4001c248: 80 a0 60 00 cmp %g1, 0
4001c24c: 12 80 00 23 bne 4001c2d8 <rtems_rfs_bitmap_map_alloc+0xe0>
4001c250: 80 a6 60 00 cmp %i1, 0
break;
}
if (lower_seed >= 0)
4001c254: 36 80 00 15 bge,a 4001c2a8 <rtems_rfs_bitmap_map_alloc+0xb0>
4001c258: 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)
4001c25c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001c260: 80 a0 40 1d cmp %g1, %i5
4001c264: 38 80 00 02 bgu,a 4001c26c <rtems_rfs_bitmap_map_alloc+0x74>
4001c268: ba 07 68 00 add %i5, 0x800, %i5
upper_seed += window;
if (lower_seed >= 0)
4001c26c: 80 a6 60 00 cmp %i1, 0
4001c270: 06 bf ff e5 bl 4001c204 <rtems_rfs_bitmap_map_alloc+0xc>
4001c274: 80 a7 60 00 cmp %i5, 0
* we have searched all of the map. The seed may not be aligned to a window
* boundary so we may need to search a partial window and this may also not
* be balanced for the upper or lower seeds. We move to the limits, search
* then return false if no clear bits are found.
*/
while (((upper_seed >= 0) && (upper_seed < control->size))
4001c278: 16 bf ff e6 bge 4001c210 <rtems_rfs_bitmap_map_alloc+0x18><== ALWAYS TAKEN
4001c27c: b2 06 78 00 add %i1, -2048, %i1
|| ((lower_seed >= 0) && (lower_seed < control->size)))
4001c280: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4001c284: 06 80 00 15 bl 4001c2d8 <rtems_rfs_bitmap_map_alloc+0xe0>
4001c288: 01 00 00 00 nop
4001c28c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001c290: 80 a6 40 01 cmp %i1, %g1
4001c294: 1a 80 00 11 bcc 4001c2d8 <rtems_rfs_bitmap_map_alloc+0xe0>
4001c298: 80 a0 40 1d cmp %g1, %i5
{
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
4001c29c: 38 bf ff e2 bgu,a 4001c224 <rtems_rfs_bitmap_map_alloc+0x2c><== NEVER TAKEN
4001c2a0: fa 26 c0 00 st %i5, [ %i3 ] <== NOT EXECUTED
break;
}
if (lower_seed >= 0)
{
*bit = lower_seed;
4001c2a4: f2 26 c0 00 st %i1, [ %i3 ]
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
4001c2a8: 90 10 00 18 mov %i0, %o0
4001c2ac: 92 10 00 1b mov %i3, %o1
4001c2b0: 94 10 00 1a mov %i2, %o2
4001c2b4: 7f ff fe 55 call 4001bc08 <rtems_rfs_search_map_for_clear_bit.constprop.1>
4001c2b8: 96 10 3f ff mov -1, %o3
window, -1);
if ((rc > 0) || *allocated)
4001c2bc: 80 a2 20 00 cmp %o0, 0
4001c2c0: 14 80 00 06 bg 4001c2d8 <rtems_rfs_bitmap_map_alloc+0xe0> <== NEVER TAKEN
4001c2c4: 01 00 00 00 nop
4001c2c8: c2 0e 80 00 ldub [ %i2 ], %g1
4001c2cc: 80 a0 60 00 cmp %g1, 0
4001c2d0: 22 bf ff e4 be,a 4001c260 <rtems_rfs_bitmap_map_alloc+0x68>
4001c2d4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
4001c2d8: 81 c7 e0 08 ret
4001c2dc: 91 e8 20 00 restore %g0, 0, %o0
4001bee0 <rtems_rfs_bitmap_mask>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
4001bee0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
4001bee4: 90 20 00 08 neg %o0 <== NOT EXECUTED
return mask;
}
4001bee8: 81 c3 e0 08 retl <== NOT EXECUTED
4001beec: 91 30 40 08 srl %g1, %o0, %o0 <== NOT EXECUTED
4001bef0 <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
4001bef0: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
rtems_rfs_bitmap_element mask = 0;
if (end > start)
4001bef4: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
4001bef8: 08 80 00 06 bleu 4001bf10 <rtems_rfs_bitmap_mask_section+0x20><== NOT EXECUTED
4001befc: 90 10 20 00 clr %o0 <== NOT EXECUTED
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
4001bf00: 92 20 40 09 sub %g1, %o1, %o1 <== NOT EXECUTED
4001bf04: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
4001bf08: 91 32 00 09 srl %o0, %o1, %o0 <== NOT EXECUTED
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
if (end > start)
mask = rtems_rfs_bitmap_mask (end - start) << start;
4001bf0c: 91 2a 00 01 sll %o0, %g1, %o0 <== NOT EXECUTED
return mask;
}
4001bf10: 81 c3 e0 08 retl <== NOT EXECUTED
4001c630 <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)
{
4001c630: 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);
4001c634: 96 10 20 01 mov 1, %o3
4001c638: 90 10 00 18 mov %i0, %o0
4001c63c: 92 10 00 19 mov %i1, %o1
4001c640: 40 00 04 78 call 4001d820 <rtems_rfs_buffer_handle_request>
4001c644: 94 10 00 1a mov %i2, %o2
if (rc > 0)
4001c648: 80 a2 20 00 cmp %o0, 0
4001c64c: 24 80 00 04 ble,a 4001c65c <rtems_rfs_block_find_indirect+0x2c><== ALWAYS TAKEN
4001c650: c4 06 60 08 ld [ %i1 + 8 ], %g2
*result = 0;
rc = EIO;
}
return 0;
}
4001c654: 81 c7 e0 08 ret
4001c658: 91 e8 00 08 restore %g0, %o0, %o0
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
4001c65c: 83 2e e0 02 sll %i3, 2, %g1
4001c660: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
4001c664: c8 06 20 04 ld [ %i0 + 4 ], %g4
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
4001c668: fa 08 c0 01 ldub [ %g3 + %g1 ], %i5
4001c66c: 84 00 c0 01 add %g3, %g1, %g2
4001c670: c2 08 a0 03 ldub [ %g2 + 3 ], %g1
4001c674: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
4001c678: c4 08 a0 02 ldub [ %g2 + 2 ], %g2
4001c67c: bb 2f 60 18 sll %i5, 0x18, %i5
4001c680: 85 28 a0 08 sll %g2, 8, %g2
4001c684: 87 28 e0 10 sll %g3, 0x10, %g3
4001c688: 82 10 40 1d or %g1, %i5, %g1
4001c68c: 82 10 40 03 or %g1, %g3, %g1
4001c690: 82 10 40 02 or %g1, %g2, %g1
if ((*result + 1) == 0)
*result = 0;
4001c694: 84 38 00 01 xnor %g0, %g1, %g2
4001c698: 80 a0 00 02 cmp %g0, %g2
4001c69c: 84 60 20 00 subx %g0, 0, %g2
4001c6a0: 82 08 40 02 and %g1, %g2, %g1
4001c6a4: c2 27 00 00 st %g1, [ %i4 ]
if (*result >= rtems_rfs_fs_blocks (fs))
4001c6a8: 80 a1 00 01 cmp %g4, %g1
4001c6ac: 18 bf ff ea bgu 4001c654 <rtems_rfs_block_find_indirect+0x24><== ALWAYS TAKEN
4001c6b0: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
4001c6b4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001c6b8: 7f ff e2 7b call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001c6bc: 13 00 00 04 sethi %hi(0x1000), %o1 <== NOT EXECUTED
4001c6c0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001c6c4: 32 80 00 06 bne,a 4001c6dc <rtems_rfs_block_find_indirect+0xac><== NOT EXECUTED
4001c6c8: d2 07 00 00 ld [ %i4 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
4001c6cc: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
4001c6d0: 90 10 20 00 clr %o0 <== NOT EXECUTED
rc = EIO;
}
return 0;
}
4001c6d4: 81 c7 e0 08 ret <== NOT EXECUTED
4001c6d8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
printf ("rtems-rfs: block-find: invalid block in table:"
4001c6dc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001c6e0: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001c6e4: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4001c6e8: 40 00 22 a5 call 4002517c <printf> <== NOT EXECUTED
4001c6ec: 90 12 22 38 or %o0, 0x238, %o0 <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
4001c6f0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001c6f4: 10 bf ff f8 b 4001c6d4 <rtems_rfs_block_find_indirect+0xa4><== NOT EXECUTED
4001c6f8: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
4001c75c <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)
{
4001c75c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if (pos == 0)
4001c760: 80 96 40 1a orcc %i1, %i2, %g0 <== NOT EXECUTED
4001c764: 02 80 00 11 be 4001c7a8 <rtems_rfs_block_get_block_size+0x4c><== NOT EXECUTED
4001c768: 94 10 20 00 clr %o2 <== NOT EXECUTED
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
4001c76c: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== NOT EXECUTED
4001c770: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
4001c774: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4001c778: 40 00 56 d4 call 400322c8 <__udivdi3> <== NOT EXECUTED
4001c77c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001c780: 92 02 60 01 inc %o1 <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
4001c784: 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;
4001c788: d2 26 c0 00 st %o1, [ %i3 ] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
4001c78c: 94 10 20 00 clr %o2 <== NOT EXECUTED
4001c790: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001c794: 40 00 57 a1 call 40032618 <__umoddi3> <== NOT EXECUTED
4001c798: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
4001c79c: d2 26 e0 04 st %o1, [ %i3 + 4 ] <== NOT EXECUTED
4001c7a0: 81 c7 e0 08 ret <== NOT EXECUTED
4001c7a4: 81 e8 00 00 restore <== NOT EXECUTED
* @param size A pointer to the block size.
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
4001c7a8: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
size->offset = 0;
4001c7ac: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
4001c7b0: 81 c7 e0 08 ret <== NOT EXECUTED
4001c7b4: 81 e8 00 00 restore <== NOT EXECUTED
4001c994 <rtems_rfs_block_map_close>:
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
4001c994: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
int brc;
if (map->dirty && map->inode)
4001c998: c2 0e 40 00 ldub [ %i1 ], %g1
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
4001c99c: ba 10 00 18 mov %i0, %i5
int rc = 0;
int brc;
if (map->dirty && map->inode)
4001c9a0: 80 a0 60 00 cmp %g1, 0
4001c9a4: 02 80 00 0b be 4001c9d0 <rtems_rfs_block_map_close+0x3c>
4001c9a8: b0 10 20 00 clr %i0
4001c9ac: d2 06 60 04 ld [ %i1 + 4 ], %o1
4001c9b0: 80 a2 60 00 cmp %o1, 0
4001c9b4: 22 80 00 08 be,a 4001c9d4 <rtems_rfs_block_map_close+0x40><== NEVER TAKEN
4001c9b8: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
{
brc = rtems_rfs_inode_load (fs, map->inode);
4001c9bc: 7f ff da e6 call 40013554 <rtems_rfs_inode_load>
4001c9c0: 90 10 00 1d mov %i5, %o0
if (brc > 0)
4001c9c4: b0 92 20 00 orcc %o0, 0, %i0
4001c9c8: 04 80 00 11 ble 4001ca0c <rtems_rfs_block_map_close+0x78> <== ALWAYS TAKEN
4001c9cc: b8 10 00 19 mov %i1, %i4
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4001c9d0: 92 06 60 38 add %i1, 0x38, %o1
map->dirty = false;
}
}
map->inode = NULL;
4001c9d4: c0 26 60 04 clr [ %i1 + 4 ]
4001c9d8: 40 00 03 18 call 4001d638 <rtems_rfs_buffer_handle_release>
4001c9dc: 90 10 00 1d mov %i5, %o0
4001c9e0: 90 10 00 1d mov %i5, %o0
handle->dirty = false;
4001c9e4: c0 2e 60 38 clrb [ %i1 + 0x38 ]
handle->bnum = 0;
4001c9e8: c0 26 60 3c clr [ %i1 + 0x3c ]
handle->buffer = NULL;
4001c9ec: 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);
4001c9f0: 40 00 03 12 call 4001d638 <rtems_rfs_buffer_handle_release>
4001c9f4: 92 06 60 44 add %i1, 0x44, %o1
handle->dirty = false;
4001c9f8: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
4001c9fc: c0 26 60 48 clr [ %i1 + 0x48 ]
handle->buffer = NULL;
4001ca00: 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;
}
4001ca04: 81 c7 e0 08 ret
4001ca08: 81 e8 00 00 restore
int brc;
if (map->dirty && map->inode)
{
brc = rtems_rfs_inode_load (fs, map->inode);
if (brc > 0)
4001ca0c: 88 10 20 00 clr %g4
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001ca10: b0 10 20 01 mov 1, %i0
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
4001ca14: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001ca18: c4 07 20 24 ld [ %i4 + 0x24 ], %g2
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
4001ca1c: f6 00 60 0c ld [ %g1 + 0xc ], %i3
4001ca20: 86 01 20 06 add %g4, 6, %g3
4001ca24: 87 28 e0 02 sll %g3, 2, %g3
4001ca28: b6 06 c0 03 add %i3, %g3, %i3
4001ca2c: b5 30 a0 18 srl %g2, 0x18, %i2
4001ca30: f4 2e e0 04 stb %i2, [ %i3 + 4 ]
4001ca34: f6 00 60 0c ld [ %g1 + 0xc ], %i3
4001ca38: b5 30 a0 10 srl %g2, 0x10, %i2
4001ca3c: b6 06 c0 03 add %i3, %g3, %i3
4001ca40: f4 2e e0 05 stb %i2, [ %i3 + 5 ]
4001ca44: f6 00 60 0c ld [ %g1 + 0xc ], %i3
4001ca48: b5 30 a0 08 srl %g2, 8, %i2
4001ca4c: b6 06 c0 03 add %i3, %g3, %i3
4001ca50: f4 2e e0 06 stb %i2, [ %i3 + 6 ]
4001ca54: f6 00 60 0c ld [ %g1 + 0xc ], %i3
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
4001ca58: 88 01 20 01 inc %g4
4001ca5c: 86 06 c0 03 add %i3, %g3, %g3
4001ca60: c4 28 e0 07 stb %g2, [ %g3 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001ca64: f0 28 60 10 stb %i0, [ %g1 + 0x10 ]
4001ca68: b8 07 20 04 add %i4, 4, %i4
4001ca6c: 80 a1 20 05 cmp %g4, 5
4001ca70: 12 bf ff e9 bne 4001ca14 <rtems_rfs_block_map_close+0x80>
4001ca74: 82 10 20 01 mov 1, %g1
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
4001ca78: c4 06 60 04 ld [ %i1 + 4 ], %g2
4001ca7c: c6 06 60 08 ld [ %i1 + 8 ], %g3
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
4001ca80: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
4001ca84: b9 30 e0 18 srl %g3, 0x18, %i4
4001ca88: f8 29 20 0c stb %i4, [ %g4 + 0xc ]
4001ca8c: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
4001ca90: b9 30 e0 10 srl %g3, 0x10, %i4
4001ca94: f8 29 20 0d stb %i4, [ %g4 + 0xd ]
4001ca98: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
4001ca9c: b9 30 e0 08 srl %g3, 8, %i4
4001caa0: f8 29 20 0e stb %i4, [ %g4 + 0xe ]
4001caa4: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
4001caa8: 90 10 00 1d mov %i5, %o0
4001caac: c6 29 20 0f stb %g3, [ %g4 + 0xf ]
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
4001cab0: c8 06 60 04 ld [ %i1 + 4 ], %g4
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
4001cab4: f6 0e 60 0e ldub [ %i1 + 0xe ], %i3
4001cab8: f8 01 20 0c ld [ %g4 + 0xc ], %i4
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001cabc: c2 28 a0 10 stb %g1, [ %g2 + 0x10 ]
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
4001cac0: c6 06 60 0c ld [ %i1 + 0xc ], %g3
4001cac4: f6 2f 20 0a stb %i3, [ %i4 + 0xa ]
4001cac8: c4 01 20 0c ld [ %g4 + 0xc ], %g2
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
4001cacc: 94 10 20 01 mov 1, %o2
4001cad0: c6 28 a0 0b stb %g3, [ %g2 + 0xb ]
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
4001cad4: c6 06 60 04 ld [ %i1 + 4 ], %g3
4001cad8: 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);
4001cadc: f8 00 e0 0c ld [ %g3 + 0xc ], %i4
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001cae0: c2 29 20 10 stb %g1, [ %g4 + 0x10 ]
* @param block_count The last map block number.
*/
static inline void
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
4001cae4: 89 30 a0 18 srl %g2, 0x18, %g4
4001cae8: c8 2f 20 30 stb %g4, [ %i4 + 0x30 ]
4001caec: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
4001caf0: b9 30 a0 10 srl %g2, 0x10, %i4
4001caf4: f8 29 20 31 stb %i4, [ %g4 + 0x31 ]
4001caf8: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
4001cafc: b9 30 a0 08 srl %g2, 8, %i4
4001cb00: f8 29 20 32 stb %i4, [ %g4 + 0x32 ]
4001cb04: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
4001cb08: c4 29 20 33 stb %g2, [ %g4 + 0x33 ]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
4001cb0c: c4 06 60 04 ld [ %i1 + 4 ], %g2
4001cb10: c8 06 60 20 ld [ %i1 + 0x20 ], %g4
* @param block_count The last data block number.
*/
static inline void
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
4001cb14: f8 00 a0 0c ld [ %g2 + 0xc ], %i4
*/
static inline void
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001cb18: c2 28 e0 10 stb %g1, [ %g3 + 0x10 ]
* @param block_count The last data block number.
*/
static inline void
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
4001cb1c: 87 31 20 18 srl %g4, 0x18, %g3
4001cb20: c6 2f 20 34 stb %g3, [ %i4 + 0x34 ]
4001cb24: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4001cb28: b9 31 20 10 srl %g4, 0x10, %i4
4001cb2c: f8 28 e0 35 stb %i4, [ %g3 + 0x35 ]
4001cb30: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4001cb34: b9 31 20 08 srl %g4, 8, %i4
4001cb38: f8 28 e0 36 stb %i4, [ %g3 + 0x36 ]
4001cb3c: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
4001cb40: c8 28 e0 37 stb %g4, [ %g3 + 0x37 ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
4001cb44: d2 06 60 04 ld [ %i1 + 4 ], %o1
4001cb48: 7f ff da e7 call 400136e4 <rtems_rfs_inode_unload>
4001cb4c: c2 28 a0 10 stb %g1, [ %g2 + 0x10 ]
if (brc > 0)
rc = brc;
map->dirty = false;
4001cb50: c0 2e 40 00 clrb [ %i1 ]
4001cb54: 82 38 00 08 xnor %g0, %o0, %g1
4001cb58: 83 38 60 1f sra %g1, 0x1f, %g1
4001cb5c: 10 bf ff 9d b 4001c9d0 <rtems_rfs_block_map_close+0x3c>
4001cb60: b0 0a 00 01 and %o0, %g1, %i0
4001cb64 <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)
{
4001cb64: 9d e3 bf 98 save %sp, -104, %sp
int rc = 0;
*block = 0;
4001cb68: 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))
4001cb6c: fa 06 80 00 ld [ %i2 ], %i5
int
rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_pos* bpos,
rtems_rfs_block_no* block)
{
4001cb70: a0 10 00 18 mov %i0, %l0
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
4001cb74: 80 a7 60 00 cmp %i5, 0
4001cb78: 02 80 00 05 be 4001cb8c <rtems_rfs_block_map_find+0x28>
4001cb7c: f8 06 60 08 ld [ %i1 + 8 ], %i4
4001cb80: 80 a7 20 00 cmp %i4, 0
4001cb84: 02 80 00 4b be 4001ccb0 <rtems_rfs_block_map_find+0x14c> <== NEVER TAKEN
4001cb88: b0 10 20 06 mov 6, %i0
4001cb8c: 80 a7 40 1c cmp %i5, %i4
4001cb90: 1a 80 00 48 bcc 4001ccb0 <rtems_rfs_block_map_find+0x14c>
4001cb94: b0 10 20 06 mov 6, %i0
return ENXIO;
/*
* If the block position is the same and we have found the block just return it.
*/
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
4001cb98: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4001cb9c: 80 a7 40 01 cmp %i5, %g1
4001cba0: 22 80 00 14 be,a 4001cbf0 <rtems_rfs_block_map_find+0x8c>
4001cba4: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
/*
* Determine the type of access we need to perform. If the number of blocks
* is less than or equal to the number of slots in the inode the blocks are
* directly accessed.
*/
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
4001cba8: 80 a7 20 05 cmp %i4, 5
4001cbac: 38 80 00 16 bgu,a 4001cc04 <rtems_rfs_block_map_find+0xa0>
4001cbb0: e2 04 20 34 ld [ %l0 + 0x34 ], %l1
{
*block = map->blocks[bpos->bno];
4001cbb4: ba 07 60 08 add %i5, 8, %i5
4001cbb8: bb 2f 60 02 sll %i5, 2, %i5
4001cbbc: ba 06 40 1d add %i1, %i5, %i5
4001cbc0: c2 07 60 04 ld [ %i5 + 4 ], %g1
4001cbc4: c2 26 c0 00 st %g1, [ %i3 ]
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
4001cbc8: c6 06 a0 08 ld [ %i2 + 8 ], %g3
4001cbcc: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4001cbd0: c4 06 80 00 ld [ %i2 ], %g2
4001cbd4: c6 26 60 18 st %g3, [ %i1 + 0x18 ]
4001cbd8: c4 26 60 10 st %g2, [ %i1 + 0x10 ]
4001cbdc: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
map->bpos.block = *block;
4001cbe0: c2 06 c0 00 ld [ %i3 ], %g1
4001cbe4: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
}
return rc;
}
4001cbe8: 81 c7 e0 08 ret
4001cbec: 91 e8 20 00 restore %g0, 0, %o0
return ENXIO;
/*
* If the block position is the same and we have found the block just return it.
*/
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
4001cbf0: 80 a0 60 00 cmp %g1, 0
4001cbf4: 02 bf ff ee be 4001cbac <rtems_rfs_block_map_find+0x48>
4001cbf8: 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];
4001cbfc: 10 bf ff f3 b 4001cbc8 <rtems_rfs_block_map_find+0x64>
4001cc00: 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;
4001cc04: 90 10 00 1d mov %i5, %o0
4001cc08: 40 00 52 f3 call 400317d4 <.urem>
4001cc0c: 92 10 00 11 mov %l1, %o1
singly = bpos->bno / fs->blocks_per_block;
4001cc10: 92 10 00 11 mov %l1, %o1
* The map is either singly or doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
4001cc14: a6 10 00 08 mov %o0, %l3
singly = bpos->bno / fs->blocks_per_block;
4001cc18: 7f ff 96 a2 call 400026a0 <.udiv>
4001cc1c: 90 10 00 1d mov %i5, %o0
if (map->size.count <= fs->block_map_singly_blocks)
4001cc20: c2 04 20 38 ld [ %l0 + 0x38 ], %g1
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
singly = bpos->bno / fs->blocks_per_block;
4001cc24: d0 27 bf fc st %o0, [ %fp + -4 ]
if (map->size.count <= fs->block_map_singly_blocks)
4001cc28: 80 a0 40 1c cmp %g1, %i4
4001cc2c: 1a 80 00 23 bcc 4001ccb8 <rtems_rfs_block_map_find+0x154> <== ALWAYS TAKEN
4001cc30: ba 10 00 08 mov %o0, %i5
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
4001cc34: 40 00 52 e8 call 400317d4 <.urem> <== NOT EXECUTED
4001cc38: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
4001cc3c: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
4001cc40: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
4001cc44: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
4001cc48: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED
4001cc4c: 08 80 00 19 bleu 4001ccb0 <rtems_rfs_block_map_find+0x14c><== NOT EXECUTED
4001cc50: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED
/*
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
4001cc54: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4001cc58: 7f ff 96 92 call 400026a0 <.udiv> <== NOT EXECUTED
4001cc5c: 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,
4001cc60: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED
4001cc64: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
4001cc68: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
4001cc6c: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
4001cc70: 92 06 60 44 add %i1, 0x44, %o1 <== NOT EXECUTED
4001cc74: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001cc78: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
4001cc7c: 7f ff fe 6d call 4001c630 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
4001cc80: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
4001cc84: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001cc88: 12 80 00 0a bne 4001ccb0 <rtems_rfs_block_map_find+0x14c> <== NOT EXECUTED
4001cc8c: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
4001cc90: 90 10 00 10 mov %l0, %o0
4001cc94: 92 06 60 38 add %i1, 0x38, %o1
4001cc98: 96 10 00 13 mov %l3, %o3
4001cc9c: 7f ff fe 65 call 4001c630 <rtems_rfs_block_find_indirect>
4001cca0: 98 10 00 1b mov %i3, %o4
}
}
}
}
if (rc == 0)
4001cca4: b0 92 20 00 orcc %o0, 0, %i0
4001cca8: 22 bf ff c9 be,a 4001cbcc <rtems_rfs_block_map_find+0x68><== ALWAYS TAKEN
4001ccac: c6 06 a0 08 ld [ %i2 + 8 ], %g3
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
map->bpos.block = *block;
}
return rc;
}
4001ccb0: 81 c7 e0 08 ret
4001ccb4: 81 e8 00 00 restore
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
4001ccb8: 82 02 20 08 add %o0, 8, %g1
4001ccbc: 83 28 60 02 sll %g1, 2, %g1
4001ccc0: 82 06 40 01 add %i1, %g1, %g1
4001ccc4: 10 bf ff f3 b 4001cc90 <rtems_rfs_block_map_find+0x12c>
4001ccc8: d4 00 60 04 ld [ %g1 + 4 ], %o2
4001cd74 <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)
{
4001cd74: 9d e3 bf 98 save %sp, -104, %sp
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
4001cd78: 90 10 20 00 clr %o0
4001cd7c: 7f ff e0 ca call 400150a4 <rtems_rfs_trace>
4001cd80: 13 00 00 08 sethi %hi(0x2000), %o1
4001cd84: 80 8a 20 ff btst 0xff, %o0
4001cd88: 32 80 00 cf bne,a 4001d0c4 <rtems_rfs_block_map_grow+0x350><== NEVER TAKEN
4001cd8c: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
4001cd90: c4 06 60 08 ld [ %i1 + 8 ], %g2
4001cd94: c2 06 20 3c ld [ %i0 + 0x3c ], %g1
4001cd98: 84 06 80 02 add %i2, %g2, %g2
4001cd9c: 80 a0 80 01 cmp %g2, %g1
4001cda0: 0a 80 00 04 bcs 4001cdb0 <rtems_rfs_block_map_grow+0x3c> <== ALWAYS TAKEN
4001cda4: ba 10 20 1b mov 0x1b, %i5
map->last_data_block = block;
map->dirty = true;
}
return 0;
}
4001cda8: 81 c7 e0 08 ret
4001cdac: 91 e8 00 1d restore %g0, %i5, %o0
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
4001cdb0: 80 a6 a0 00 cmp %i2, 0
4001cdb4: 02 80 00 de be 4001d12c <rtems_rfs_block_map_grow+0x3b8> <== NEVER TAKEN
4001cdb8: b8 10 20 00 clr %i4
4001cdbc: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001cdc0: a2 10 20 01 mov 1, %l1
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
4001cdc4: a6 06 60 44 add %i1, 0x44, %l3
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001cdc8: 10 80 00 11 b 4001ce0c <rtems_rfs_block_map_grow+0x98>
4001cdcc: a4 06 60 38 add %i1, 0x38, %l2
false, &block);
if (rc > 0)
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
map->blocks[map->size.count] = block;
4001cdd0: 82 07 60 08 add %i5, 8, %g1
4001cdd4: 83 28 60 02 sll %g1, 2, %g1
4001cdd8: 82 06 40 01 add %i1, %g1, %g1
4001cddc: d2 20 60 04 st %o1, [ %g1 + 4 ]
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
4001cde0: ba 07 60 01 inc %i5
map->size.offset = 0;
4001cde4: c0 26 60 0c clr [ %i1 + 0xc ]
if (b == 0)
4001cde8: 80 a7 20 00 cmp %i4, 0
4001cdec: 12 80 00 03 bne 4001cdf8 <rtems_rfs_block_map_grow+0x84> <== NEVER TAKEN
4001cdf0: fa 26 60 08 st %i5, [ %i1 + 8 ]
*new_block = block;
4001cdf4: d2 26 c0 00 st %o1, [ %i3 ]
map->last_data_block = block;
map->dirty = true;
4001cdf8: e2 2e 40 00 stb %l1, [ %i1 ]
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
4001cdfc: b8 07 20 01 inc %i4
4001ce00: 80 a7 00 1a cmp %i4, %i2
4001ce04: 02 80 00 ca be 4001d12c <rtems_rfs_block_map_grow+0x3b8> <== ALWAYS TAKEN
4001ce08: d2 26 60 20 st %o1, [ %i1 + 0x20 ]
/*
* Allocate the block. If an indirect block is needed and cannot be
* allocated free this block.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
4001ce0c: 90 10 00 18 mov %i0, %o0
4001ce10: 94 10 20 00 clr %o2
4001ce14: 7f ff d8 80 call 40013014 <rtems_rfs_group_bitmap_alloc>
4001ce18: 96 07 bf f8 add %fp, -8, %o3
false, &block);
if (rc > 0)
4001ce1c: ba 92 20 00 orcc %o0, 0, %i5
4001ce20: 14 bf ff e2 bg 4001cda8 <rtems_rfs_block_map_grow+0x34>
4001ce24: 01 00 00 00 nop
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
4001ce28: fa 06 60 08 ld [ %i1 + 8 ], %i5
4001ce2c: 80 a7 60 04 cmp %i5, 4
4001ce30: 08 bf ff e8 bleu 4001cdd0 <rtems_rfs_block_map_grow+0x5c>
4001ce34: d2 07 bf f8 ld [ %fp + -8 ], %o1
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
4001ce38: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
4001ce3c: 90 10 00 1d mov %i5, %o0
4001ce40: 40 00 52 65 call 400317d4 <.urem>
4001ce44: 92 10 00 10 mov %l0, %o1
singly = map->size.count / fs->blocks_per_block;
4001ce48: 92 10 00 10 mov %l0, %o1
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
4001ce4c: a8 10 00 08 mov %o0, %l4
singly = map->size.count / fs->blocks_per_block;
4001ce50: 7f ff 96 14 call 400026a0 <.udiv>
4001ce54: 90 10 00 1d mov %i5, %o0
if (map->size.count < fs->block_map_singly_blocks)
4001ce58: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
4001ce5c: 80 a7 40 01 cmp %i5, %g1
4001ce60: 1a 80 00 31 bcc 4001cf24 <rtems_rfs_block_map_grow+0x1b0> <== NEVER TAKEN
4001ce64: aa 10 00 08 mov %o0, %l5
* Singly indirect tables are being used. Allocate a new block for a
* mapping table if direct is 0 or we are moving up (upping). If upping
* move the direct blocks into the table and if not this is the first
* entry of a new block.
*/
if ((direct == 0) ||
4001ce68: 80 a5 20 00 cmp %l4, 0
4001ce6c: 02 80 00 06 be 4001ce84 <rtems_rfs_block_map_grow+0x110> <== NEVER TAKEN
4001ce70: 80 a5 20 05 cmp %l4, 5
4001ce74: 12 80 00 8a bne 4001d09c <rtems_rfs_block_map_grow+0x328>
4001ce78: 80 a2 20 00 cmp %o0, 0
4001ce7c: 12 80 00 89 bne 4001d0a0 <rtems_rfs_block_map_grow+0x32c> <== NEVER TAKEN
4001ce80: 82 05 60 08 add %l5, 8, %g1
{
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
4001ce84: ba 1f 60 05 xor %i5, 5, %i5
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001ce88: 80 a0 00 1d cmp %g0, %i5
&map->singly_buffer,
&map->blocks[singly],
4001ce8c: 96 05 60 08 add %l5, 8, %o3
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001ce90: 90 10 00 18 mov %i0, %o0
&map->singly_buffer,
&map->blocks[singly],
4001ce94: 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,
4001ce98: 92 10 00 19 mov %i1, %o1
&map->singly_buffer,
&map->blocks[singly],
4001ce9c: 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,
4001cea0: 94 10 00 12 mov %l2, %o2
4001cea4: 96 02 e0 04 add %o3, 4, %o3
4001cea8: 7f ff fd 8f call 4001c4e4 <rtems_rfs_block_map_indirect_alloc>
4001ceac: 98 60 3f ff subx %g0, -1, %o4
4001ceb0: ba 10 00 08 mov %o0, %i5
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
4001ceb4: 80 a7 60 00 cmp %i5, 0
4001ceb8: 14 80 00 a1 bg 4001d13c <rtems_rfs_block_map_grow+0x3c8> <== NEVER TAKEN
4001cebc: d4 07 bf f8 ld [ %fp + -8 ], %o2
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001cec0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001cec4: c4 0f bf f8 ldub [ %fp + -8 ], %g2
4001cec8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001cecc: 91 2d 20 02 sll %l4, 2, %o0
4001ced0: c4 28 40 08 stb %g2, [ %g1 + %o0 ]
4001ced4: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001ced8: c4 17 bf f8 lduh [ %fp + -8 ], %g2
4001cedc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001cee0: 82 00 40 08 add %g1, %o0, %g1
4001cee4: c4 28 60 01 stb %g2, [ %g1 + 1 ]
4001cee8: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001ceec: c4 07 bf f8 ld [ %fp + -8 ], %g2
4001cef0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001cef4: 85 30 a0 08 srl %g2, 8, %g2
4001cef8: 82 00 40 08 add %g1, %o0, %g1
4001cefc: c4 28 60 02 stb %g2, [ %g1 + 2 ]
4001cf00: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001cf04: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001cf08: 90 00 40 08 add %g1, %o0, %o0
4001cf0c: c2 07 bf f8 ld [ %fp + -8 ], %g1
4001cf10: c2 2a 20 03 stb %g1, [ %o0 + 3 ]
4001cf14: e2 2e 60 38 stb %l1, [ %i1 + 0x38 ]
4001cf18: fa 06 60 08 ld [ %i1 + 8 ], %i5
4001cf1c: 10 bf ff b1 b 4001cde0 <rtems_rfs_block_map_grow+0x6c>
4001cf20: d2 07 bf f8 ld [ %fp + -8 ], %o1
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
4001cf24: 7f ff 95 df call 400026a0 <.udiv> <== NOT EXECUTED
4001cf28: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
singly %= fs->blocks_per_block;
4001cf2c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
4001cf30: ac 10 00 08 mov %o0, %l6 <== NOT EXECUTED
singly %= fs->blocks_per_block;
4001cf34: 40 00 52 28 call 400317d4 <.urem> <== NOT EXECUTED
4001cf38: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
* Allocate a new block for a singly indirect table if direct is 0 as
* it is the first entry of a new block. We may also need to allocate a
* doubly indirect block as well. Both always occur when direct is 0
* and the doubly indirect block when singly is 0.
*/
if (direct == 0)
4001cf3c: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
4001cf40: 12 80 00 38 bne 4001d020 <rtems_rfs_block_map_grow+0x2ac> <== NOT EXECUTED
4001cf44: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001cf48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001cf4c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001cf50: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
4001cf54: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
4001cf58: 7f ff fd 63 call 4001c4e4 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
4001cf5c: 98 10 20 00 clr %o4 <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
4001cf60: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4001cf64: 14 80 00 75 bg 4001d138 <rtems_rfs_block_map_grow+0x3c4> <== NOT EXECUTED
4001cf68: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
/*
* Allocate a new block for a doubly indirect table if singly is 0 as
* it is the first entry of a new singly indirect block.
*/
if ((singly == 0) ||
4001cf6c: 02 80 00 06 be 4001cf84 <rtems_rfs_block_map_grow+0x210> <== NOT EXECUTED
4001cf70: 80 a4 20 05 cmp %l0, 5 <== NOT EXECUTED
4001cf74: 12 80 00 5a bne 4001d0dc <rtems_rfs_block_map_grow+0x368> <== NOT EXECUTED
4001cf78: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
4001cf7c: 12 80 00 59 bne 4001d0e0 <rtems_rfs_block_map_grow+0x36c> <== NOT EXECUTED
4001cf80: 82 05 a0 08 add %l6, 8, %g1 <== NOT EXECUTED
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
4001cf84: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
4001cf88: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
&map->doubly_buffer,
&map->blocks[doubly],
4001cf8c: 96 05 a0 08 add %l6, 8, %o3 <== NOT EXECUTED
*/
if ((singly == 0) ||
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
4001cf90: 82 18 80 01 xor %g2, %g1, %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
4001cf94: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
4001cf98: 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,
4001cf9c: 98 60 3f ff subx %g0, -1, %o4 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
4001cfa0: 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,
4001cfa4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001cfa8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001cfac: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
4001cfb0: 7f ff fd 4d call 4001c4e4 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
4001cfb4: 96 02 e0 04 add %o3, 4, %o3 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
upping);
if (rc > 0)
4001cfb8: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4001cfbc: 14 80 00 54 bg 4001d10c <rtems_rfs_block_map_grow+0x398> <== NOT EXECUTED
4001cfc0: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
4001cfc4: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001cfc8: c4 0f bf fc ldub [ %fp + -4 ], %g2 <== NOT EXECUTED
4001cfcc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001cfd0: a1 2c 20 02 sll %l0, 2, %l0 <== NOT EXECUTED
4001cfd4: c4 28 40 10 stb %g2, [ %g1 + %l0 ] <== NOT EXECUTED
4001cfd8: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001cfdc: c4 17 bf fc lduh [ %fp + -4 ], %g2 <== NOT EXECUTED
4001cfe0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001cfe4: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED
4001cfe8: c4 28 60 01 stb %g2, [ %g1 + 1 ] <== NOT EXECUTED
4001cfec: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001cff0: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
4001cff4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001cff8: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED
4001cffc: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED
4001d000: c4 28 60 02 stb %g2, [ %g1 + 2 ] <== NOT EXECUTED
4001d004: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001d008: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4001d00c: a0 00 40 10 add %g1, %l0, %l0 <== NOT EXECUTED
4001d010: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
4001d014: c2 2c 20 03 stb %g1, [ %l0 + 3 ] <== NOT EXECUTED
4001d018: 10 bf ff aa b 4001cec0 <rtems_rfs_block_map_grow+0x14c> <== NOT EXECUTED
4001d01c: e2 2e 60 44 stb %l1, [ %i1 + 0x44 ] <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
4001d020: ac 05 a0 08 add %l6, 8, %l6 <== NOT EXECUTED
4001d024: ad 2d a0 02 sll %l6, 2, %l6 <== NOT EXECUTED
4001d028: ac 06 40 16 add %i1, %l6, %l6 <== NOT EXECUTED
4001d02c: d4 05 a0 04 ld [ %l6 + 4 ], %o2 <== NOT EXECUTED
4001d030: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001d034: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
4001d038: 40 00 01 fa call 4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001d03c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
4001d040: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4001d044: 14 80 00 3d bg 4001d138 <rtems_rfs_block_map_grow+0x3c4> <== NOT EXECUTED
4001d048: a1 2c 20 02 sll %l0, 2, %l0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001d04c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001d050: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d054: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001d058: c6 08 80 10 ldub [ %g2 + %l0 ], %g3 <== NOT EXECUTED
4001d05c: 82 00 80 10 add %g2, %l0, %g1 <== NOT EXECUTED
4001d060: d4 08 60 03 ldub [ %g1 + 3 ], %o2 <== NOT EXECUTED
4001d064: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
4001d068: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
4001d06c: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
4001d070: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4001d074: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001d078: 94 12 80 03 or %o2, %g3, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d07c: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001d080: 94 12 80 02 or %o2, %g2, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d084: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
4001d088: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d08c: 40 00 01 e5 call 4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001d090: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED
4001d094: 10 bf ff 88 b 4001ceb4 <rtems_rfs_block_map_grow+0x140> <== NOT EXECUTED
4001d098: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d09c: 82 05 60 08 add %l5, 8, %g1
4001d0a0: 83 28 60 02 sll %g1, 2, %g1
4001d0a4: 82 06 40 01 add %i1, %g1, %g1
4001d0a8: d4 00 60 04 ld [ %g1 + 4 ], %o2
4001d0ac: 90 10 00 18 mov %i0, %o0
4001d0b0: 92 10 00 12 mov %l2, %o1
4001d0b4: 40 00 01 db call 4001d820 <rtems_rfs_buffer_handle_request>
4001d0b8: 96 10 20 01 mov 1, %o3
4001d0bc: 10 bf ff 7e b 4001ceb4 <rtems_rfs_block_map_grow+0x140>
4001d0c0: ba 10 00 08 mov %o0, %i5
rtems_rfs_block_no* new_block)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
4001d0c4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001d0c8: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001d0cc: 40 00 20 2c call 4002517c <printf> <== NOT EXECUTED
4001d0d0: 90 12 22 88 or %o0, 0x288, %o0 ! 40037e88 <CSWTCH.2+0x98> <== NOT EXECUTED
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
4001d0d4: 10 bf ff 30 b 4001cd94 <rtems_rfs_block_map_grow+0x20> <== NOT EXECUTED
4001d0d8: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001d0dc: 82 05 a0 08 add %l6, 8, %g1 <== NOT EXECUTED
4001d0e0: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
4001d0e4: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
4001d0e8: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
4001d0ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001d0f0: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
4001d0f4: 40 00 01 cb call 4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001d0f8: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
4001d0fc: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4001d100: 24 bf ff b2 ble,a 4001cfc8 <rtems_rfs_block_map_grow+0x254><== NOT EXECUTED
4001d104: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
4001d108: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
4001d10c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001d110: 7f ff d8 50 call 40013250 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001d114: 92 10 20 00 clr %o1 <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
4001d118: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
4001d11c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001d120: 7f ff d8 4c call 40013250 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001d124: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001d128: 30 bf ff 20 b,a 4001cda8 <rtems_rfs_block_map_grow+0x34> <== NOT EXECUTED
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
4001d12c: ba 10 20 00 clr %i5
}
4001d130: 81 c7 e0 08 ret
4001d134: 91 e8 00 1d restore %g0, %i5, %o0
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
4001d138: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
4001d13c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001d140: 7f ff d8 44 call 40013250 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001d144: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001d148: 30 bf ff 18 b,a 4001cda8 <rtems_rfs_block_map_grow+0x34> <== NOT EXECUTED
4001c4e4 <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)
{
4001c4e4: 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);
4001c4e8: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001c4ec: 94 10 20 00 clr %o2
4001c4f0: 90 10 00 18 mov %i0, %o0
4001c4f4: 7f ff da c8 call 40013014 <rtems_rfs_group_bitmap_alloc>
4001c4f8: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
4001c4fc: ba 92 20 00 orcc %o0, 0, %i5
4001c500: 04 80 00 04 ble 4001c510 <rtems_rfs_block_map_indirect_alloc+0x2c><== ALWAYS TAKEN
4001c504: d4 07 bf fc ld [ %fp + -4 ], %o2
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
map->last_map_block = new_block;
return 0;
}
4001c508: 81 c7 e0 08 ret
4001c50c: 91 e8 00 1d restore %g0, %i5, %o0
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
if (rc > 0)
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
4001c510: 90 10 00 18 mov %i0, %o0
4001c514: 92 10 00 1a mov %i2, %o1
4001c518: 40 00 04 c2 call 4001d820 <rtems_rfs_buffer_handle_request>
4001c51c: 96 10 20 00 clr %o3
if (rc > 0)
4001c520: ba 92 20 00 orcc %o0, 0, %i5
4001c524: 04 80 00 08 ble 4001c544 <rtems_rfs_block_map_indirect_alloc+0x60><== ALWAYS TAKEN
4001c528: d4 07 bf fc ld [ %fp + -4 ], %o2
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
4001c52c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001c530: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001c534: 7f ff db 47 call 40013250 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001c538: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
map->last_map_block = new_block;
return 0;
}
4001c53c: 81 c7 e0 08 ret <== NOT EXECUTED
4001c540: 81 e8 00 00 restore <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
return rc;
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
4001c544: c2 06 a0 08 ld [ %i2 + 8 ], %g1
4001c548: d4 06 20 08 ld [ %i0 + 8 ], %o2
4001c54c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4001c550: 40 00 22 8d call 40024f84 <memset>
4001c554: 92 10 20 ff mov 0xff, %o1
if (upping)
4001c558: 80 a7 20 00 cmp %i4, 0
4001c55c: 12 80 00 08 bne 4001c57c <rtems_rfs_block_map_indirect_alloc+0x98><== ALWAYS TAKEN
4001c560: c2 07 bf fc ld [ %fp + -4 ], %g1
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
4001c564: 84 10 20 01 mov 1, %g2
4001c568: c4 2e 80 00 stb %g2, [ %i2 ]
*block = new_block;
4001c56c: c2 26 c0 00 st %g1, [ %i3 ]
map->last_map_block = new_block;
4001c570: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
return 0;
4001c574: 10 bf ff e5 b 4001c508 <rtems_rfs_block_map_indirect_alloc+0x24>
4001c578: ba 10 20 00 clr %i5
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
if (upping)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
4001c57c: 90 10 20 00 clr %o0
4001c580: 7f ff e2 c9 call 400150a4 <rtems_rfs_trace>
4001c584: 13 00 00 08 sethi %hi(0x2000), %o1
4001c588: 80 8a 20 ff btst 0xff, %o0
4001c58c: 32 80 00 24 bne,a 4001c61c <rtems_rfs_block_map_indirect_alloc+0x138><== NEVER TAKEN
4001c590: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001c594: 84 10 00 19 mov %i1, %g2
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
4001c598: 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]);
4001c59c: ba 10 20 01 mov 1, %i5
4001c5a0: c6 06 a0 08 ld [ %i2 + 8 ], %g3
4001c5a4: c8 08 a0 24 ldub [ %g2 + 0x24 ], %g4
4001c5a8: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
4001c5ac: c8 28 c0 01 stb %g4, [ %g3 + %g1 ]
4001c5b0: c6 06 a0 08 ld [ %i2 + 8 ], %g3
4001c5b4: c8 10 a0 24 lduh [ %g2 + 0x24 ], %g4
4001c5b8: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
4001c5bc: 86 00 c0 01 add %g3, %g1, %g3
4001c5c0: c8 28 e0 01 stb %g4, [ %g3 + 1 ]
4001c5c4: c6 06 a0 08 ld [ %i2 + 8 ], %g3
4001c5c8: c8 00 a0 24 ld [ %g2 + 0x24 ], %g4
4001c5cc: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
4001c5d0: 89 31 20 08 srl %g4, 8, %g4
4001c5d4: 86 00 c0 01 add %g3, %g1, %g3
4001c5d8: c8 28 e0 02 stb %g4, [ %g3 + 2 ]
4001c5dc: c6 06 a0 08 ld [ %i2 + 8 ], %g3
4001c5e0: c8 00 a0 24 ld [ %g2 + 0x24 ], %g4
4001c5e4: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
4001c5e8: 84 00 a0 04 add %g2, 4, %g2
4001c5ec: 86 00 c0 01 add %g3, %g1, %g3
4001c5f0: c8 28 e0 03 stb %g4, [ %g3 + 3 ]
4001c5f4: 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++)
4001c5f8: 80 a0 60 14 cmp %g1, 0x14
4001c5fc: 12 bf ff e9 bne 4001c5a0 <rtems_rfs_block_map_indirect_alloc+0xbc>
4001c600: fa 2e 80 00 stb %i5, [ %i2 ]
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
4001c604: 90 06 60 24 add %i1, 0x24, %o0
4001c608: 92 10 20 00 clr %o1
4001c60c: 40 00 22 5e call 40024f84 <memset>
4001c610: 94 10 20 14 mov 0x14, %o2
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
4001c614: 10 bf ff d4 b 4001c564 <rtems_rfs_block_map_indirect_alloc+0x80>
4001c618: c2 07 bf fc ld [ %fp + -4 ], %g1
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
if (upping)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
4001c61c: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001c620: 40 00 22 d7 call 4002517c <printf> <== NOT EXECUTED
4001c624: 90 12 22 00 or %o0, 0x200, %o0 ! 40037e00 <CSWTCH.2+0x10> <== NOT EXECUTED
4001c628: 10 bf ff dc b 4001c598 <rtems_rfs_block_map_indirect_alloc+0xb4><== NOT EXECUTED
4001c62c: 84 10 00 19 mov %i1, %g2 <== NOT EXECUTED
4001c430 <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)
{
4001c430: 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) ||
4001c434: 80 a7 20 00 cmp %i4, 0
4001c438: 22 80 00 07 be,a 4001c454 <rtems_rfs_block_map_indirect_shrink+0x24><== NEVER TAKEN
4001c43c: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED
4001c440: 80 a7 20 05 cmp %i4, 5
4001c444: 02 80 00 11 be 4001c488 <rtems_rfs_block_map_indirect_shrink+0x58>
4001c448: 80 a6 e0 00 cmp %i3, 0
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no indirect,
rtems_rfs_block_no index)
{
int rc = 0;
4001c44c: 81 c7 e0 08 ret
4001c450: 91 e8 20 00 restore %g0, 0, %o0
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
4001c454: b7 2e e0 02 sll %i3, 2, %i3 <== NOT EXECUTED
4001c458: b6 06 40 1b add %i1, %i3, %i3 <== NOT EXECUTED
4001c45c: f4 06 e0 04 ld [ %i3 + 4 ], %i2 <== NOT EXECUTED
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
4001c460: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
4001c464: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001c468: 92 10 20 00 clr %o1
4001c46c: 7f ff db 79 call 40013250 <rtems_rfs_group_bitmap_free>
4001c470: 94 10 00 1a mov %i2, %o2
if (rc > 0)
4001c474: b0 92 20 00 orcc %o0, 0, %i0
4001c478: 24 80 00 02 ble,a 4001c480 <rtems_rfs_block_map_indirect_shrink+0x50><== ALWAYS TAKEN
4001c47c: f4 26 60 1c st %i2, [ %i1 + 0x1c ]
map->last_map_block = block_to_free;
}
return rc;
}
4001c480: 81 c7 e0 08 ret
4001c484: 81 e8 00 00 restore
* block to be freed and the indirect block is now also free, or we have only
* one indirect table and we can fit the remaining blocks into the inode,
* then either move to the next indirect block or move the remaining blocks
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
4001c488: 12 bf ff f1 bne 4001c44c <rtems_rfs_block_map_indirect_shrink+0x1c><== NEVER TAKEN
4001c48c: 84 10 20 00 clr %g2
4001c490: c2 06 a0 08 ld [ %i2 + 8 ], %g1
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
4001c494: f4 06 60 24 ld [ %i1 + 0x24 ], %i2
4001c498: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
4001c49c: c8 08 40 00 ldub [ %g1 ], %g4
4001c4a0: f6 08 60 01 ldub [ %g1 + 1 ], %i3
4001c4a4: f8 08 60 03 ldub [ %g1 + 3 ], %i4
4001c4a8: fa 08 60 02 ldub [ %g1 + 2 ], %i5
* @param indirect The index index in the inode's block table.
* @param index The index in the indirect table of the block.
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
4001c4ac: 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);
4001c4b0: 89 29 20 18 sll %g4, 0x18, %g4
4001c4b4: b7 2e e0 10 sll %i3, 0x10, %i3
4001c4b8: bb 2f 60 08 sll %i5, 8, %i5
4001c4bc: 88 11 00 1b or %g4, %i3, %g4
4001c4c0: 88 11 00 1c or %g4, %i4, %g4
4001c4c4: 88 11 00 1d or %g4, %i5, %g4
4001c4c8: c8 20 e0 24 st %g4, [ %g3 + 0x24 ]
4001c4cc: 84 00 a0 04 add %g2, 4, %g2
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
4001c4d0: 80 a0 a0 14 cmp %g2, 0x14
4001c4d4: 12 bf ff f2 bne 4001c49c <rtems_rfs_block_map_indirect_shrink+0x6c>
4001c4d8: 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);
4001c4dc: 10 bf ff e3 b 4001c468 <rtems_rfs_block_map_indirect_shrink+0x38>
4001c4e0: 90 10 00 18 mov %i0, %o0
4001c810 <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)
{
4001c810: 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;
4001c814: c0 2e 80 00 clrb [ %i2 ]
map->inode = NULL;
4001c818: 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;
4001c81c: c0 26 a0 08 clr [ %i2 + 8 ]
size->offset = 0;
4001c820: 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;
4001c824: c0 26 a0 10 clr [ %i2 + 0x10 ]
bpos->boff = 0;
4001c828: c0 26 a0 14 clr [ %i2 + 0x14 ]
bpos->block = 0;
4001c82c: 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;
4001c830: c0 2e a0 38 clrb [ %i2 + 0x38 ]
handle->bnum = 0;
4001c834: c0 26 a0 3c clr [ %i2 + 0x3c ]
handle->buffer = NULL;
4001c838: 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;
4001c83c: c0 2e a0 44 clrb [ %i2 + 0x44 ]
handle->bnum = 0;
4001c840: c0 26 a0 48 clr [ %i2 + 0x48 ]
handle->buffer = NULL;
4001c844: 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);
4001c848: 90 10 00 18 mov %i0, %o0
4001c84c: 92 10 00 19 mov %i1, %o1
4001c850: 7f ff db 41 call 40013554 <rtems_rfs_inode_load>
4001c854: ba 10 00 1a mov %i2, %i5
if (rc > 0)
4001c858: b8 92 20 00 orcc %o0, 0, %i4
4001c85c: 14 80 00 3f bg 4001c958 <rtems_rfs_block_map_open+0x148> <== NEVER TAKEN
4001c860: 88 10 00 1a mov %i2, %g4
4001c864: c6 06 60 0c ld [ %i1 + 0xc ], %g3
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
4001c868: f2 26 a0 04 st %i1, [ %i2 + 4 ]
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
4001c86c: 82 10 20 00 clr %g1
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
4001c870: b8 00 60 06 add %g1, 6, %i4
4001c874: b9 2f 20 02 sll %i4, 2, %i4
4001c878: b8 00 c0 1c add %g3, %i4, %i4
4001c87c: de 0f 20 04 ldub [ %i4 + 4 ], %o7
4001c880: f4 0f 20 05 ldub [ %i4 + 5 ], %i2
4001c884: f6 0f 20 07 ldub [ %i4 + 7 ], %i3
4001c888: f8 0f 20 06 ldub [ %i4 + 6 ], %i4
4001c88c: 85 2b e0 18 sll %o7, 0x18, %g2
4001c890: b5 2e a0 10 sll %i2, 0x10, %i2
4001c894: b9 2f 20 08 sll %i4, 8, %i4
4001c898: 84 10 80 1a or %g2, %i2, %g2
4001c89c: 84 10 80 1b or %g2, %i3, %g2
4001c8a0: 84 10 80 1c or %g2, %i4, %g2
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
4001c8a4: c4 21 20 24 st %g2, [ %g4 + 0x24 ]
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
4001c8a8: 82 00 60 01 inc %g1
4001c8ac: 80 a0 60 05 cmp %g1, 5
4001c8b0: 12 bf ff f0 bne 4001c870 <rtems_rfs_block_map_open+0x60>
4001c8b4: 88 01 20 04 add %g4, 4, %g4
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
4001c8b8: c8 08 e0 0f ldub [ %g3 + 0xf ], %g4
4001c8bc: c2 08 e0 0c ldub [ %g3 + 0xc ], %g1
4001c8c0: f8 08 e0 0d ldub [ %g3 + 0xd ], %i4
4001c8c4: c4 08 e0 0e ldub [ %g3 + 0xe ], %g2
4001c8c8: b9 2f 20 10 sll %i4, 0x10, %i4
4001c8cc: 85 28 a0 08 sll %g2, 8, %g2
4001c8d0: 83 28 60 18 sll %g1, 0x18, %g1
4001c8d4: 82 10 40 1c or %g1, %i4, %g1
4001c8d8: 82 10 40 04 or %g1, %g4, %g1
4001c8dc: 82 10 40 02 or %g1, %g2, %g1
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
4001c8e0: c2 27 60 08 st %g1, [ %i5 + 8 ]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
4001c8e4: c4 08 e0 0b ldub [ %g3 + 0xb ], %g2
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
4001c8e8: c2 08 e0 0a ldub [ %g3 + 0xa ], %g1
4001c8ec: 83 28 60 08 sll %g1, 8, %g1
4001c8f0: 82 10 80 01 or %g2, %g1, %g1
4001c8f4: c2 27 60 0c st %g1, [ %i5 + 0xc ]
* @return uint32_t The last map block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_map_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_map_block);
4001c8f8: c8 08 e0 33 ldub [ %g3 + 0x33 ], %g4
4001c8fc: c2 08 e0 30 ldub [ %g3 + 0x30 ], %g1
4001c900: f8 08 e0 31 ldub [ %g3 + 0x31 ], %i4
4001c904: c4 08 e0 32 ldub [ %g3 + 0x32 ], %g2
4001c908: b9 2f 20 10 sll %i4, 0x10, %i4
4001c90c: 85 28 a0 08 sll %g2, 8, %g2
4001c910: 83 28 60 18 sll %g1, 0x18, %g1
4001c914: 82 10 40 1c or %g1, %i4, %g1
4001c918: 82 10 40 04 or %g1, %g4, %g1
4001c91c: 82 10 40 02 or %g1, %g2, %g1
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
4001c920: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
* @return uint32_t The last data block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_data_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_data_block);
4001c924: c2 08 e0 34 ldub [ %g3 + 0x34 ], %g1
4001c928: c8 08 e0 37 ldub [ %g3 + 0x37 ], %g4
4001c92c: c4 08 e0 36 ldub [ %g3 + 0x36 ], %g2
4001c930: f8 08 e0 35 ldub [ %g3 + 0x35 ], %i4
4001c934: 83 28 60 18 sll %g1, 0x18, %g1
4001c938: 87 2f 20 10 sll %i4, 0x10, %g3
4001c93c: 85 28 a0 08 sll %g2, 8, %g2
4001c940: 82 10 40 03 or %g1, %g3, %g1
4001c944: 82 10 40 04 or %g1, %g4, %g1
4001c948: 82 10 40 02 or %g1, %g2, %g1
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
4001c94c: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rc = rtems_rfs_inode_unload (fs, inode, false);
4001c950: 7f ff db 65 call 400136e4 <rtems_rfs_inode_unload>
4001c954: 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);
4001c958: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED
4001c95c: 40 00 03 37 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001c960: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001c964: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
4001c968: c0 2e a0 38 clrb [ %i2 + 0x38 ] <== NOT EXECUTED
handle->bnum = 0;
4001c96c: c0 26 a0 3c clr [ %i2 + 0x3c ] <== NOT EXECUTED
handle->buffer = NULL;
4001c970: 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);
4001c974: 92 06 a0 44 add %i2, 0x44, %o1 <== NOT EXECUTED
4001c978: 40 00 03 30 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001c97c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
handle->dirty = false;
4001c980: c0 2e a0 44 clrb [ %i2 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
4001c984: c0 26 a0 48 clr [ %i2 + 0x48 ] <== NOT EXECUTED
handle->buffer = NULL;
4001c988: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED
return rc;
}
4001c98c: 81 c7 e0 08 ret <== NOT EXECUTED
4001c990: 81 e8 00 00 restore <== NOT EXECUTED
4001d14c <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
4001d14c: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
4001d150: 90 10 20 00 clr %o0
4001d154: 13 00 00 10 sethi %hi(0x4000), %o1
4001d158: 7f ff df d3 call 400150a4 <rtems_rfs_trace>
4001d15c: b6 10 00 18 mov %i0, %i3
4001d160: 80 8a 20 ff btst 0xff, %o0
4001d164: 32 80 00 b0 bne,a 4001d424 <rtems_rfs_block_map_shrink+0x2d8><== NEVER TAKEN
4001d168: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
4001d16c: f8 06 60 08 ld [ %i1 + 8 ], %i4
4001d170: 80 a7 20 00 cmp %i4, 0
4001d174: 02 80 00 a9 be 4001d418 <rtems_rfs_block_map_shrink+0x2cc>
4001d178: 80 a6 80 1c cmp %i2, %i4
4001d17c: 38 80 00 02 bgu,a 4001d184 <rtems_rfs_block_map_shrink+0x38><== NEVER TAKEN
4001d180: b4 10 00 1c mov %i4, %i2 <== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
4001d184: 80 a6 a0 00 cmp %i2, 0
4001d188: 02 80 00 98 be 4001d3e8 <rtems_rfs_block_map_shrink+0x29c><== NEVER TAKEN
4001d18c: a6 06 60 44 add %i1, 0x44, %l3
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d190: a4 06 60 38 add %i1, 0x38, %l2
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
4001d194: 10 80 00 14 b 4001d1e4 <rtems_rfs_block_map_shrink+0x98>
4001d198: a2 10 20 01 mov 1, %l1
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
4001d19c: b9 2f 20 02 sll %i4, 2, %i4
4001d1a0: b8 06 40 1c add %i1, %i4, %i4
4001d1a4: fa 07 20 04 ld [ %i4 + 4 ], %i5
map->blocks[block] = 0;
4001d1a8: c0 27 20 04 clr [ %i4 + 4 ]
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
4001d1ac: 90 10 00 1b mov %i3, %o0
4001d1b0: 92 10 20 00 clr %o1
4001d1b4: 7f ff d8 27 call 40013250 <rtems_rfs_group_bitmap_free>
4001d1b8: 94 10 00 1d mov %i5, %o2
if (rc > 0)
4001d1bc: 80 a2 20 00 cmp %o0, 0
4001d1c0: 14 80 00 63 bg 4001d34c <rtems_rfs_block_map_shrink+0x200><== NEVER TAKEN
4001d1c4: b4 86 bf ff addcc %i2, -1, %i2
return rc;
map->size.count--;
4001d1c8: f8 06 60 08 ld [ %i1 + 8 ], %i4
map->size.offset = 0;
4001d1cc: 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--;
4001d1d0: b8 07 3f ff add %i4, -1, %i4
map->size.offset = 0;
map->last_data_block = block_to_free;
4001d1d4: 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--;
4001d1d8: f8 26 60 08 st %i4, [ %i1 + 8 ]
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
4001d1dc: 02 80 00 80 be 4001d3dc <rtems_rfs_block_map_shrink+0x290>
4001d1e0: e2 2e 40 00 stb %l1, [ %i1 ]
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
4001d1e4: ba 07 3f ff add %i4, -1, %i5
if (block < RTEMS_RFS_INODE_BLOCKS)
4001d1e8: 80 a7 60 04 cmp %i5, 4
4001d1ec: 28 bf ff ec bleu,a 4001d19c <rtems_rfs_block_map_shrink+0x50>
4001d1f0: b8 07 20 07 add %i4, 7, %i4
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
4001d1f4: f0 06 e0 34 ld [ %i3 + 0x34 ], %i0
4001d1f8: 90 10 00 1d mov %i5, %o0
4001d1fc: 40 00 51 76 call 400317d4 <.urem>
4001d200: 92 10 00 18 mov %i0, %o1
singly = block / fs->blocks_per_block;
4001d204: 92 10 00 18 mov %i0, %o1
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
4001d208: a0 10 00 08 mov %o0, %l0
singly = block / fs->blocks_per_block;
4001d20c: 7f ff 95 25 call 400026a0 <.udiv>
4001d210: 90 10 00 1d mov %i5, %o0
if (block < fs->block_map_singly_blocks)
4001d214: c2 06 e0 38 ld [ %i3 + 0x38 ], %g1
4001d218: 80 a7 40 01 cmp %i5, %g1
4001d21c: 0a 80 00 4e bcs 4001d354 <rtems_rfs_block_map_shrink+0x208><== ALWAYS TAKEN
4001d220: a8 10 00 08 mov %o0, %l4
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
singly, direct);
if (rc)
return rc;
}
else if (block < fs->block_map_doubly_blocks)
4001d224: c2 06 e0 3c ld [ %i3 + 0x3c ], %g1 <== NOT EXECUTED
4001d228: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4001d22c: 1a 80 00 6d bcc 4001d3e0 <rtems_rfs_block_map_shrink+0x294><== NOT EXECUTED
4001d230: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
4001d234: 7f ff 95 1b call 400026a0 <.udiv> <== NOT EXECUTED
4001d238: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
4001d23c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
4001d240: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
4001d244: 40 00 51 64 call 400317d4 <.urem> <== NOT EXECUTED
4001d248: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001d24c: 82 07 20 08 add %i4, 8, %g1 <== NOT EXECUTED
4001d250: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
4001d254: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
4001d258: 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;
4001d25c: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001d260: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
4001d264: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001d268: 40 00 01 6e call 4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001d26c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
4001d270: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001d274: 14 80 00 36 bg 4001d34c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
4001d278: 85 2d 20 02 sll %l4, 2, %g2 <== NOT EXECUTED
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
4001d27c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
4001d280: 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,
4001d284: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
4001d288: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
4001d28c: c6 08 c0 02 ldub [ %g3 + %g2 ], %g3 <== NOT EXECUTED
4001d290: ea 08 60 03 ldub [ %g1 + 3 ], %l5 <== NOT EXECUTED
4001d294: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
4001d298: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
4001d29c: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
4001d2a0: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4001d2a4: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001d2a8: aa 15 40 03 or %l5, %g3, %l5 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d2ac: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
4001d2b0: aa 15 40 02 or %l5, %g2, %l5 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d2b4: 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,
4001d2b8: aa 15 40 01 or %l5, %g1, %l5 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d2bc: 40 00 01 59 call 4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001d2c0: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
singly, true);
if (rc > 0)
4001d2c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001d2c8: 14 80 00 21 bg 4001d34c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
4001d2cc: 85 2c 20 02 sll %l0, 2, %g2 <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001d2d0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
4001d2d4: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED
direct);
if (direct == 0)
4001d2d8: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly, true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001d2dc: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
4001d2e0: c6 08 c0 02 ldub [ %g3 + %g2 ], %g3 <== NOT EXECUTED
4001d2e4: fa 08 60 03 ldub [ %g1 + 3 ], %i5 <== NOT EXECUTED
4001d2e8: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
4001d2ec: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
4001d2f0: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
4001d2f4: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4001d2f8: ba 17 40 03 or %i5, %g3, %i5 <== NOT EXECUTED
4001d2fc: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001d300: ba 17 40 02 or %i5, %g2, %i5 <== NOT EXECUTED
direct);
if (direct == 0)
4001d304: 12 bf ff aa bne 4001d1ac <rtems_rfs_block_map_shrink+0x60><== NOT EXECUTED
4001d308: ba 17 40 01 or %i5, %g1, %i5 <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
4001d30c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001d310: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001d314: 7f ff d7 cf call 40013250 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
4001d318: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
if (rc > 0)
4001d31c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001d320: 14 80 00 0b bg 4001d34c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
4001d324: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
return rc;
map->last_map_block = singly;
4001d328: ea 26 60 1c st %l5, [ %i1 + 0x1c ] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
4001d32c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4001d330: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
4001d334: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4001d338: 7f ff fc 3e call 4001c430 <rtems_rfs_block_map_indirect_shrink><== NOT EXECUTED
4001d33c: 98 10 00 14 mov %l4, %o4 <== NOT EXECUTED
doubly, doubly_singly);
if (rc)
4001d340: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001d344: 22 bf ff 9b be,a 4001d1b0 <rtems_rfs_block_map_shrink+0x64><== NOT EXECUTED
4001d348: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
}
4001d34c: 81 c7 e0 08 ret <== NOT EXECUTED
4001d350: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d354: 82 02 20 08 add %o0, 8, %g1
4001d358: 83 28 60 02 sll %g1, 2, %g1
4001d35c: 82 06 40 01 add %i1, %g1, %g1
4001d360: d4 00 60 04 ld [ %g1 + 4 ], %o2
4001d364: 90 10 00 1b mov %i3, %o0
4001d368: 92 10 00 12 mov %l2, %o1
4001d36c: 40 00 01 2d call 4001d820 <rtems_rfs_buffer_handle_request>
4001d370: 96 10 20 01 mov 1, %o3
map->blocks[singly], true);
if (rc > 0)
4001d374: 80 a2 20 00 cmp %o0, 0
4001d378: 14 bf ff f5 bg 4001d34c <rtems_rfs_block_map_shrink+0x200><== NEVER TAKEN
4001d37c: 85 2c 20 02 sll %l0, 2, %g2
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001d380: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4001d384: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001d388: 90 10 00 1b mov %i3, %o0
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001d38c: 82 00 c0 02 add %g3, %g2, %g1
4001d390: c6 08 c0 02 ldub [ %g3 + %g2 ], %g3
4001d394: fa 08 60 03 ldub [ %g1 + 3 ], %i5
4001d398: c4 08 60 01 ldub [ %g1 + 1 ], %g2
4001d39c: c2 08 60 02 ldub [ %g1 + 2 ], %g1
4001d3a0: 87 28 e0 18 sll %g3, 0x18, %g3
4001d3a4: 85 28 a0 10 sll %g2, 0x10, %g2
4001d3a8: 83 28 60 08 sll %g1, 8, %g1
4001d3ac: ba 17 40 03 or %i5, %g3, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001d3b0: 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,
4001d3b4: ba 17 40 02 or %i5, %g2, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001d3b8: 94 10 00 12 mov %l2, %o2
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001d3bc: ba 17 40 01 or %i5, %g1, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001d3c0: 96 10 00 14 mov %l4, %o3
4001d3c4: 7f ff fc 1b call 4001c430 <rtems_rfs_block_map_indirect_shrink>
4001d3c8: 98 10 00 10 mov %l0, %o4
singly, direct);
if (rc)
4001d3cc: 80 a2 20 00 cmp %o0, 0
4001d3d0: 22 bf ff 78 be,a 4001d1b0 <rtems_rfs_block_map_shrink+0x64><== ALWAYS TAKEN
4001d3d4: 90 10 00 1b mov %i3, %o0
4001d3d8: 30 bf ff dd b,a 4001d34c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
4001d3dc: 80 a7 20 00 cmp %i4, 0
4001d3e0: 22 80 00 17 be,a 4001d43c <rtems_rfs_block_map_shrink+0x2f0>
4001d3e4: c0 26 60 1c clr [ %i1 + 0x1c ]
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
4001d3e8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
4001d3ec: 80 a0 80 1c cmp %g2, %i4
4001d3f0: 1a 80 00 14 bcc 4001d440 <rtems_rfs_block_map_shrink+0x2f4><== NEVER TAKEN
4001d3f4: 82 07 3f ff add %i4, -1, %g1
4001d3f8: 80 a0 40 02 cmp %g1, %g2
4001d3fc: 12 80 00 08 bne 4001d41c <rtems_rfs_block_map_shrink+0x2d0><== NEVER TAKEN
4001d400: 90 10 20 00 clr %o0
4001d404: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4001d408: c4 06 60 14 ld [ %i1 + 0x14 ], %g2
4001d40c: 80 a0 80 01 cmp %g2, %g1
4001d410: 38 80 00 0e bgu,a 4001d448 <rtems_rfs_block_map_shrink+0x2fc><== ALWAYS TAKEN
4001d414: f8 26 60 10 st %i4, [ %i1 + 0x10 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
return 0;
4001d418: 90 10 20 00 clr %o0
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
}
4001d41c: 81 c7 e0 08 ret
4001d420: 91 e8 00 08 restore %g0, %o0, %o0
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
4001d424: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001d428: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001d42c: 40 00 1f 54 call 4002517c <printf> <== NOT EXECUTED
4001d430: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 40037ec0 <CSWTCH.2+0xd0> <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
4001d434: 10 bf ff 4f b 4001d170 <rtems_rfs_block_map_shrink+0x24> <== NOT EXECUTED
4001d438: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
}
if (map->size.count == 0)
{
map->last_map_block = 0;
map->last_data_block = 0;
4001d43c: c0 26 60 20 clr [ %i1 + 0x20 ]
4001d440: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
4001d444: f8 26 60 10 st %i4, [ %i1 + 0x10 ]
4001d448: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
4001d44c: 80 a0 60 00 cmp %g1, 0
4001d450: 02 bf ff f2 be 4001d418 <rtems_rfs_block_map_shrink+0x2cc><== ALWAYS TAKEN
4001d454: c0 26 60 18 clr [ %i1 + 0x18 ]
4001d458: b8 07 3f ff add %i4, -1, %i4 <== NOT EXECUTED
return 0;
4001d45c: 90 10 20 00 clr %o0 <== NOT EXECUTED
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
4001d460: f8 26 60 10 st %i4, [ %i1 + 0x10 ] <== NOT EXECUTED
return 0;
}
4001d464: 81 c7 e0 08 ret <== NOT EXECUTED
4001d468: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
400236b8 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
400236b8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
400236bc: 90 10 20 00 clr %o0
400236c0: 7f ff c6 79 call 400150a4 <rtems_rfs_trace>
400236c4: 92 10 20 40 mov 0x40, %o1
400236c8: 80 8a 20 ff btst 0xff, %o0
400236cc: 02 80 00 0b be 400236f8 <rtems_rfs_buffer_bdbuf_release+0x40><== ALWAYS TAKEN
400236d0: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
400236d4: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED
400236d8: 12 80 00 18 bne 40023738 <rtems_rfs_buffer_bdbuf_release+0x80><== NOT EXECUTED
400236dc: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED
400236e0: 17 10 00 e3 sethi %hi(0x40038c00), %o3 <== NOT EXECUTED
400236e4: 96 12 e2 50 or %o3, 0x250, %o3 ! 40038e50 <CSWTCH.2+0x1060><== NOT EXECUTED
400236e8: 11 10 00 e5 sethi %hi(0x40039400), %o0 <== NOT EXECUTED
400236ec: 40 00 06 a4 call 4002517c <printf> <== NOT EXECUTED
400236f0: 90 12 21 30 or %o0, 0x130, %o0 ! 40039530 <rtems_rfs_rtems_file_handlers+0x3c><== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
400236f4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
400236f8: 02 80 00 09 be 4002371c <rtems_rfs_buffer_bdbuf_release+0x64>
400236fc: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release_modified (buffer);
40023700: 7f ff d0 29 call 400177a4 <rtems_bdbuf_release_modified>
40023704: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
40023708: 80 a0 00 08 cmp %g0, %o0
4002370c: b0 60 20 00 subx %g0, 0, %i0
#endif
rc = EIO;
}
return rc;
}
40023710: b0 0e 20 05 and %i0, 5, %i0
40023714: 81 c7 e0 08 ret
40023718: 81 e8 00 00 restore
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
else
sc = rtems_bdbuf_release (buffer);
4002371c: 7f ff cf ea call 400176c4 <rtems_bdbuf_release>
40023720: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
40023724: 80 a0 00 08 cmp %g0, %o0
40023728: b0 60 20 00 subx %g0, 0, %i0
#endif
rc = EIO;
}
return rc;
}
4002372c: b0 0e 20 05 and %i0, 5, %i0
40023730: 81 c7 e0 08 ret
40023734: 81 e8 00 00 restore
{
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
40023738: 17 10 00 e5 sethi %hi(0x40039400), %o3 <== NOT EXECUTED
4002373c: 10 bf ff eb b 400236e8 <rtems_rfs_buffer_bdbuf_release+0x30><== NOT EXECUTED
40023740: 96 12 e1 20 or %o3, 0x120, %o3 ! 40039520 <rtems_rfs_rtems_file_handlers+0x2c><== NOT EXECUTED
40023744: 40 02 39 e8 call 400b1ee4 <__end+0x66194> <== NOT EXECUTED
40023748: 40 02 39 54 call 400b1c98 <__end+0x65f48> <== NOT EXECUTED
4002374c: 40 02 39 48 call 400b1c6c <__end+0x65f1c> <== NOT EXECUTED
40023750: 40 02 39 3c call 400b1c40 <__end+0x65ef0> <== NOT EXECUTED
40023754: 40 02 39 30 call 400b1c14 <__end+0x65ec4> <== NOT EXECUTED
40023758: 40 02 39 28 call 400b1bf8 <__end+0x65ea8> <== NOT EXECUTED
4002375c: 40 02 39 1c call 400b1bcc <__end+0x65e7c> <== NOT EXECUTED
40023760: 40 02 39 10 call 400b1ba0 <__end+0x65e50> <== NOT EXECUTED
40023764: 40 02 39 04 call 400b1b74 <__end+0x65e24> <== NOT EXECUTED
40023768: 40 02 38 fc call 400b1b58 <__end+0x65e08> <== NOT EXECUTED
4002376c: 40 02 38 f0 call 400b1b2c <__end+0x65ddc> <== NOT EXECUTED
40023770: 40 02 38 e4 call 400b1b00 <__end+0x65db0> <== NOT EXECUTED
40023774: 40 02 38 d8 call 400b1ad4 <__end+0x65d84> <== NOT EXECUTED
4001def0 <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
4001def0: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001def4: 90 10 20 00 clr %o0
4001def8: 92 10 20 10 mov 0x10, %o1
4001defc: 7f ff dc 6a call 400150a4 <rtems_rfs_trace>
4001df00: ba 10 00 18 mov %i0, %i5
4001df04: 80 8a 20 ff btst 0xff, %o0
4001df08: 12 80 00 15 bne 4001df5c <rtems_rfs_buffer_close+0x6c> <== NEVER TAKEN
4001df0c: 11 10 00 e0 sethi %hi(0x40038000), %o0
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
4001df10: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4001df14: 90 10 00 1d mov %i5, %o0
4001df18: 7f ff ff ad call 4001ddcc <rtems_rfs_buffer_setblksize>
4001df1c: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001df20: b0 92 20 00 orcc %o0, 0, %i0
4001df24: 04 80 00 07 ble 4001df40 <rtems_rfs_buffer_close+0x50> <== ALWAYS TAKEN
4001df28: 90 10 20 00 clr %o0
4001df2c: 7f ff dc 5e call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001df30: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
4001df34: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001df38: 12 80 00 1f bne 4001dfb4 <rtems_rfs_buffer_close+0xc4> <== NOT EXECUTED
4001df3c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
rc, strerror (rc));
if (close (fs->device) < 0)
4001df40: 7f ff ac 58 call 400090a0 <close>
4001df44: d0 07 60 0c ld [ %i5 + 0xc ], %o0
4001df48: 80 a2 20 00 cmp %o0, 0
4001df4c: 06 80 00 08 bl 4001df6c <rtems_rfs_buffer_close+0x7c> <== NEVER TAKEN
4001df50: 01 00 00 00 nop
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
rc, strerror (rc));
}
return rc;
}
4001df54: 81 c7 e0 08 ret
4001df58: 81 e8 00 00 restore
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-close: closing\n");
4001df5c: 40 00 1d 20 call 400253dc <puts> <== NOT EXECUTED
4001df60: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
4001df64: 10 bf ff ec b 4001df14 <rtems_rfs_buffer_close+0x24> <== NOT EXECUTED
4001df68: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
rc, strerror (rc));
if (close (fs->device) < 0)
{
rc = errno;
4001df6c: 40 00 16 f3 call 40023b38 <__errno> <== NOT EXECUTED
4001df70: 01 00 00 00 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001df74: 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;
4001df78: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
4001df7c: 7f ff dc 4a call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001df80: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001df84: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001df88: 02 80 00 09 be 4001dfac <rtems_rfs_buffer_close+0xbc> <== NOT EXECUTED
4001df8c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
4001df90: 40 00 20 c5 call 400262a4 <strerror> <== NOT EXECUTED
4001df94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001df98: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001df9c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001dfa0: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001dfa4: 40 00 1c 76 call 4002517c <printf> <== NOT EXECUTED
4001dfa8: 90 12 20 00 mov %o0, %o0 ! 40038400 <CSWTCH.2+0x610> <== NOT EXECUTED
rc, strerror (rc));
}
return rc;
}
4001dfac: 81 c7 e0 08 ret <== NOT EXECUTED
4001dfb0: 81 e8 00 00 restore <== NOT EXECUTED
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
4001dfb4: 40 00 20 bc call 400262a4 <strerror> <== NOT EXECUTED
4001dfb8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001dfbc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001dfc0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001dfc4: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001dfc8: 40 00 1c 6d call 4002517c <printf> <== NOT EXECUTED
4001dfcc: 90 12 23 c0 or %o0, 0x3c0, %o0 ! 400383c0 <CSWTCH.2+0x5d0><== NOT EXECUTED
rc, strerror (rc));
if (close (fs->device) < 0)
4001dfd0: 7f ff ac 34 call 400090a0 <close> <== NOT EXECUTED
4001dfd4: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
4001dfd8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001dfdc: 16 bf ff f4 bge 4001dfac <rtems_rfs_buffer_close+0xbc> <== NOT EXECUTED
4001dfe0: 01 00 00 00 nop <== NOT EXECUTED
4001dfe4: 30 bf ff e2 b,a 4001df6c <rtems_rfs_buffer_close+0x7c> <== NOT EXECUTED
4001d638 <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
4001d638: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
4001d63c: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001d640: 80 a0 60 00 cmp %g1, 0
4001d644: 02 80 00 13 be 4001d690 <rtems_rfs_buffer_handle_release+0x58>
4001d648: b8 10 20 00 clr %i4
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
4001d64c: 90 10 20 00 clr %o0
4001d650: 7f ff de 95 call 400150a4 <rtems_rfs_trace>
4001d654: 92 10 22 00 mov 0x200, %o1
4001d658: 80 8a 20 ff btst 0xff, %o0
4001d65c: 32 80 00 0f bne,a 4001d698 <rtems_rfs_buffer_handle_release+0x60><== NEVER TAKEN
4001d660: c2 0e 40 00 ldub [ %i1 ], %g1 <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
if (rtems_rfs_buffer_refs (handle) > 0)
4001d664: d0 06 60 08 ld [ %i1 + 8 ], %o0
4001d668: fa 02 20 30 ld [ %o0 + 0x30 ], %i5
4001d66c: 80 a7 60 00 cmp %i5, 0
4001d670: 04 80 00 05 ble 4001d684 <rtems_rfs_buffer_handle_release+0x4c><== NEVER TAKEN
4001d674: 01 00 00 00 nop
rtems_rfs_buffer_refs_down (handle);
4001d678: ba 07 7f ff add %i5, -1, %i5
4001d67c: fa 22 20 30 st %i5, [ %o0 + 0x30 ]
if (rtems_rfs_buffer_refs (handle) == 0)
4001d680: 80 a7 60 00 cmp %i5, 0
4001d684: 02 80 00 15 be 4001d6d8 <rtems_rfs_buffer_handle_release+0xa0>
4001d688: b8 10 20 00 clr %i4
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
}
}
}
handle->buffer = NULL;
4001d68c: c0 26 60 08 clr [ %i1 + 8 ]
}
return rc;
}
4001d690: 81 c7 e0 08 ret
4001d694: 91 e8 00 1c restore %g0, %i4, %o0
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
4001d698: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001d69c: 12 80 00 28 bne 4001d73c <rtems_rfs_buffer_handle_release+0x104><== NOT EXECUTED
4001d6a0: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
4001d6a4: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
4001d6a8: 15 10 00 e3 sethi %hi(0x40038c00), %o2 <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
4001d6ac: 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",
4001d6b0: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
4001d6b4: 12 80 00 28 bne 4001d754 <rtems_rfs_buffer_handle_release+0x11c><== NOT EXECUTED
4001d6b8: 94 12 a2 50 or %o2, 0x250, %o2 <== NOT EXECUTED
4001d6bc: 19 10 00 df sethi %hi(0x40037c00), %o4 <== NOT EXECUTED
4001d6c0: 98 13 23 90 or %o4, 0x390, %o4 ! 40037f90 <CSWTCH.2+0x1a0><== NOT EXECUTED
4001d6c4: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001d6c8: 40 00 1e ad call 4002517c <printf> <== NOT EXECUTED
4001d6cc: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 40037fa0 <CSWTCH.2+0x1b0><== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
if (rtems_rfs_buffer_refs (handle) > 0)
4001d6d0: 10 bf ff e6 b 4001d668 <rtems_rfs_buffer_handle_release+0x30><== NOT EXECUTED
4001d6d4: d0 06 60 08 ld [ %i1 + 8 ], %o0 <== NOT EXECUTED
4001d6d8: 7f ff f3 61 call 4001a45c <_Chain_Extract>
4001d6dc: 01 00 00 00 nop
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
4001d6e0: c4 06 20 50 ld [ %i0 + 0x50 ], %g2
if (rtems_rfs_fs_no_local_cache (fs))
4001d6e4: c2 06 00 00 ld [ %i0 ], %g1
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
4001d6e8: 84 00 bf ff add %g2, -1, %g2
if (rtems_rfs_fs_no_local_cache (fs))
4001d6ec: 80 88 60 02 btst 2, %g1
4001d6f0: 12 80 00 1c bne 4001d760 <rtems_rfs_buffer_handle_release+0x128>
4001d6f4: c4 26 20 50 st %g2, [ %i0 + 0x50 ]
* head.
*
* This code stops a large series of transactions causing all the
* buffers in the cache being held in queues of this file system.
*/
if ((fs->release_count +
4001d6f8: c6 06 20 70 ld [ %i0 + 0x70 ], %g3
4001d6fc: c4 06 20 60 ld [ %i0 + 0x60 ], %g2
4001d700: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
4001d704: 84 00 c0 02 add %g3, %g2, %g2
4001d708: 80 a0 80 01 cmp %g2, %g1
4001d70c: 1a 80 00 21 bcc 4001d790 <rtems_rfs_buffer_handle_release+0x158>
4001d710: b8 10 00 1d mov %i5, %i4
}
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
}
if (rtems_rfs_buffer_dirty (handle))
4001d714: c2 0e 40 00 ldub [ %i1 ], %g1
4001d718: 80 a0 60 00 cmp %g1, 0
4001d71c: 02 80 00 17 be 4001d778 <rtems_rfs_buffer_handle_release+0x140>
4001d720: 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 );
4001d724: 7f ff c4 c2 call 4000ea2c <_Chain_Append>
4001d728: 90 06 20 64 add %i0, 0x64, %o0
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
4001d72c: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
4001d730: 82 00 60 01 inc %g1
4001d734: 10 bf ff d6 b 4001d68c <rtems_rfs_buffer_handle_release+0x54>
4001d738: c2 26 20 70 st %g1, [ %i0 + 0x70 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
4001d73c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
4001d740: 15 10 00 df sethi %hi(0x40037c00), %o2 <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
4001d744: 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",
4001d748: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
4001d74c: 02 bf ff dc be 4001d6bc <rtems_rfs_buffer_handle_release+0x84><== NOT EXECUTED
4001d750: 94 12 a3 88 or %o2, 0x388, %o2 <== NOT EXECUTED
4001d754: 19 10 00 e3 sethi %hi(0x40038c00), %o4 <== NOT EXECUTED
4001d758: 10 bf ff db b 4001d6c4 <rtems_rfs_buffer_handle_release+0x8c><== NOT EXECUTED
4001d75c: 98 13 22 50 or %o4, 0x250, %o4 ! 40038e50 <CSWTCH.2+0x1060><== NOT EXECUTED
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
4001d760: d0 06 60 08 ld [ %i1 + 8 ], %o0
rc = rtems_rfs_buffer_io_release (handle->buffer,
4001d764: d2 0e 40 00 ldub [ %i1 ], %o1
4001d768: 40 00 17 d4 call 400236b8 <rtems_rfs_buffer_bdbuf_release>
4001d76c: c0 22 20 34 clr [ %o0 + 0x34 ]
4001d770: 10 bf ff c7 b 4001d68c <rtems_rfs_buffer_handle_release+0x54>
4001d774: b8 10 00 08 mov %o0, %i4
4001d778: 7f ff c4 ad call 4000ea2c <_Chain_Append>
4001d77c: 90 06 20 54 add %i0, 0x54, %o0
fs->release_modified_count++;
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
4001d780: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
4001d784: 82 00 60 01 inc %g1
4001d788: 10 bf ff c1 b 4001d68c <rtems_rfs_buffer_handle_release+0x54>
4001d78c: c2 26 20 60 st %g1, [ %i0 + 0x60 ]
fs->release_modified_count) >= fs->max_held_buffers)
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
4001d790: 90 10 20 00 clr %o0
4001d794: 7f ff de 44 call 400150a4 <rtems_rfs_trace>
4001d798: 92 10 22 00 mov 0x200, %o1
4001d79c: 80 8a 20 ff btst 0xff, %o0
4001d7a0: 32 80 00 19 bne,a 4001d804 <rtems_rfs_buffer_handle_release+0x1cc><== NEVER TAKEN
4001d7a4: d2 06 20 70 ld [ %i0 + 0x70 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: buffer-release: local cache overflow:"
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
4001d7a8: c4 06 20 60 ld [ %i0 + 0x60 ], %g2
4001d7ac: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
4001d7b0: 80 a0 80 01 cmp %g2, %g1
4001d7b4: 08 80 00 0d bleu 4001d7e8 <rtems_rfs_buffer_handle_release+0x1b0>
4001d7b8: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4001d7bc: 7f ff c4 a7 call 4000ea58 <_Chain_Get>
4001d7c0: 90 06 20 54 add %i0, 0x54, %o0
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
4001d7c4: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
modified = false;
4001d7c8: 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--;
4001d7cc: 82 00 7f ff add %g1, -1, %g1
4001d7d0: c2 26 20 60 st %g1, [ %i0 + 0x60 ]
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
modified = true;
}
buffer->user = (void*) 0;
4001d7d4: c0 22 20 34 clr [ %o0 + 0x34 ]
rc = rtems_rfs_buffer_io_release (buffer, modified);
4001d7d8: 40 00 17 b8 call 400236b8 <rtems_rfs_buffer_bdbuf_release>
4001d7dc: 92 0a 60 01 and %o1, 1, %o1
4001d7e0: 10 bf ff cd b 4001d714 <rtems_rfs_buffer_handle_release+0xdc>
4001d7e4: b8 10 00 08 mov %o0, %i4
4001d7e8: 7f ff c4 9c call 4000ea58 <_Chain_Get>
4001d7ec: 90 06 20 64 add %i0, 0x64, %o0
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
4001d7f0: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
modified = true;
4001d7f4: 92 10 20 01 mov 1, %o1
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
4001d7f8: 82 00 7f ff add %g1, -1, %g1
4001d7fc: 10 bf ff f6 b 4001d7d4 <rtems_rfs_buffer_handle_release+0x19c>
4001d800: c2 26 20 70 st %g1, [ %i0 + 0x70 ]
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: local cache overflow:"
4001d804: c2 06 20 60 ld [ %i0 + 0x60 ], %g1 <== NOT EXECUTED
4001d808: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001d80c: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED
4001d810: 40 00 1e 5b call 4002517c <printf> <== NOT EXECUTED
4001d814: 90 12 23 d8 or %o0, 0x3d8, %o0 <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
4001d818: 10 bf ff e5 b 4001d7ac <rtems_rfs_buffer_handle_release+0x174><== NOT EXECUTED
4001d81c: c4 06 20 60 ld [ %i0 + 0x60 ], %g2 <== NOT EXECUTED
4001d820 <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)
{
4001d820: 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))
4001d824: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001d828: 80 a0 60 00 cmp %g1, 0
4001d82c: 02 80 00 17 be 4001d888 <rtems_rfs_buffer_handle_request+0x68>
4001d830: 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))
4001d834: 80 a6 a0 00 cmp %i2, 0
4001d838: 02 80 00 06 be 4001d850 <rtems_rfs_buffer_handle_request+0x30><== NEVER TAKEN
4001d83c: 90 10 20 00 clr %o0
4001d840: c2 06 60 04 ld [ %i1 + 4 ], %g1
4001d844: 80 a0 40 1a cmp %g1, %i2
4001d848: 02 80 00 40 be 4001d948 <rtems_rfs_buffer_handle_request+0x128>
4001d84c: 01 00 00 00 nop
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001d850: 7f ff de 15 call 400150a4 <rtems_rfs_trace>
4001d854: 92 10 21 00 mov 0x100, %o1 ! 100 <PROM_START+0x100>
4001d858: 80 8a 20 ff btst 0xff, %o0
4001d85c: 32 80 00 3d bne,a 4001d950 <rtems_rfs_buffer_handle_request+0x130><== NEVER TAKEN
4001d860: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
4001d864: 90 10 00 1d mov %i5, %o0
4001d868: 7f ff ff 74 call 4001d638 <rtems_rfs_buffer_handle_release>
4001d86c: 92 10 00 19 mov %i1, %o1
if (rc > 0)
4001d870: b0 92 20 00 orcc %o0, 0, %i0
4001d874: 24 80 00 04 ble,a 4001d884 <rtems_rfs_buffer_handle_request+0x64><== ALWAYS TAKEN
4001d878: c0 2e 40 00 clrb [ %i1 ]
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
}
4001d87c: 81 c7 e0 08 ret <== NOT EXECUTED
4001d880: 81 e8 00 00 restore <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (fs, handle);
if (rc > 0)
return rc;
handle->dirty = false;
handle->bnum = 0;
4001d884: c0 26 60 04 clr [ %i1 + 4 ]
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001d888: 90 10 20 00 clr %o0
4001d88c: 7f ff de 06 call 400150a4 <rtems_rfs_trace>
4001d890: 92 10 21 00 mov 0x100, %o1
4001d894: 80 8a 20 ff btst 0xff, %o0
4001d898: 32 80 00 5b bne,a 4001da04 <rtems_rfs_buffer_handle_request+0x1e4><== NEVER TAKEN
4001d89c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
* currently attached to a handle. If it is share the access. A buffer could
* be shared where different parts of the block have separate functions. An
* example is an inode block and the file system needs to handle 2 inodes in
* the same block at the same time.
*/
if (fs->buffers_count)
4001d8a0: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
4001d8a4: 80 a0 60 00 cmp %g1, 0
4001d8a8: 12 80 00 44 bne 4001d9b8 <rtems_rfs_buffer_handle_request+0x198>
4001d8ac: 90 07 60 44 add %i5, 0x44, %o0
4001d8b0: c2 06 60 08 ld [ %i1 + 8 ], %g1
/*
* If the buffer has not been found check the local cache of released
* buffers. There are release and released modified lists to preserve the
* state.
*/
if (!rtems_rfs_fs_no_local_cache (fs) &&
4001d8b4: c4 07 40 00 ld [ %i5 ], %g2
4001d8b8: 80 88 a0 02 btst 2, %g2
4001d8bc: 02 80 00 2a be 4001d964 <rtems_rfs_buffer_handle_request+0x144>
4001d8c0: 80 a0 60 00 cmp %g1, 0
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
4001d8c4: 02 80 00 65 be 4001da58 <rtems_rfs_buffer_handle_request+0x238><== ALWAYS TAKEN
4001d8c8: 90 10 00 1d mov %i5, %o0
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
4001d8cc: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4001d8d0: 92 10 00 01 mov %g1, %o1
4001d8d4: 84 00 a0 01 inc %g2
4001d8d8: 90 07 60 44 add %i5, 0x44, %o0
4001d8dc: 7f ff c4 54 call 4000ea2c <_Chain_Append>
4001d8e0: c4 20 60 30 st %g2, [ %g1 + 0x30 ]
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
4001d8e4: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
handle->buffer->user = (void*) ((intptr_t) block);
4001d8e8: c2 06 60 08 ld [ %i1 + 8 ], %g1
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
4001d8ec: 84 00 a0 01 inc %g2
4001d8f0: c4 27 60 50 st %g2, [ %i5 + 0x50 ]
handle->buffer->user = (void*) ((intptr_t) block);
4001d8f4: f4 20 60 34 st %i2, [ %g1 + 0x34 ]
handle->bnum = block;
4001d8f8: f4 26 60 04 st %i2, [ %i1 + 4 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001d8fc: 90 10 20 00 clr %o0
4001d900: 7f ff dd e9 call 400150a4 <rtems_rfs_trace>
4001d904: 92 10 21 00 mov 0x100, %o1
4001d908: 80 8a 20 ff btst 0xff, %o0
4001d90c: 02 80 00 0f be 4001d948 <rtems_rfs_buffer_handle_request+0x128><== ALWAYS TAKEN
4001d910: 80 a6 e0 00 cmp %i3, 0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001d914: 02 80 00 41 be 4001da18 <rtems_rfs_buffer_handle_request+0x1f8><== NOT EXECUTED
4001d918: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
4001d91c: b0 10 20 00 clr %i0 <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001d920: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
4001d924: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED
4001d928: 15 10 00 dd sethi %hi(0x40037400), %o2 <== NOT EXECUTED
4001d92c: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001d930: 94 12 a0 d0 or %o2, 0xd0, %o2 <== NOT EXECUTED
4001d934: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001d938: 40 00 1e 11 call 4002517c <printf> <== NOT EXECUTED
4001d93c: 90 12 20 e8 or %o0, 0xe8, %o0 <== NOT EXECUTED
4001d940: 81 c7 e0 08 ret <== NOT EXECUTED
4001d944: 81 e8 00 00 restore <== NOT EXECUTED
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
return 0;
4001d948: 81 c7 e0 08 ret
4001d94c: 91 e8 20 00 restore %g0, 0, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
4001d950: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001d954: 40 00 1e 0a call 4002517c <printf> <== NOT EXECUTED
4001d958: 90 12 20 18 or %o0, 0x18, %o0 ! 40038018 <CSWTCH.2+0x228> <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
4001d95c: 10 bf ff c3 b 4001d868 <rtems_rfs_buffer_handle_request+0x48><== NOT EXECUTED
4001d960: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/*
* If the buffer has not been found check the local cache of released
* buffers. There are release and released modified lists to preserve the
* state.
*/
if (!rtems_rfs_fs_no_local_cache (fs) &&
4001d964: 32 bf ff db bne,a 4001d8d0 <rtems_rfs_buffer_handle_request+0xb0>
4001d968: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
4001d96c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4001d970: 80 a0 60 00 cmp %g1, 0
4001d974: 12 80 00 5a bne 4001dadc <rtems_rfs_buffer_handle_request+0x2bc>
4001d978: 90 07 60 54 add %i5, 0x54, %o0
handle->buffer = rtems_rfs_scan_chain (&fs->release,
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
4001d97c: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4001d980: 80 a0 60 00 cmp %g1, 0
4001d984: 02 80 00 35 be 4001da58 <rtems_rfs_buffer_handle_request+0x238>
4001d988: 90 10 00 1d mov %i5, %o0
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
4001d98c: 90 07 60 64 add %i5, 0x64, %o0
4001d990: 92 07 60 70 add %i5, 0x70, %o1
4001d994: 7f ff fe e1 call 4001d518 <rtems_rfs_scan_chain>
4001d998: 94 10 00 1a mov %i2, %o2
4001d99c: d0 26 60 08 st %o0, [ %i1 + 8 ]
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
4001d9a0: 80 a2 20 00 cmp %o0, 0
4001d9a4: 02 80 00 2c be 4001da54 <rtems_rfs_buffer_handle_request+0x234>
4001d9a8: 82 10 00 08 mov %o0, %g1
rtems_rfs_buffer_mark_dirty (handle);
4001d9ac: 84 10 20 01 mov 1, %g2
4001d9b0: 10 bf ff c7 b 4001d8cc <rtems_rfs_buffer_handle_request+0xac>
4001d9b4: c4 2e 40 00 stb %g2, [ %i1 ]
if (fs->buffers_count)
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
4001d9b8: 92 07 60 50 add %i5, 0x50, %o1
4001d9bc: 7f ff fe d7 call 4001d518 <rtems_rfs_scan_chain>
4001d9c0: 94 10 00 1a mov %i2, %o2
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
4001d9c4: 80 a2 20 00 cmp %o0, 0
4001d9c8: 02 80 00 1f be 4001da44 <rtems_rfs_buffer_handle_request+0x224>
4001d9cc: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001d9d0: 90 10 20 00 clr %o0
4001d9d4: 7f ff dd b4 call 400150a4 <rtems_rfs_trace>
4001d9d8: 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) &&
4001d9dc: 80 8a 20 ff btst 0xff, %o0
4001d9e0: 02 bf ff b5 be 4001d8b4 <rtems_rfs_buffer_handle_request+0x94><== ALWAYS TAKEN
4001d9e4: c2 06 60 08 ld [ %i1 + 8 ], %g1
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
4001d9e8: d2 00 60 30 ld [ %g1 + 0x30 ], %o1 <== NOT EXECUTED
4001d9ec: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001d9f0: 92 02 60 01 inc %o1 <== NOT EXECUTED
4001d9f4: 40 00 1d e2 call 4002517c <printf> <== NOT EXECUTED
4001d9f8: 90 12 20 78 or %o0, 0x78, %o0 <== NOT EXECUTED
4001d9fc: 10 bf ff ae b 4001d8b4 <rtems_rfs_buffer_handle_request+0x94><== NOT EXECUTED
4001da00: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
4001da04: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001da08: 40 00 1d dd call 4002517c <printf> <== NOT EXECUTED
4001da0c: 90 12 20 50 or %o0, 0x50, %o0 ! 40038050 <CSWTCH.2+0x260> <== 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)
4001da10: 10 bf ff a5 b 4001d8a4 <rtems_rfs_buffer_handle_request+0x84><== NOT EXECUTED
4001da14: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
4001da18: b0 10 20 00 clr %i0 <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001da1c: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
4001da20: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED
4001da24: 15 10 00 e0 sethi %hi(0x40038000), %o2 <== NOT EXECUTED
4001da28: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001da2c: 94 12 a0 10 or %o2, 0x10, %o2 <== NOT EXECUTED
4001da30: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001da34: 40 00 1d d2 call 4002517c <printf> <== NOT EXECUTED
4001da38: 90 12 20 e8 or %o0, 0xe8, %o0 <== NOT EXECUTED
4001da3c: 81 c7 e0 08 ret <== NOT EXECUTED
4001da40: 81 e8 00 00 restore <== NOT EXECUTED
/*
* If the buffer has not been found check the local cache of released
* buffers. There are release and released modified lists to preserve the
* state.
*/
if (!rtems_rfs_fs_no_local_cache (fs) &&
4001da44: c2 07 40 00 ld [ %i5 ], %g1
4001da48: 80 88 60 02 btst 2, %g1
4001da4c: 22 bf ff c9 be,a 4001d970 <rtems_rfs_buffer_handle_request+0x150>
4001da50: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
4001da54: 90 10 00 1d mov %i5, %o0
4001da58: 92 10 00 1a mov %i2, %o1
4001da5c: 94 10 00 1b mov %i3, %o2
4001da60: 40 00 17 02 call 40023668 <rtems_rfs_buffer_bdbuf_request>
4001da64: 96 06 60 08 add %i1, 8, %o3
if (rc > 0)
4001da68: b0 92 20 00 orcc %o0, 0, %i0
4001da6c: 04 80 00 16 ble 4001dac4 <rtems_rfs_buffer_handle_request+0x2a4><== ALWAYS TAKEN
4001da70: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
4001da74: 7f ff dd 8c call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001da78: 92 10 21 00 mov 0x100, %o1 <== NOT EXECUTED
4001da7c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001da80: 02 bf ff 7f be 4001d87c <rtems_rfs_buffer_handle_request+0x5c><== NOT EXECUTED
4001da84: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
4001da88: 02 80 00 13 be 4001dad4 <rtems_rfs_buffer_handle_request+0x2b4><== NOT EXECUTED
4001da8c: 3b 10 00 e0 sethi %hi(0x40038000), %i5 <== NOT EXECUTED
4001da90: 3b 10 00 dd sethi %hi(0x40037400), %i5 <== NOT EXECUTED
4001da94: ba 17 60 d0 or %i5, 0xd0, %i5 ! 400374d0 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001da98: 40 00 22 03 call 400262a4 <strerror> <== NOT EXECUTED
4001da9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001daa0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001daa4: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001daa8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001daac: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001dab0: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4001dab4: 40 00 1d b2 call 4002517c <printf> <== NOT EXECUTED
4001dab8: 90 12 20 b0 or %o0, 0xb0, %o0 <== NOT EXECUTED
4001dabc: 81 c7 e0 08 ret <== NOT EXECUTED
4001dac0: 81 e8 00 00 restore <== NOT EXECUTED
block, read ? "read" : "get", rc, strerror (rc));
return rc;
}
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
4001dac4: c2 06 60 08 ld [ %i1 + 8 ], %g1
4001dac8: c0 20 60 04 clr [ %g1 + 4 ]
4001dacc: 10 bf ff 80 b 4001d8cc <rtems_rfs_buffer_handle_request+0xac>
4001dad0: c0 20 40 00 clr [ %g1 ]
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
4001dad4: 10 bf ff f1 b 4001da98 <rtems_rfs_buffer_handle_request+0x278><== NOT EXECUTED
4001dad8: ba 17 60 10 or %i5, 0x10, %i5 <== NOT EXECUTED
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
handle->buffer = rtems_rfs_scan_chain (&fs->release,
4001dadc: 92 07 60 60 add %i5, 0x60, %o1
4001dae0: 7f ff fe 8e call 4001d518 <rtems_rfs_scan_chain>
4001dae4: 94 10 00 1a mov %i2, %o2
4001dae8: d0 26 60 08 st %o0, [ %i1 + 8 ]
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
4001daec: 80 a2 20 00 cmp %o0, 0
4001daf0: 12 bf ff 77 bne 4001d8cc <rtems_rfs_buffer_handle_request+0xac>
4001daf4: 82 10 00 08 mov %o0, %g1
4001daf8: 10 bf ff a2 b 4001d980 <rtems_rfs_buffer_handle_request+0x160>
4001dafc: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
4001db00 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
4001db00: 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))
4001db04: 90 10 20 00 clr %o0
4001db08: 92 10 20 20 mov 0x20, %o1
4001db0c: 7f ff dd 66 call 400150a4 <rtems_rfs_trace>
4001db10: ba 10 00 18 mov %i0, %i5
4001db14: 80 8a 20 ff btst 0xff, %o0
4001db18: 12 80 00 1b bne 4001db84 <rtems_rfs_buffer_open+0x84> <== NEVER TAKEN
4001db1c: 92 10 00 18 mov %i0, %o1
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
fs->device = open (name, O_RDWR);
4001db20: 90 10 00 1d mov %i5, %o0
4001db24: 7f ff b1 46 call 4000a03c <open>
4001db28: 92 10 20 02 mov 2, %o1
if (fs->device < 0)
4001db2c: 80 a2 20 00 cmp %o0, 0
4001db30: 06 80 00 1e bl 4001dba8 <rtems_rfs_buffer_open+0xa8> <== NEVER TAKEN
4001db34: d0 26 60 0c st %o0, [ %i1 + 0xc ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
}
if (fstat (fs->device, &st) < 0)
4001db38: 7f ff ad a6 call 400091d0 <fstat>
4001db3c: 92 07 bf b8 add %fp, -72, %o1
4001db40: 80 a2 20 00 cmp %o0, 0
4001db44: 06 80 00 3b bl 4001dc30 <rtems_rfs_buffer_open+0x130> <== NEVER TAKEN
4001db48: c4 07 bf c4 ld [ %fp + -60 ], %g2
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
4001db4c: 03 00 00 3c sethi %hi(0xf000), %g1
4001db50: 84 08 80 01 and %g2, %g1, %g2
4001db54: 03 00 00 18 sethi %hi(0x6000), %g1
4001db58: 80 a0 80 01 cmp %g2, %g1
4001db5c: 22 80 00 1e be,a 4001dbd4 <rtems_rfs_buffer_open+0xd4> <== ALWAYS TAKEN
4001db60: d0 06 60 0c ld [ %i1 + 0xc ], %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001db64: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001db68: 7f ff dd 4f call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001db6c: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001db70: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001db74: 32 80 00 29 bne,a 4001dc18 <rtems_rfs_buffer_open+0x118> <== NOT EXECUTED
4001db78: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
if (fs->device < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
4001db7c: 81 c7 e0 08 ret <== NOT EXECUTED
4001db80: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
int rv;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
4001db84: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001db88: 40 00 1d 7d call 4002517c <printf> <== NOT EXECUTED
4001db8c: 90 12 21 28 or %o0, 0x128, %o0 ! 40038128 <CSWTCH.2+0x338><== NOT EXECUTED
fs->device = open (name, O_RDWR);
4001db90: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001db94: 7f ff b1 2a call 4000a03c <open> <== NOT EXECUTED
4001db98: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
if (fs->device < 0)
4001db9c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001dba0: 16 bf ff e6 bge 4001db38 <rtems_rfs_buffer_open+0x38> <== NOT EXECUTED
4001dba4: d0 26 60 0c st %o0, [ %i1 + 0xc ] <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001dba8: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001dbac: 7f ff dd 3e call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001dbb0: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001dbb4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001dbb8: 02 bf ff f1 be 4001db7c <rtems_rfs_buffer_open+0x7c> <== NOT EXECUTED
4001dbbc: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
4001dbc0: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
if (fs->device < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot open file\n");
4001dbc4: 40 00 1e 06 call 400253dc <puts> <== NOT EXECUTED
4001dbc8: 90 12 21 50 or %o0, 0x150, %o0 <== NOT EXECUTED
4001dbcc: 81 c7 e0 08 ret <== NOT EXECUTED
4001dbd0: 81 e8 00 00 restore <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
4001dbd4: 94 06 60 10 add %i1, 0x10, %o2
4001dbd8: 13 10 01 10 sethi %hi(0x40044000), %o1
4001dbdc: 7f ff ad d3 call 40009328 <ioctl>
4001dbe0: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <flashdisk_data+0x9751>
/*
* 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)
4001dbe4: 80 a2 20 00 cmp %o0, 0
4001dbe8: 02 80 00 23 be 4001dc74 <rtems_rfs_buffer_open+0x174> <== ALWAYS TAKEN
4001dbec: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001dbf0: 7f ff dd 2d call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001dbf4: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001dbf8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001dbfc: 02 bf ff e0 be 4001db7c <rtems_rfs_buffer_open+0x7c> <== NOT EXECUTED
4001dc00: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
return ENXIO;
4001dc04: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED
*/
rv = rtems_disk_fd_get_disk_device (fs->device, &fs->disk);
if (rv != 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
4001dc08: 40 00 1d f5 call 400253dc <puts> <== NOT EXECUTED
4001dc0c: 90 12 21 e8 or %o0, 0x1e8, %o0 <== NOT EXECUTED
4001dc10: 81 c7 e0 08 ret <== NOT EXECUTED
4001dc14: 81 e8 00 00 restore <== NOT EXECUTED
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
4001dc18: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001dc1c: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001dc20: 40 00 1d 57 call 4002517c <printf> <== NOT EXECUTED
4001dc24: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 400381b0 <CSWTCH.2+0x3c0><== NOT EXECUTED
4001dc28: 81 c7 e0 08 ret <== NOT EXECUTED
4001dc2c: 81 e8 00 00 restore <== NOT EXECUTED
return ENXIO;
}
if (fstat (fs->device, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
4001dc30: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001dc34: 7f ff dd 1c call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001dc38: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
4001dc3c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001dc40: 02 bf ff cf be 4001db7c <rtems_rfs_buffer_open+0x7c> <== NOT EXECUTED
4001dc44: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
4001dc48: 40 00 17 bc call 40023b38 <__errno> <== NOT EXECUTED
4001dc4c: b0 10 20 06 mov 6, %i0 ! 6 <PROM_START+0x6> <== NOT EXECUTED
}
if (fstat (fs->device, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
4001dc50: 40 00 21 95 call 400262a4 <strerror> <== NOT EXECUTED
4001dc54: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
4001dc58: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001dc5c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001dc60: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001dc64: 40 00 1d 46 call 4002517c <printf> <== NOT EXECUTED
4001dc68: 90 12 21 80 or %o0, 0x180, %o0 ! 40038180 <CSWTCH.2+0x390><== NOT EXECUTED
4001dc6c: 81 c7 e0 08 ret <== NOT EXECUTED
4001dc70: 81 e8 00 00 restore <== NOT EXECUTED
#else
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4001dc74: 92 10 20 20 mov 0x20, %o1
4001dc78: 7f ff dd 0b call 400150a4 <rtems_rfs_trace>
4001dc7c: b0 10 20 00 clr %i0
4001dc80: 80 8a 20 ff btst 0xff, %o0
4001dc84: 32 80 00 04 bne,a 4001dc94 <rtems_rfs_buffer_open+0x194> <== NEVER TAKEN
4001dc88: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
4001dc8c: 81 c7 e0 08 ret
4001dc90: 81 e8 00 00 restore
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
4001dc94: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001dc98: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
4001dc9c: d4 00 60 20 ld [ %g1 + 0x20 ], %o2 <== NOT EXECUTED
4001dca0: 40 00 1d 37 call 4002517c <printf> <== NOT EXECUTED
4001dca4: 90 12 22 18 or %o0, 0x218, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
4001dca8: 81 c7 e0 08 ret <== NOT EXECUTED
4001dcac: 81 e8 00 00 restore <== NOT EXECUTED
4001ddcc <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
4001ddcc: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001ddd0: 90 10 20 00 clr %o0
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
4001ddd4: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001ddd8: 7f ff dc b3 call 400150a4 <rtems_rfs_trace>
4001dddc: 92 10 24 00 mov 0x400, %o1
4001dde0: 80 8a 20 ff btst 0xff, %o0
4001dde4: 12 80 00 21 bne 4001de68 <rtems_rfs_buffer_setblksize+0x9c><== NEVER TAKEN
4001dde8: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
rc = rtems_rfs_buffers_release (fs);
4001ddec: 7f ff ff d7 call 4001dd48 <rtems_rfs_buffers_release>
4001ddf0: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001ddf4: ba 92 20 00 orcc %o0, 0, %i5
4001ddf8: 04 80 00 07 ble 4001de14 <rtems_rfs_buffer_setblksize+0x48><== ALWAYS TAKEN
4001ddfc: 90 10 20 00 clr %o0
4001de00: 7f ff dc a9 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001de04: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
4001de08: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001de0c: 12 80 00 20 bne 4001de8c <rtems_rfs_buffer_setblksize+0xc0><== NOT EXECUTED
4001de10: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
4001de14: 7f ff ff a7 call 4001dcb0 <rtems_rfs_buffer_sync>
4001de18: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001de1c: ba 92 20 00 orcc %o0, 0, %i5
4001de20: 04 80 00 07 ble 4001de3c <rtems_rfs_buffer_setblksize+0x70><== ALWAYS TAKEN
4001de24: 90 10 20 00 clr %o0
4001de28: 7f ff dc 9f call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001de2c: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
4001de30: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001de34: 12 80 00 1e bne 4001deac <rtems_rfs_buffer_setblksize+0xe0><== NOT EXECUTED
4001de38: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
4001de3c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
4001de40: 13 20 01 10 sethi %hi(0x80044000), %o1
4001de44: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4001de48: 92 12 62 04 or %o1, 0x204, %o1
4001de4c: 9f c0 40 00 call %g1
4001de50: 94 07 a0 48 add %fp, 0x48, %o2
if (rc < 0)
4001de54: b0 92 20 00 orcc %o0, 0, %i0
4001de58: 06 80 00 08 bl 4001de78 <rtems_rfs_buffer_setblksize+0xac><== NEVER TAKEN
4001de5c: 01 00 00 00 nop
rc = errno;
#endif
return rc;
}
4001de60: 81 c7 e0 08 ret
4001de64: 81 e8 00 00 restore
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
4001de68: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001de6c: 40 00 1c c4 call 4002517c <printf> <== NOT EXECUTED
4001de70: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 400382e8 <CSWTCH.2+0x4f8><== NOT EXECUTED
4001de74: 30 bf ff de b,a 4001ddec <rtems_rfs_buffer_setblksize+0x20><== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
if (rc < 0)
rc = errno;
4001de78: 40 00 17 30 call 40023b38 <__errno> <== NOT EXECUTED
4001de7c: 01 00 00 00 nop <== NOT EXECUTED
4001de80: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
#endif
return rc;
}
4001de84: 81 c7 e0 08 ret <== NOT EXECUTED
4001de88: 81 e8 00 00 restore <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
rc = rtems_rfs_buffers_release (fs);
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
4001de8c: 40 00 21 06 call 400262a4 <strerror> <== NOT EXECUTED
4001de90: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001de94: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001de98: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001de9c: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001dea0: 40 00 1c b7 call 4002517c <printf> <== NOT EXECUTED
4001dea4: 90 12 23 18 or %o0, 0x318, %o0 ! 40038318 <CSWTCH.2+0x528><== NOT EXECUTED
4001dea8: 30 bf ff db b,a 4001de14 <rtems_rfs_buffer_setblksize+0x48><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
4001deac: 40 00 20 fe call 400262a4 <strerror> <== NOT EXECUTED
4001deb0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001deb4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001deb8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001debc: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001dec0: 40 00 1c af call 4002517c <printf> <== NOT EXECUTED
4001dec4: 90 12 23 58 or %o0, 0x358, %o0 ! 40038358 <CSWTCH.2+0x568><== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
4001dec8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
4001decc: 13 20 01 10 sethi %hi(0x80044000), %o1 <== NOT EXECUTED
4001ded0: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 <== NOT EXECUTED
4001ded4: 92 12 62 04 or %o1, 0x204, %o1 <== NOT EXECUTED
4001ded8: 9f c0 40 00 call %g1 <== NOT EXECUTED
4001dedc: 94 07 a0 48 add %fp, 0x48, %o2 <== NOT EXECUTED
if (rc < 0)
4001dee0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001dee4: 16 bf ff e8 bge 4001de84 <rtems_rfs_buffer_setblksize+0xb8><== NOT EXECUTED
4001dee8: 01 00 00 00 nop <== NOT EXECUTED
4001deec: 30 bf ff e3 b,a 4001de78 <rtems_rfs_buffer_setblksize+0xac><== NOT EXECUTED
4001dcb0 <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
4001dcb0: 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))
4001dcb4: 90 10 20 00 clr %o0
4001dcb8: 92 10 20 20 mov 0x20, %o1
4001dcbc: 7f ff dc fa call 400150a4 <rtems_rfs_trace>
4001dcc0: ba 10 00 18 mov %i0, %i5
4001dcc4: 80 8a 20 ff btst 0xff, %o0
4001dcc8: 12 80 00 1c bne 4001dd38 <rtems_rfs_buffer_sync+0x88> <== NEVER TAKEN
4001dccc: 11 10 00 e0 sethi %hi(0x40038000), %o0
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
4001dcd0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
4001dcd4: 7f ff e7 26 call 4001796c <rtems_bdbuf_syncdev>
4001dcd8: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
4001dcdc: b8 92 20 00 orcc %o0, 0, %i4
4001dce0: 12 80 00 06 bne 4001dcf8 <rtems_rfs_buffer_sync+0x48> <== NEVER TAKEN
4001dce4: 90 10 20 00 clr %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
4001dce8: 7f ff 9e 0c call 40005518 <rtems_disk_release>
4001dcec: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
4001dcf0: 81 c7 e0 08 ret
4001dcf4: 81 e8 00 00 restore
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
4001dcf8: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
4001dcfc: 7f ff dc ea call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001dd00: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001dd04: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001dd08: 02 bf ff f8 be 4001dce8 <rtems_rfs_buffer_sync+0x38> <== NOT EXECUTED
4001dd0c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
4001dd10: 7f ff eb 40 call 40018a10 <rtems_status_text> <== NOT EXECUTED
4001dd14: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001dd18: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001dd1c: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001dd20: 40 00 1d 17 call 4002517c <printf> <== NOT EXECUTED
4001dd24: 90 12 22 68 or %o0, 0x268, %o0 ! 40038268 <CSWTCH.2+0x478><== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
4001dd28: 7f ff 9d fc call 40005518 <rtems_disk_release> <== NOT EXECUTED
4001dd2c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
4001dd30: 81 c7 e0 08 ret <== NOT EXECUTED
4001dd34: 81 e8 00 00 restore <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: syncing\n");
4001dd38: 40 00 1d a9 call 400253dc <puts> <== NOT EXECUTED
4001dd3c: 90 12 22 48 or %o0, 0x248, %o0 <== NOT EXECUTED
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
4001dd40: 10 bf ff e5 b 4001dcd4 <rtems_rfs_buffer_sync+0x24> <== NOT EXECUTED
4001dd44: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
4001dd48 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
4001dd48: 9d e3 bf a0 save %sp, -96, %sp
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
4001dd4c: 90 10 20 00 clr %o0
4001dd50: 7f ff dc d5 call 400150a4 <rtems_rfs_trace>
4001dd54: 92 10 20 40 mov 0x40, %o1
4001dd58: 80 8a 20 ff btst 0xff, %o0
4001dd5c: 32 80 00 15 bne,a 4001ddb0 <rtems_rfs_buffers_release+0x68><== NEVER TAKEN
4001dd60: d2 06 20 50 ld [ %i0 + 0x50 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
4001dd64: 92 06 20 60 add %i0, 0x60, %o1
4001dd68: 94 10 20 00 clr %o2
4001dd6c: 7f ff fd c4 call 4001d47c <rtems_rfs_release_chain>
4001dd70: 90 06 20 54 add %i0, 0x54, %o0
4001dd74: 82 38 00 08 xnor %g0, %o0, %g1
4001dd78: 83 38 60 1f sra %g1, 0x1f, %g1
4001dd7c: ba 10 00 08 mov %o0, %i5
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
4001dd80: 92 06 20 70 add %i0, 0x70, %o1
4001dd84: ba 0f 40 01 and %i5, %g1, %i5
4001dd88: 90 06 20 64 add %i0, 0x64, %o0
4001dd8c: 7f ff fd bc call 4001d47c <rtems_rfs_release_chain>
4001dd90: 94 10 20 01 mov 1, %o2
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
4001dd94: 80 a7 60 00 cmp %i5, 0
4001dd98: 12 80 00 04 bne 4001dda8 <rtems_rfs_buffers_release+0x60> <== NEVER TAKEN
4001dd9c: 80 a2 20 00 cmp %o0, 0
4001dda0: 34 80 00 02 bg,a 4001dda8 <rtems_rfs_buffers_release+0x60><== NEVER TAKEN
4001dda4: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
rrc = rc;
return rrc;
}
4001dda8: 81 c7 e0 08 ret
4001ddac: 91 e8 00 1d restore %g0, %i5, %o0
{
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
4001ddb0: d4 06 20 60 ld [ %i0 + 0x60 ], %o2 <== NOT EXECUTED
4001ddb4: d6 06 20 70 ld [ %i0 + 0x70 ], %o3 <== NOT EXECUTED
4001ddb8: 11 10 00 e0 sethi %hi(0x40038000), %o0 <== NOT EXECUTED
4001ddbc: 40 00 1c f0 call 4002517c <printf> <== NOT EXECUTED
4001ddc0: 90 12 22 98 or %o0, 0x298, %o0 ! 40038298 <CSWTCH.2+0x4a8><== 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,
4001ddc4: 10 bf ff e9 b 4001dd68 <rtems_rfs_buffers_release+0x20> <== NOT EXECUTED
4001ddc8: 92 06 20 60 add %i0, 0x60, %o1 <== NOT EXECUTED
4001e524 <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)
{
4001e524: 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))
4001e528: 90 10 20 00 clr %o0
4001e52c: 7f ff da de call 400150a4 <rtems_rfs_trace>
4001e530: 13 08 00 00 sethi %hi(0x20000000), %o1
4001e534: 80 8a 20 ff btst 0xff, %o0
4001e538: 32 80 00 7c bne,a 4001e728 <rtems_rfs_dir_add_entry+0x204><== NEVER TAKEN
4001e53c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%zd\n", length);
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001e540: 90 10 00 18 mov %i0, %o0
4001e544: 92 10 00 19 mov %i1, %o1
4001e548: 7f ff f8 b2 call 4001c810 <rtems_rfs_block_map_open>
4001e54c: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001e550: ba 92 20 00 orcc %o0, 0, %i5
4001e554: 04 80 00 04 ble 4001e564 <rtems_rfs_dir_add_entry+0x40> <== ALWAYS TAKEN
4001e558: 29 00 00 3f sethi %hi(0xfc00), %l4
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001e55c: 81 c7 e0 08 ret
4001e560: 91 e8 00 1d restore %g0, %i5, %o0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001e564: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001e568: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001e56c: 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;
4001e570: c0 27 bf 98 clr [ %fp + -104 ]
bpos->boff = 0;
4001e574: c0 27 bf 9c clr [ %fp + -100 ]
bpos->block = 0;
4001e578: c0 27 bf a0 clr [ %fp + -96 ]
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001e57c: a8 15 23 ff or %l4, 0x3ff, %l4
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
4001e580: a6 06 e0 0a add %i3, 0xa, %l3
/*
* Locate the first block. If an error the block will be 0. If the map is
* empty which happens when creating a directory and adding the first entry
* the seek will return ENXIO. In this case we need to grow the directory.
*/
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
4001e584: 90 10 00 18 mov %i0, %o0
4001e588: 92 07 bf b0 add %fp, -80, %o1
4001e58c: 94 07 bf 98 add %fp, -104, %o2
4001e590: 7f ff f9 75 call 4001cb64 <rtems_rfs_block_map_find>
4001e594: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
4001e598: ba 92 20 00 orcc %o0, 0, %i5
4001e59c: 04 80 00 ae ble 4001e854 <rtems_rfs_dir_add_entry+0x330>
4001e5a0: 80 a7 60 06 cmp %i5, 6
{
if (rc != ENXIO)
4001e5a4: 12 80 00 c7 bne 4001e8c0 <rtems_rfs_dir_add_entry+0x39c> <== NEVER TAKEN
4001e5a8: 90 10 00 18 mov %i0, %o0
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
4001e5ac: 92 07 bf b0 add %fp, -80, %o1
4001e5b0: 94 10 20 01 mov 1, %o2
4001e5b4: 7f ff f9 f0 call 4001cd74 <rtems_rfs_block_map_grow>
4001e5b8: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
4001e5bc: ba 92 20 00 orcc %o0, 0, %i5
4001e5c0: 14 80 00 d1 bg 4001e904 <rtems_rfs_dir_add_entry+0x3e0> <== NEVER TAKEN
4001e5c4: a0 10 20 00 clr %l0
}
read = false;
}
bpos.bno++;
4001e5c8: c2 07 bf 98 ld [ %fp + -104 ], %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001e5cc: d4 07 bf 94 ld [ %fp + -108 ], %o2
}
read = false;
}
bpos.bno++;
4001e5d0: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001e5d4: a0 0c 20 ff and %l0, 0xff, %l0
}
read = false;
}
bpos.bno++;
4001e5d8: c2 27 bf 98 st %g1, [ %fp + -104 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
4001e5dc: 90 10 00 18 mov %i0, %o0
4001e5e0: 92 07 bf a4 add %fp, -92, %o1
4001e5e4: 7f ff fc 8f call 4001d820 <rtems_rfs_buffer_handle_request>
4001e5e8: 96 10 00 10 mov %l0, %o3
if (rc > 0)
4001e5ec: ba 92 20 00 orcc %o0, 0, %i5
4001e5f0: 14 80 00 9b bg 4001e85c <rtems_rfs_dir_add_entry+0x338> <== NEVER TAKEN
4001e5f4: c2 07 bf ac ld [ %fp + -84 ], %g1
break;
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
4001e5f8: 80 a4 20 00 cmp %l0, 0
4001e5fc: 02 80 00 5e be 4001e774 <rtems_rfs_dir_add_entry+0x250>
4001e600: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001e604: da 06 20 08 ld [ %i0 + 8 ], %o5
4001e608: 9e 83 7f f6 addcc %o5, -10, %o7
4001e60c: 02 bf ff df be 4001e588 <rtems_rfs_dir_add_entry+0x64> <== NEVER TAKEN
4001e610: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001e614: e0 0f 60 08 ldub [ %i5 + 8 ], %l0
4001e618: c8 0f 60 09 ldub [ %i5 + 9 ], %g4
eino = rtems_rfs_dir_entry_ino (entry);
4001e61c: e4 0f 40 00 ldub [ %i5 ], %l2
4001e620: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
4001e624: c4 0f 60 03 ldub [ %i5 + 3 ], %g2
4001e628: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001e62c: a1 2c 20 08 sll %l0, 8, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001e630: a5 2c a0 18 sll %l2, 0x18, %l2
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001e634: a0 14 00 04 or %l0, %g4, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001e638: 87 28 e0 08 sll %g3, 8, %g3
4001e63c: 83 28 60 10 sll %g1, 0x10, %g1
4001e640: a4 14 80 03 or %l2, %g3, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001e644: 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);
4001e648: a4 14 80 02 or %l2, %g2, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001e64c: 02 80 00 58 be 4001e7ac <rtems_rfs_dir_add_entry+0x288>
4001e650: a4 14 80 01 or %l2, %g1, %l2
4001e654: 10 80 00 20 b 4001e6d4 <rtems_rfs_dir_add_entry+0x1b0>
4001e658: a2 10 20 00 clr %l1
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001e65c: 80 a4 00 01 cmp %l0, %g1
4001e660: 1a 80 00 20 bcc 4001e6e0 <rtems_rfs_dir_add_entry+0x1bc> <== NEVER TAKEN
4001e664: ba 07 40 10 add %i5, %l0, %i5
4001e668: 80 a4 a0 00 cmp %l2, 0
4001e66c: 02 80 00 1e be 4001e6e4 <rtems_rfs_dir_add_entry+0x1c0> <== NEVER TAKEN
4001e670: 90 10 20 00 clr %o0
4001e674: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001e678: 80 a0 40 12 cmp %g1, %l2
4001e67c: 0a 80 00 1a bcs 4001e6e4 <rtems_rfs_dir_add_entry+0x1c0> <== NEVER TAKEN
4001e680: 01 00 00 00 nop
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
offset += elength;
4001e684: 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))
4001e688: 80 a4 40 0f cmp %l1, %o7
4001e68c: 1a bf ff be bcc 4001e584 <rtems_rfs_dir_add_entry+0x60> <== NEVER TAKEN
4001e690: 98 10 00 11 mov %l1, %o4
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001e694: e0 0f 60 08 ldub [ %i5 + 8 ], %l0
4001e698: c8 0f 60 09 ldub [ %i5 + 9 ], %g4
eino = rtems_rfs_dir_entry_ino (entry);
4001e69c: e4 0f 40 00 ldub [ %i5 ], %l2
4001e6a0: c6 0f 60 01 ldub [ %i5 + 1 ], %g3
4001e6a4: c4 0f 60 03 ldub [ %i5 + 3 ], %g2
4001e6a8: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001e6ac: a1 2c 20 08 sll %l0, 8, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001e6b0: a5 2c a0 18 sll %l2, 0x18, %l2
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001e6b4: a0 14 00 04 or %l0, %g4, %l0
eino = rtems_rfs_dir_entry_ino (entry);
4001e6b8: 87 28 e0 10 sll %g3, 0x10, %g3
4001e6bc: 83 28 60 08 sll %g1, 8, %g1
4001e6c0: a4 14 80 03 or %l2, %g3, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001e6c4: 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);
4001e6c8: a4 14 80 02 or %l2, %g2, %l2
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001e6cc: 02 80 00 39 be 4001e7b0 <rtems_rfs_dir_add_entry+0x28c>
4001e6d0: a4 14 80 01 or %l2, %g1, %l2
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001e6d4: 80 a4 20 0a cmp %l0, 0xa
4001e6d8: 34 bf ff e1 bg,a 4001e65c <rtems_rfs_dir_add_entry+0x138><== ALWAYS TAKEN
4001e6dc: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001e6e0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e6e4: 7f ff da 70 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001e6e8: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001e6ec: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e6f0: 32 80 00 27 bne,a 4001e78c <rtems_rfs_dir_add_entry+0x268><== NOT EXECUTED
4001e6f4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4001e6f8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001e6fc: 7f ff fb cf call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e700: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
rtems_rfs_inode_ino (dir), elength, eino, offset);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
4001e704: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
4001e708: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED
handle->bnum = 0;
4001e70c: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED
handle->buffer = NULL;
4001e710: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED
4001e714: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001e718: 7f ff f8 9f call 4001c994 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001e71c: 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;
}
4001e720: 81 c7 e0 08 ret <== NOT EXECUTED
4001e724: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
4001e728: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e72c: 40 00 1a 94 call 4002517c <printf> <== NOT EXECUTED
4001e730: 90 12 23 08 or %o0, 0x308, %o0 ! 40038708 <CSWTCH.2+0x918><== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
4001e734: ba 10 20 00 clr %i5 <== NOT EXECUTED
4001e738: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
4001e73c: 02 80 00 08 be 4001e75c <rtems_rfs_dir_add_entry+0x238> <== NOT EXECUTED
4001e740: 82 10 20 00 clr %g1 <== NOT EXECUTED
printf ("%c", name[c]);
4001e744: d0 4e 80 01 ldsb [ %i2 + %g1 ], %o0 <== NOT EXECUTED
4001e748: 40 00 1a f7 call 40025324 <putchar> <== NOT EXECUTED
4001e74c: 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++)
4001e750: 80 a7 40 1b cmp %i5, %i3 <== NOT EXECUTED
4001e754: 12 bf ff fc bne 4001e744 <rtems_rfs_dir_add_entry+0x220> <== NOT EXECUTED
4001e758: 82 10 00 1d mov %i5, %g1 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
4001e75c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001e760: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e764: 40 00 1a 86 call 4002517c <printf> <== NOT EXECUTED
4001e768: 90 12 23 38 or %o0, 0x338, %o0 ! 40038738 <CSWTCH.2+0x948><== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001e76c: 10 bf ff 76 b 4001e544 <rtems_rfs_dir_add_entry+0x20> <== NOT EXECUTED
4001e770: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
4001e774: d4 06 20 08 ld [ %i0 + 8 ], %o2
4001e778: 90 10 00 1d mov %i5, %o0
4001e77c: 40 00 1a 02 call 40024f84 <memset>
4001e780: 92 10 20 ff mov 0xff, %o1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001e784: 10 bf ff a1 b 4001e608 <rtems_rfs_dir_add_entry+0xe4>
4001e788: da 06 20 08 ld [ %i0 + 8 ], %o5
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
printf ("rtems-rfs: dir-add-entry: "
4001e78c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
4001e790: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001e794: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
4001e798: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
4001e79c: 40 00 1a 78 call 4002517c <printf> <== NOT EXECUTED
4001e7a0: 90 12 20 20 or %o0, 0x20, %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);
4001e7a4: 10 bf ff d6 b 4001e6fc <rtems_rfs_dir_add_entry+0x1d8> <== NOT EXECUTED
4001e7a8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001e7ac: 98 10 20 00 clr %o4
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
4001e7b0: 9a 23 40 0c sub %o5, %o4, %o5
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
4001e7b4: 80 a4 c0 0d cmp %l3, %o5
4001e7b8: 3a bf ff 74 bcc,a 4001e588 <rtems_rfs_dir_add_entry+0x64><== NEVER TAKEN
4001e7bc: 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);
4001e7c0: 92 10 00 1b mov %i3, %o1
4001e7c4: 40 00 13 ed call 40023778 <rtems_rfs_dir_hash>
4001e7c8: 90 10 00 1a mov %i2, %o0
rtems_rfs_dir_set_entry_hash (entry, hash);
4001e7cc: 83 32 20 08 srl %o0, 8, %g1
4001e7d0: c2 2f 60 06 stb %g1, [ %i5 + 6 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001e7d4: 83 37 20 10 srl %i4, 0x10, %g1
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
4001e7d8: 85 32 20 10 srl %o0, 0x10, %g2
rtems_rfs_dir_set_entry_ino (entry, ino);
4001e7dc: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
4001e7e0: 83 37 20 08 srl %i4, 8, %g1
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
4001e7e4: 87 32 20 18 srl %o0, 0x18, %g3
4001e7e8: c4 2f 60 05 stb %g2, [ %i5 + 5 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001e7ec: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
4001e7f0: 85 37 20 18 srl %i4, 0x18, %g2
rtems_rfs_dir_set_entry_length (entry,
4001e7f4: 83 34 e0 08 srl %l3, 8, %g1
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
4001e7f8: c6 2f 60 04 stb %g3, [ %i5 + 4 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001e7fc: c4 2f 40 00 stb %g2, [ %i5 ]
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001e800: 94 10 00 1b mov %i3, %o2
4001e804: 92 10 00 1a mov %i2, %o1
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
4001e808: d0 2f 60 07 stb %o0, [ %i5 + 7 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
4001e80c: f8 2f 60 03 stb %i4, [ %i5 + 3 ]
rtems_rfs_dir_set_entry_length (entry,
4001e810: e6 2f 60 09 stb %l3, [ %i5 + 9 ]
4001e814: c2 2f 60 08 stb %g1, [ %i5 + 8 ]
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
4001e818: 40 00 19 4c call 40024d48 <memcpy>
4001e81c: 90 07 60 0a add %i5, 0xa, %o0
rtems_rfs_buffer_mark_dirty (&buffer);
4001e820: 82 10 20 01 mov 1, %g1
4001e824: 92 07 bf a4 add %fp, -92, %o1
4001e828: 90 10 00 18 mov %i0, %o0
4001e82c: 7f ff fb 83 call 4001d638 <rtems_rfs_buffer_handle_release>
4001e830: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
4001e834: 90 10 00 18 mov %i0, %o0
handle->dirty = false;
4001e838: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001e83c: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001e840: c0 27 bf ac clr [ %fp + -84 ]
4001e844: 92 07 bf b0 add %fp, -80, %o1
4001e848: 7f ff f8 53 call 4001c994 <rtems_rfs_block_map_close>
4001e84c: ba 10 20 00 clr %i5
4001e850: 30 bf ff 43 b,a 4001e55c <rtems_rfs_dir_add_entry+0x38>
while (true)
{
rtems_rfs_block_no block;
uint8_t* entry;
int offset;
bool read = true;
4001e854: 10 bf ff 5d b 4001e5c8 <rtems_rfs_dir_add_entry+0xa4>
4001e858: a0 10 20 01 mov 1, %l0
bpos.bno++;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001e85c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e860: 7f ff da 11 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001e864: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001e868: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e86c: 22 80 00 0c be,a 4001e89c <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED
4001e870: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001e874: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001e878: 40 00 1e 8b call 400262a4 <strerror> <== NOT EXECUTED
4001e87c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e880: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001e884: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001e888: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001e88c: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e890: 40 00 1a 3b call 4002517c <printf> <== NOT EXECUTED
4001e894: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 400387d8 <CSWTCH.2+0x9e8><== 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);
4001e898: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001e89c: 7f ff fb 67 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e8a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
4001e8a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
4001e8a8: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED
handle->bnum = 0;
4001e8ac: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED
handle->buffer = NULL;
4001e8b0: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED
4001e8b4: 7f ff f8 38 call 4001c994 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001e8b8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001e8bc: 30 bf ff 28 b,a 4001e55c <rtems_rfs_dir_add_entry+0x38> <== NOT EXECUTED
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
if (rc > 0)
{
if (rc != ENXIO)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001e8c0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e8c4: 7f ff d9 f8 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001e8c8: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001e8cc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e8d0: 22 bf ff f3 be,a 4001e89c <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED
4001e8d4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001e8d8: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001e8dc: 40 00 1e 72 call 400262a4 <strerror> <== NOT EXECUTED
4001e8e0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e8e4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001e8e8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001e8ec: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001e8f0: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e8f4: 40 00 1a 22 call 4002517c <printf> <== NOT EXECUTED
4001e8f8: 90 12 23 48 or %o0, 0x348, %o0 ! 40038748 <CSWTCH.2+0x958><== 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);
4001e8fc: 10 bf ff e8 b 4001e89c <rtems_rfs_dir_add_entry+0x378> <== NOT EXECUTED
4001e900: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
4001e904: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e908: 7f ff d9 e7 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001e90c: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
4001e910: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e914: 22 bf ff e2 be,a 4001e89c <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED
4001e918: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
4001e91c: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001e920: 40 00 1e 61 call 400262a4 <strerror> <== NOT EXECUTED
4001e924: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001e928: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001e92c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001e930: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001e934: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e938: 40 00 1a 11 call 4002517c <printf> <== NOT EXECUTED
4001e93c: 90 12 23 90 or %o0, 0x390, %o0 ! 40038790 <CSWTCH.2+0x9a0><== NOT EXECUTED
4001e940: 10 bf ff d7 b 4001e89c <rtems_rfs_dir_add_entry+0x378> <== NOT EXECUTED
4001e944: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001e948 <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)
{
4001e948: 9d e3 bf 40 save %sp, -192, %sp
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001e94c: 90 10 20 00 clr %o0
4001e950: 13 10 00 00 sethi %hi(0x40000000), %o1
4001e954: 7f ff d9 d4 call 400150a4 <rtems_rfs_trace>
4001e958: a2 10 00 18 mov %i0, %l1
4001e95c: 80 8a 20 ff btst 0xff, %o0
4001e960: 12 80 00 0a bne 4001e988 <rtems_rfs_dir_del_entry+0x40> <== NEVER TAKEN
4001e964: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001e968: 90 10 00 11 mov %l1, %o0
4001e96c: 7f ff f7 a9 call 4001c810 <rtems_rfs_block_map_open>
4001e970: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001e974: b0 92 20 00 orcc %o0, 0, %i0
4001e978: 04 80 00 11 ble 4001e9bc <rtems_rfs_dir_del_entry+0x74> <== ALWAYS TAKEN
4001e97c: 90 10 00 11 mov %l1, %o0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001e980: 81 c7 e0 08 ret <== NOT EXECUTED
4001e984: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
4001e988: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001e98c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001e990: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4001e994: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001e998: 40 00 19 f9 call 4002517c <printf> <== NOT EXECUTED
4001e99c: 90 12 20 68 or %o0, 0x68, %o0 ! 40038868 <CSWTCH.2+0xa78> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001e9a0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001e9a4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001e9a8: 7f ff f7 9a call 4001c810 <rtems_rfs_block_map_open> <== NOT EXECUTED
4001e9ac: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
if (rc > 0)
4001e9b0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001e9b4: 14 bf ff f3 bg 4001e980 <rtems_rfs_dir_del_entry+0x38> <== NOT EXECUTED
4001e9b8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001e9bc: 92 07 bf b0 add %fp, -80, %o1
4001e9c0: 94 10 20 00 clr %o2
4001e9c4: 96 10 00 1b mov %i3, %o3
4001e9c8: 7f ff f8 c1 call 4001cccc <rtems_rfs_block_map_seek>
4001e9cc: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
4001e9d0: b0 92 20 00 orcc %o0, 0, %i0
4001e9d4: 04 80 00 09 ble 4001e9f8 <rtems_rfs_dir_del_entry+0xb0> <== ALWAYS TAKEN
4001e9d8: 80 a6 20 06 cmp %i0, 6
{
if (rc == ENXIO)
4001e9dc: 22 80 00 02 be,a 4001e9e4 <rtems_rfs_dir_del_entry+0x9c> <== NOT EXECUTED
4001e9e0: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
4001e9e4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001e9e8: 7f ff f7 eb call 4001c994 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001e9ec: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001e9f0: 81 c7 e0 08 ret <== NOT EXECUTED
4001e9f4: 81 e8 00 00 restore <== NOT EXECUTED
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
4001e9f8: 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)
4001e9fc: 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;
4001ea00: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001ea04: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001ea08: c0 27 bf ac clr [ %fp + -84 ]
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
4001ea0c: 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)
4001ea10: a8 15 23 ff or %l4, 0x3ff, %l4
while (rc == 0)
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001ea14: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001ea18: 90 10 00 11 mov %l1, %o0
4001ea1c: 92 07 bf a4 add %fp, -92, %o1
4001ea20: 7f ff fb 80 call 4001d820 <rtems_rfs_buffer_handle_request>
4001ea24: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001ea28: b0 92 20 00 orcc %o0, 0, %i0
4001ea2c: 14 80 00 cc bg 4001ed5c <rtems_rfs_dir_del_entry+0x414> <== NEVER TAKEN
4001ea30: 80 a4 e0 00 cmp %l3, 0
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
4001ea34: 02 80 00 63 be 4001ebc0 <rtems_rfs_dir_del_entry+0x278> <== ALWAYS TAKEN
4001ea38: ea 04 60 08 ld [ %l1 + 8 ], %l5
4001ea3c: 90 10 20 00 clr %o0 <== NOT EXECUTED
eoffset = 0;
4001ea40: a4 10 20 00 clr %l2 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
4001ea44: c2 07 bf ac ld [ %fp + -84 ], %g1
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001ea48: 9e 05 7f f6 add %l5, -10, %o7
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
4001ea4c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001ea50: 80 a3 c0 08 cmp %o7, %o0
4001ea54: 08 80 00 33 bleu 4001eb20 <rtems_rfs_dir_del_entry+0x1d8> <== NEVER TAKEN
4001ea58: ba 00 40 08 add %g1, %o0, %i5
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001ea5c: f8 0f 60 08 ldub [ %i5 + 8 ], %i4
4001ea60: c8 0f 60 09 ldub [ %i5 + 9 ], %g4
eino = rtems_rfs_dir_entry_ino (entry);
4001ea64: e0 0f 60 01 ldub [ %i5 + 1 ], %l0
4001ea68: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
4001ea6c: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001ea70: b9 2f 20 08 sll %i4, 8, %i4
eino = rtems_rfs_dir_entry_ino (entry);
4001ea74: c4 0f 60 03 ldub [ %i5 + 3 ], %g2
4001ea78: a1 2c 20 10 sll %l0, 0x10, %l0
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001ea7c: b8 17 00 04 or %i4, %g4, %i4
eino = rtems_rfs_dir_entry_ino (entry);
4001ea80: 87 28 e0 08 sll %g3, 8, %g3
4001ea84: 10 80 00 22 b 4001eb0c <rtems_rfs_dir_del_entry+0x1c4>
4001ea88: 83 28 60 18 sll %g1, 0x18, %g1
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001ea8c: 80 a7 20 0a cmp %i4, 0xa
4001ea90: 04 80 00 33 ble 4001eb5c <rtems_rfs_dir_del_entry+0x214> <== NEVER TAKEN
4001ea94: 90 10 20 00 clr %o0
4001ea98: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
4001ea9c: 80 a7 00 01 cmp %i4, %g1
4001eaa0: 1a 80 00 2f bcc 4001eb5c <rtems_rfs_dir_del_entry+0x214> <== NEVER TAKEN
4001eaa4: 80 a4 20 00 cmp %l0, 0
4001eaa8: 02 80 00 2d be 4001eb5c <rtems_rfs_dir_del_entry+0x214> <== NEVER TAKEN
4001eaac: 01 00 00 00 nop
4001eab0: c2 04 60 14 ld [ %l1 + 0x14 ], %g1
4001eab4: 80 a0 40 10 cmp %g1, %l0
4001eab8: 0a 80 00 29 bcs 4001eb5c <rtems_rfs_dir_del_entry+0x214> <== NEVER TAKEN
4001eabc: 80 a6 80 10 cmp %i2, %l0
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
4001eac0: 02 80 00 45 be 4001ebd4 <rtems_rfs_dir_del_entry+0x28c> <== ALWAYS TAKEN
4001eac4: 80 a4 e0 00 cmp %l3, 0
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
}
if (!search)
4001eac8: 22 80 00 33 be,a 4001eb94 <rtems_rfs_dir_del_entry+0x24c><== NOT EXECUTED
4001eacc: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
rc = EIO;
break;
}
entry += elength;
eoffset += elength;
4001ead0: a4 04 80 1c add %l2, %i4, %l2 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001ead4: 80 a4 80 0f cmp %l2, %o7 <== NOT EXECUTED
4001ead8: 1a 80 00 12 bcc 4001eb20 <rtems_rfs_dir_del_entry+0x1d8> <== NOT EXECUTED
4001eadc: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001eae0: f8 0f 60 08 ldub [ %i5 + 8 ], %i4 <== NOT EXECUTED
4001eae4: c8 0f 60 09 ldub [ %i5 + 9 ], %g4 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
4001eae8: e0 0f 40 00 ldub [ %i5 ], %l0 <== NOT EXECUTED
4001eaec: c6 0f 60 01 ldub [ %i5 + 1 ], %g3 <== NOT EXECUTED
4001eaf0: c2 0f 60 02 ldub [ %i5 + 2 ], %g1 <== NOT EXECUTED
4001eaf4: c4 0f 60 03 ldub [ %i5 + 3 ], %g2 <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001eaf8: b9 2f 20 08 sll %i4, 8, %i4 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
4001eafc: a1 2c 20 18 sll %l0, 0x18, %l0 <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001eb00: b8 17 00 04 or %i4, %g4, %i4 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
4001eb04: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
4001eb08: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4001eb0c: a0 14 00 03 or %l0, %g3, %l0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001eb10: 80 a7 00 14 cmp %i4, %l4
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
4001eb14: a0 14 00 02 or %l0, %g2, %l0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001eb18: 12 bf ff dd bne 4001ea8c <rtems_rfs_dir_del_entry+0x144> <== ALWAYS TAKEN
4001eb1c: a0 14 00 01 or %l0, %g1, %l0
entry += elength;
eoffset += elength;
}
if (rc == 0)
4001eb20: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001eb24: 12 80 00 1d bne 4001eb98 <rtems_rfs_dir_del_entry+0x250> <== NOT EXECUTED
4001eb28: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001eb2c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001eb30: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001eb34: 7f ff f8 83 call 4001cd40 <rtems_rfs_block_map_next_block><== NOT EXECUTED
4001eb38: 94 07 bf a0 add %fp, -96, %o2 <== NOT EXECUTED
if (rc == ENXIO)
4001eb3c: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED
4001eb40: 02 80 00 85 be 4001ed54 <rtems_rfs_dir_del_entry+0x40c> <== NOT EXECUTED
4001eb44: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
4001eb48: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001eb4c: 02 bf ff b3 be 4001ea18 <rtems_rfs_dir_del_entry+0xd0> <== NOT EXECUTED
4001eb50: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4001eb54: 10 80 00 11 b 4001eb98 <rtems_rfs_dir_del_entry+0x250> <== NOT EXECUTED
4001eb58: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001eb5c: 7f ff d9 52 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001eb60: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
4001eb64: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001eb68: 22 80 00 0b be,a 4001eb94 <rtems_rfs_dir_del_entry+0x24c><== NOT EXECUTED
4001eb6c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001eb70: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001eb74: d8 07 bf a0 ld [ %fp + -96 ], %o4 <== NOT EXECUTED
4001eb78: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001eb7c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001eb80: 90 12 20 f0 or %o0, 0xf0, %o0 <== NOT EXECUTED
4001eb84: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
4001eb88: 40 00 19 7d call 4002517c <printf> <== NOT EXECUTED
4001eb8c: 9a 10 00 12 mov %l2, %o5 <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
4001eb90: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001eb94: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001eb98: 7f ff fa a8 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001eb9c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
4001eba0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
handle->dirty = false;
4001eba4: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED
handle->bnum = 0;
4001eba8: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED
handle->buffer = NULL;
4001ebac: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED
4001ebb0: 7f ff f7 79 call 4001c994 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001ebb4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001ebb8: 81 c7 e0 08 ret <== NOT EXECUTED
4001ebbc: 81 e8 00 00 restore <== NOT EXECUTED
* skip to the offset in the block.
*/
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
4001ebc0: 90 10 00 1b mov %i3, %o0
4001ebc4: 40 00 4b 04 call 400317d4 <.urem>
4001ebc8: 92 10 00 15 mov %l5, %o1
4001ebcc: 10 bf ff 9e b 4001ea44 <rtems_rfs_dir_del_entry+0xfc>
4001ebd0: a4 10 00 08 mov %o0, %l2
}
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
4001ebd4: 82 07 00 12 add %i4, %l2, %g1
memmove (entry, entry + elength, remaining);
4001ebd8: 92 07 40 1c add %i5, %i4, %o1
}
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
4001ebdc: aa 25 40 01 sub %l5, %g1, %l5
memmove (entry, entry + elength, remaining);
4001ebe0: 90 10 00 1d mov %i5, %o0
4001ebe4: 40 00 18 96 call 40024e3c <memmove>
4001ebe8: 94 10 00 15 mov %l5, %o2
memset (entry + remaining, 0xff, elength);
4001ebec: 92 10 20 ff mov 0xff, %o1
4001ebf0: 94 10 00 1c mov %i4, %o2
4001ebf4: 40 00 18 e4 call 40024f84 <memset>
4001ebf8: 90 07 40 15 add %i5, %l5, %o0
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
4001ebfc: c2 0f 60 09 ldub [ %i5 + 9 ], %g1
4001ec00: c4 0f 60 08 ldub [ %i5 + 8 ], %g2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001ec04: 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);
4001ec08: bb 28 a0 08 sll %g2, 8, %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001ec0c: 13 10 00 00 sethi %hi(0x40000000), %o1
4001ec10: 7f ff d9 25 call 400150a4 <rtems_rfs_trace>
4001ec14: ba 17 40 01 or %i5, %g1, %i5
4001ec18: 80 8a 20 ff btst 0xff, %o0
4001ec1c: 02 80 00 17 be 4001ec78 <rtems_rfs_dir_del_entry+0x330> <== ALWAYS TAKEN
4001ec20: 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");
4001ec24: 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: "
4001ec28: d6 07 bf a0 ld [ %fp + -96 ], %o3 <== NOT EXECUTED
4001ec2c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001ec30: 12 80 00 05 bne 4001ec44 <rtems_rfs_dir_del_entry+0x2fc> <== NOT EXECUTED
4001ec34: 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");
4001ec38: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4001ec3c: 02 80 00 3e be 4001ed34 <rtems_rfs_dir_del_entry+0x3ec> <== NOT EXECUTED
4001ec40: 1b 10 00 db sethi %hi(0x40036c00), %o5 <== NOT EXECUTED
4001ec44: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4001ec48: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4001ec4c: 02 80 00 3a be 4001ed34 <rtems_rfs_dir_del_entry+0x3ec> <== NOT EXECUTED
4001ec50: 1b 10 00 db sethi %hi(0x40036c00), %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: "
4001ec54: 1b 10 00 d5 sethi %hi(0x40035400), %o5 <== NOT EXECUTED
4001ec58: 9a 13 60 60 or %o5, 0x60, %o5 ! 40035460 <Callbacks.6428+0x218><== NOT EXECUTED
4001ec5c: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001ec60: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001ec64: 90 12 21 40 or %o0, 0x140, %o0 <== NOT EXECUTED
4001ec68: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001ec6c: 40 00 19 44 call 4002517c <printf> <== NOT EXECUTED
4001ec70: 98 10 00 12 mov %l2, %o4 <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
4001ec74: 03 3f ff c0 sethi %hi(0xffff0000), %g1 <== NOT EXECUTED
4001ec78: ba 38 40 1d xnor %g1, %i5, %i5
4001ec7c: 80 a7 60 00 cmp %i5, 0
4001ec80: 12 80 00 1f bne 4001ecfc <rtems_rfs_dir_del_entry+0x3b4>
4001ec84: 80 a4 a0 00 cmp %l2, 0
4001ec88: 12 80 00 1d bne 4001ecfc <rtems_rfs_dir_del_entry+0x3b4> <== ALWAYS TAKEN
4001ec8c: c2 07 bf c0 ld [ %fp + -64 ], %g1
(eoffset == 0) && rtems_rfs_block_map_last (&map))
4001ec90: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001ec94: 12 80 00 2a bne 4001ed3c <rtems_rfs_dir_del_entry+0x3f4> <== NOT EXECUTED
4001ec98: c4 07 bf b8 ld [ %fp + -72 ], %g2 <== NOT EXECUTED
4001ec9c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4001eca0: 12 80 00 28 bne 4001ed40 <rtems_rfs_dir_del_entry+0x3f8> <== NOT EXECUTED
4001eca4: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
4001eca8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001ecac: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001ecb0: 7f ff f9 27 call 4001d14c <rtems_rfs_block_map_shrink> <== NOT EXECUTED
4001ecb4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
if (rc > 0)
4001ecb8: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4001ecbc: 04 80 00 10 ble 4001ecfc <rtems_rfs_dir_del_entry+0x3b4> <== NOT EXECUTED
4001ecc0: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001ecc4: 7f ff d8 f8 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001ecc8: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
4001eccc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ecd0: 02 80 00 0c be 4001ed00 <rtems_rfs_dir_del_entry+0x3b8> <== NOT EXECUTED
4001ecd4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001ecd8: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001ecdc: 40 00 1d 72 call 400262a4 <strerror> <== NOT EXECUTED
4001ece0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001ece4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001ece8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001ecec: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001ecf0: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001ecf4: 40 00 19 22 call 4002517c <printf> <== NOT EXECUTED
4001ecf8: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 400389a0 <CSWTCH.2+0xbb0><== 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);
4001ecfc: 82 10 20 01 mov 1, %g1
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4001ed00: 92 07 bf a4 add %fp, -92, %o1
4001ed04: 90 10 00 11 mov %l1, %o0
4001ed08: 7f ff fa 4c call 4001d638 <rtems_rfs_buffer_handle_release>
4001ed0c: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
4001ed10: b0 10 20 00 clr %i0
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
4001ed14: 90 10 00 11 mov %l1, %o0
handle->dirty = false;
4001ed18: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001ed1c: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001ed20: c0 27 bf ac clr [ %fp + -84 ]
4001ed24: 7f ff f7 1c call 4001c994 <rtems_rfs_block_map_close>
4001ed28: 92 07 bf b0 add %fp, -80, %o1
4001ed2c: 81 c7 e0 08 ret
4001ed30: 81 e8 00 00 restore
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
4001ed34: 10 bf ff ca b 4001ec5c <rtems_rfs_dir_del_entry+0x314> <== NOT EXECUTED
4001ed38: 9a 13 63 50 or %o5, 0x350, %o5 <== NOT EXECUTED
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
(eoffset == 0) && rtems_rfs_block_map_last (&map))
4001ed3c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4001ed40: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4001ed44: 12 bf ff ef bne 4001ed00 <rtems_rfs_dir_del_entry+0x3b8> <== NOT EXECUTED
4001ed48: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
4001ed4c: 10 bf ff d8 b 4001ecac <rtems_rfs_dir_del_entry+0x364> <== NOT EXECUTED
4001ed50: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
4001ed54: 10 bf ff 90 b 4001eb94 <rtems_rfs_dir_del_entry+0x24c> <== NOT EXECUTED
4001ed58: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
4001ed5c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001ed60: 7f ff d8 d1 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001ed64: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
4001ed68: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001ed6c: 22 bf ff 8b be,a 4001eb98 <rtems_rfs_dir_del_entry+0x250><== NOT EXECUTED
4001ed70: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
4001ed74: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
4001ed78: 40 00 1d 4b call 400262a4 <strerror> <== NOT EXECUTED
4001ed7c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ed80: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001ed84: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001ed88: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
4001ed8c: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001ed90: 40 00 18 fb call 4002517c <printf> <== NOT EXECUTED
4001ed94: 90 12 20 a8 or %o0, 0xa8, %o0 ! 400388a8 <CSWTCH.2+0xab8> <== 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);
4001ed98: 10 bf ff 80 b 4001eb98 <rtems_rfs_dir_del_entry+0x250> <== NOT EXECUTED
4001ed9c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001f154 <rtems_rfs_dir_empty>:
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
4001f154: 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))
4001f158: 90 10 20 00 clr %o0
4001f15c: 13 20 00 00 sethi %hi(0x80000000), %o1
4001f160: 7f ff d7 d1 call 400150a4 <rtems_rfs_trace>
4001f164: b4 10 00 18 mov %i0, %i2
4001f168: 80 8a 20 ff btst 0xff, %o0
4001f16c: 12 80 00 0a bne 4001f194 <rtems_rfs_dir_empty+0x40> <== NEVER TAKEN
4001f170: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001f174: 90 10 00 1a mov %i2, %o0
4001f178: 7f ff f5 a6 call 4001c810 <rtems_rfs_block_map_open>
4001f17c: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001f180: b0 92 20 00 orcc %o0, 0, %i0
4001f184: 04 80 00 0f ble 4001f1c0 <rtems_rfs_dir_empty+0x6c> <== ALWAYS TAKEN
4001f188: 90 10 00 1a mov %i2, %o0
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001f18c: 81 c7 e0 08 ret <== NOT EXECUTED
4001f190: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
4001f194: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001f198: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001f19c: 40 00 17 f8 call 4002517c <printf> <== NOT EXECUTED
4001f1a0: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 40038ad0 <CSWTCH.2+0xce0><== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001f1a4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4001f1a8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001f1ac: 7f ff f5 99 call 4001c810 <rtems_rfs_block_map_open> <== NOT EXECUTED
4001f1b0: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
if (rc > 0)
4001f1b4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001f1b8: 14 bf ff f5 bg 4001f18c <rtems_rfs_dir_empty+0x38> <== NOT EXECUTED
4001f1bc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001f1c0: 92 07 bf b0 add %fp, -80, %o1
4001f1c4: 94 10 20 00 clr %o2
4001f1c8: 96 10 20 00 clr %o3
4001f1cc: 7f ff f6 c0 call 4001cccc <rtems_rfs_block_map_seek>
4001f1d0: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
4001f1d4: b0 92 20 00 orcc %o0, 0, %i0
4001f1d8: 14 80 00 7d bg 4001f3cc <rtems_rfs_dir_empty+0x278> <== NEVER TAKEN
4001f1dc: 23 00 00 3f sethi %hi(0xfc00), %l1
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
4001f1e0: 21 10 00 e2 sethi %hi(0x40038800), %l0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001f1e4: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001f1e8: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001f1ec: 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)
4001f1f0: a2 14 63 ff or %l1, 0x3ff, %l1
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
4001f1f4: a0 14 22 f0 or %l0, 0x2f0, %l0
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001f1f8: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001f1fc: 90 10 00 1a mov %i2, %o0
4001f200: 92 07 bf a4 add %fp, -92, %o1
4001f204: 7f ff f9 87 call 4001d820 <rtems_rfs_buffer_handle_request>
4001f208: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001f20c: b0 92 20 00 orcc %o0, 0, %i0
4001f210: 14 80 00 4d bg 4001f344 <rtems_rfs_dir_empty+0x1f0> <== NEVER TAKEN
4001f214: 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))
4001f218: da 06 a0 08 ld [ %i2 + 8 ], %o5
4001f21c: 9a 83 7f f6 addcc %o5, -10, %o5
4001f220: 02 80 00 5f be 4001f39c <rtems_rfs_dir_empty+0x248> <== NEVER TAKEN
4001f224: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001f228: fa 08 60 08 ldub [ %g1 + 8 ], %i5
4001f22c: f6 08 60 09 ldub [ %g1 + 9 ], %i3
eino = rtems_rfs_dir_entry_ino (entry);
4001f230: f8 08 40 00 ldub [ %g1 ], %i4
4001f234: c8 08 60 02 ldub [ %g1 + 2 ], %g4
4001f238: c6 08 60 03 ldub [ %g1 + 3 ], %g3
4001f23c: c4 08 60 01 ldub [ %g1 + 1 ], %g2
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001f240: bb 2f 60 08 sll %i5, 8, %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001f244: b9 2f 20 18 sll %i4, 0x18, %i4
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001f248: ba 17 40 1b or %i5, %i3, %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001f24c: 89 29 20 08 sll %g4, 8, %g4
4001f250: 85 28 a0 10 sll %g2, 0x10, %g2
4001f254: b8 17 00 04 or %i4, %g4, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001f258: 80 a7 40 11 cmp %i5, %l1
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
4001f25c: b8 17 00 03 or %i4, %g3, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001f260: 02 80 00 4f be 4001f39c <rtems_rfs_dir_empty+0x248> <== NEVER TAKEN
4001f264: b8 17 00 02 or %i4, %g2, %i4
4001f268: 10 80 00 20 b 4001f2e8 <rtems_rfs_dir_empty+0x194>
4001f26c: b6 10 20 00 clr %i3
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
4001f270: 12 80 00 31 bne 4001f334 <rtems_rfs_dir_empty+0x1e0>
4001f274: 80 a0 00 18 cmp %g0, %i0
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
4001f278: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001f27c: 80 a0 a0 2e cmp %g2, 0x2e
4001f280: 12 80 00 2d bne 4001f334 <rtems_rfs_dir_empty+0x1e0> <== NEVER TAKEN
4001f284: 80 a0 00 18 cmp %g0, %i0
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
4001f288: c4 08 60 0b ldub [ %g1 + 0xb ], %g2
4001f28c: 80 a0 a0 2e cmp %g2, 0x2e
4001f290: 12 80 00 29 bne 4001f334 <rtems_rfs_dir_empty+0x1e0> <== NEVER TAKEN
4001f294: 80 a0 00 18 cmp %g0, %i0
empty = false;
break;
}
entry += elength;
offset += elength;
4001f298: b6 06 c0 1d add %i3, %i5, %i3
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001f29c: 80 a6 c0 0d cmp %i3, %o5
4001f2a0: 1a 80 00 3f bcc 4001f39c <rtems_rfs_dir_empty+0x248> <== NEVER TAKEN
4001f2a4: 82 00 40 1d add %g1, %i5, %g1
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001f2a8: fa 08 60 08 ldub [ %g1 + 8 ], %i5
4001f2ac: de 08 60 09 ldub [ %g1 + 9 ], %o7
eino = rtems_rfs_dir_entry_ino (entry);
4001f2b0: f8 08 40 00 ldub [ %g1 ], %i4
4001f2b4: c8 08 60 01 ldub [ %g1 + 1 ], %g4
4001f2b8: c6 08 60 03 ldub [ %g1 + 3 ], %g3
4001f2bc: c4 08 60 02 ldub [ %g1 + 2 ], %g2
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001f2c0: bb 2f 60 08 sll %i5, 8, %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001f2c4: b9 2f 20 18 sll %i4, 0x18, %i4
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
4001f2c8: ba 17 40 0f or %i5, %o7, %i5
eino = rtems_rfs_dir_entry_ino (entry);
4001f2cc: 89 29 20 10 sll %g4, 0x10, %g4
4001f2d0: 85 28 a0 08 sll %g2, 8, %g2
4001f2d4: b8 17 00 04 or %i4, %g4, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001f2d8: 80 a7 40 11 cmp %i5, %l1
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
4001f2dc: b8 17 00 03 or %i4, %g3, %i4
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001f2e0: 02 80 00 2f be 4001f39c <rtems_rfs_dir_empty+0x248>
4001f2e4: b8 17 00 02 or %i4, %g2, %i4
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001f2e8: 80 a7 60 0a cmp %i5, 0xa
4001f2ec: 04 80 00 21 ble 4001f370 <rtems_rfs_dir_empty+0x21c> <== NEVER TAKEN
4001f2f0: 90 10 20 01 mov 1, %o0
4001f2f4: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2
4001f2f8: 80 a7 40 02 cmp %i5, %g2
4001f2fc: 1a 80 00 1d bcc 4001f370 <rtems_rfs_dir_empty+0x21c> <== NEVER TAKEN
4001f300: 80 a7 20 00 cmp %i4, 0
4001f304: 02 80 00 1b be 4001f370 <rtems_rfs_dir_empty+0x21c> <== NEVER TAKEN
4001f308: 01 00 00 00 nop
4001f30c: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2
4001f310: 80 a0 80 1c cmp %g2, %i4
4001f314: 0a 80 00 17 bcs 4001f370 <rtems_rfs_dir_empty+0x21c> <== NEVER TAKEN
4001f318: 80 a7 60 0b cmp %i5, 0xb
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
4001f31c: 12 bf ff d5 bne 4001f270 <rtems_rfs_dir_empty+0x11c>
4001f320: 80 a7 60 0c cmp %i5, 0xc
4001f324: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001f328: 80 a0 a0 2e cmp %g2, 0x2e
4001f32c: 02 bf ff db be 4001f298 <rtems_rfs_dir_empty+0x144> <== ALWAYS TAKEN
4001f330: 80 a0 00 18 cmp %g0, %i0
4001f334: 82 60 3f ff subx %g0, -1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
4001f338: 80 88 60 ff btst 0xff, %g1
4001f33c: 32 80 00 02 bne,a 4001f344 <rtems_rfs_dir_empty+0x1f0> <== ALWAYS TAKEN
4001f340: b0 10 20 5a mov 0x5a, %i0
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4001f344: 92 07 bf a4 add %fp, -92, %o1
4001f348: 7f ff f8 bc call 4001d638 <rtems_rfs_buffer_handle_release>
4001f34c: 90 10 00 1a mov %i2, %o0
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
4001f350: 90 10 00 1a mov %i2, %o0
handle->dirty = false;
4001f354: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001f358: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001f35c: c0 27 bf ac clr [ %fp + -84 ]
4001f360: 7f ff f5 8d call 4001c994 <rtems_rfs_block_map_close>
4001f364: 92 07 bf b0 add %fp, -80, %o1
4001f368: 81 c7 e0 08 ret
4001f36c: 81 e8 00 00 restore
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
4001f370: 7f ff d7 4d call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001f374: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001f378: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f37c: 02 80 00 09 be 4001f3a0 <rtems_rfs_dir_empty+0x24c> <== NOT EXECUTED
4001f380: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
4001f384: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001f388: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001f38c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001f390: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
4001f394: 40 00 17 7a call 4002517c <printf> <== NOT EXECUTED
4001f398: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001f39c: 90 10 00 1a mov %i2, %o0
4001f3a0: 92 07 bf b0 add %fp, -80, %o1
4001f3a4: 7f ff f6 67 call 4001cd40 <rtems_rfs_block_map_next_block>
4001f3a8: 94 07 bf a0 add %fp, -96, %o2
if (rc > 0)
4001f3ac: b0 92 20 00 orcc %o0, 0, %i0
4001f3b0: 04 bf ff 93 ble 4001f1fc <rtems_rfs_dir_empty+0xa8> <== NEVER TAKEN
4001f3b4: d4 07 bf a0 ld [ %fp + -96 ], %o2
{
if (rc == ENXIO)
rc = 0;
4001f3b8: 82 1e 20 06 xor %i0, 6, %g1
4001f3bc: 80 a0 00 01 cmp %g0, %g1
4001f3c0: 82 60 20 00 subx %g0, 0, %g1
4001f3c4: 10 bf ff e0 b 4001f344 <rtems_rfs_dir_empty+0x1f0>
4001f3c8: b0 0e 00 01 and %i0, %g1, %i0
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
4001f3cc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4001f3d0: 7f ff f5 71 call 4001c994 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001f3d4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001f3d8: 81 c7 e0 08 ret <== NOT EXECUTED
4001f3dc: 81 e8 00 00 restore <== NOT EXECUTED
40023778 <rtems_rfs_dir_hash>:
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
40023778: 9d e3 bf a0 save %sp, -96, %sp
uint32_t a,b,c; /* internal state */
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
/* Set up the internal state */
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
4002377c: 09 37 f7 c5 sethi %hi(0xdfdf1400), %g4
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
40023780: 82 10 00 18 mov %i0, %g1
{
uint32_t a,b,c; /* internal state */
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
/* Set up the internal state */
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
40023784: 88 11 22 9f or %g4, 0x29f, %g4
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
40023788: 80 a6 60 0c cmp %i1, 0xc
{
uint32_t a,b,c; /* internal state */
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
/* Set up the internal state */
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
4002378c: 88 06 40 04 add %i1, %g4, %g4
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
40023790: 84 10 00 04 mov %g4, %g2
40023794: 08 80 00 4b bleu 400238c0 <rtems_rfs_dir_hash+0x148>
40023798: 86 10 00 04 mov %g4, %g3
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
4002379c: f8 08 60 0b ldub [ %g1 + 0xb ], %i4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
400237a0: fa 08 60 03 ldub [ %g1 + 3 ], %i5
b += k[4];
b += ((uint32_t)k[5])<<8;
400237a4: d8 08 60 05 ldub [ %g1 + 5 ], %o4
b += ((uint32_t)k[6])<<16;
400237a8: d0 08 60 06 ldub [ %g1 + 6 ], %o0
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
400237ac: d2 08 60 04 ldub [ %g1 + 4 ], %o1
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
400237b0: d4 08 60 07 ldub [ %g1 + 7 ], %o2
c += k[8];
c += ((uint32_t)k[9])<<8;
400237b4: d6 08 60 09 ldub [ %g1 + 9 ], %o3
c += ((uint32_t)k[10])<<16;
400237b8: f0 08 60 0a ldub [ %g1 + 0xa ], %i0
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
400237bc: da 08 60 08 ldub [ %g1 + 8 ], %o5
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
400237c0: de 08 60 01 ldub [ %g1 + 1 ], %o7
a += ((uint32_t)k[2])<<16;
400237c4: f6 08 60 02 ldub [ %g1 + 2 ], %i3
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
400237c8: f4 08 40 00 ldub [ %g1 ], %i2
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
400237cc: b9 2f 20 18 sll %i4, 0x18, %i4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
400237d0: bb 2f 60 18 sll %i5, 0x18, %i5
b += k[4];
b += ((uint32_t)k[5])<<8;
400237d4: 99 2b 20 08 sll %o4, 8, %o4
b += ((uint32_t)k[6])<<16;
400237d8: 91 2a 20 10 sll %o0, 0x10, %o0
b += ((uint32_t)k[7])<<24;
400237dc: 95 2a a0 18 sll %o2, 0x18, %o2
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
400237e0: 98 03 00 08 add %o4, %o0, %o4
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
400237e4: 97 2a e0 08 sll %o3, 8, %o3
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
400237e8: 98 03 00 09 add %o4, %o1, %o4
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
400237ec: b1 2e 20 10 sll %i0, 0x10, %i0
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
400237f0: 98 03 00 0a add %o4, %o2, %o4
b += ((uint32_t)k[7])<<24;
c += k[8];
400237f4: b0 02 c0 18 add %o3, %i0, %i0
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
400237f8: 84 03 00 02 add %o4, %g2, %g2
c += k[8];
c += ((uint32_t)k[9])<<8;
400237fc: b0 06 00 0d add %i0, %o5, %i0
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
40023800: 9f 2b e0 08 sll %o7, 8, %o7
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
40023804: b0 06 00 1c add %i0, %i4, %i0
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
40023808: b7 2e e0 10 sll %i3, 0x10, %i3
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
4002380c: b0 06 00 04 add %i0, %g4, %i0
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
40023810: b6 03 c0 1b add %o7, %i3, %i3
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
40023814: 88 06 00 02 add %i0, %g2, %g4
40023818: b9 2e 20 04 sll %i0, 4, %i4
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
4002381c: b6 06 c0 1a add %i3, %i2, %i3
a += ((uint32_t)k[2])<<16;
40023820: b6 06 c0 1d add %i3, %i5, %i3
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
40023824: bb 36 20 1c srl %i0, 0x1c, %i5
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
40023828: b0 26 c0 18 sub %i3, %i0, %i0
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
4002382c: ba 17 00 1d or %i4, %i5, %i5
40023830: 86 06 00 03 add %i0, %g3, %g3
40023834: b8 18 c0 1d xor %g3, %i5, %i4
40023838: 86 07 00 04 add %i4, %g4, %g3
4002383c: 84 20 80 1c sub %g2, %i4, %g2
40023840: bb 2f 20 06 sll %i4, 6, %i5
40023844: b9 37 20 1a srl %i4, 0x1a, %i4
40023848: ba 17 40 1c or %i5, %i4, %i5
4002384c: ba 1f 40 02 xor %i5, %g2, %i5
40023850: 84 07 40 03 add %i5, %g3, %g2
40023854: 88 21 00 1d sub %g4, %i5, %g4
40023858: b9 2f 60 08 sll %i5, 8, %i4
4002385c: bb 37 60 18 srl %i5, 0x18, %i5
40023860: ba 17 00 1d or %i4, %i5, %i5
40023864: 88 1f 40 04 xor %i5, %g4, %g4
40023868: b0 01 00 02 add %g4, %g2, %i0
4002386c: bb 29 20 10 sll %g4, 0x10, %i5
40023870: 86 20 c0 04 sub %g3, %g4, %g3
40023874: 89 31 20 10 srl %g4, 0x10, %g4
40023878: 88 17 40 04 or %i5, %g4, %g4
4002387c: 86 19 00 03 xor %g4, %g3, %g3
40023880: bb 28 e0 13 sll %g3, 0x13, %i5
40023884: 89 30 e0 0d srl %g3, 0xd, %g4
40023888: 88 17 40 04 or %i5, %g4, %g4
4002388c: 84 20 80 03 sub %g2, %g3, %g2
length -= 12;
40023890: b2 06 7f f4 add %i1, -12, %i1
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
40023894: 84 19 00 02 xor %g4, %g2, %g2
40023898: 86 00 c0 18 add %g3, %i0, %g3
4002389c: bb 28 a0 04 sll %g2, 4, %i5
400238a0: b0 26 00 02 sub %i0, %g2, %i0
400238a4: 89 30 a0 1c srl %g2, 0x1c, %g4
length -= 12;
k += 12;
400238a8: 82 00 60 0c add %g1, 0xc, %g1
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
400238ac: 88 17 40 04 or %i5, %g4, %g4
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
400238b0: 80 a6 60 0c cmp %i1, 0xc
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
400238b4: 84 00 80 03 add %g2, %g3, %g2
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
400238b8: 18 bf ff b9 bgu 4002379c <rtems_rfs_dir_hash+0x24> <== NEVER TAKEN
400238bc: 88 19 00 18 xor %g4, %i0, %g4
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
400238c0: b3 2e 60 02 sll %i1, 2, %i1
400238c4: 3b 10 00 8d sethi %hi(0x40023400), %i5
400238c8: ba 17 63 44 or %i5, 0x344, %i5 ! 40023744 <rtems_rfs_buffer_bdbuf_release+0x8c>
400238cc: fa 07 40 19 ld [ %i5 + %i1 ], %i5
400238d0: 81 c7 40 00 jmp %i5
400238d4: 01 00 00 00 nop
{
case 12: c+=((uint32_t)k[11])<<24;
400238d8: fa 08 60 0b ldub [ %g1 + 0xb ], %i5
400238dc: bb 2f 60 18 sll %i5, 0x18, %i5
400238e0: 88 01 00 1d add %g4, %i5, %g4
case 11: c+=((uint32_t)k[10])<<16;
400238e4: fa 08 60 0a ldub [ %g1 + 0xa ], %i5
400238e8: bb 2f 60 10 sll %i5, 0x10, %i5
400238ec: 88 01 00 1d add %g4, %i5, %g4
case 10: c+=((uint32_t)k[9])<<8;
400238f0: fa 08 60 09 ldub [ %g1 + 9 ], %i5
400238f4: bb 2f 60 08 sll %i5, 8, %i5
400238f8: 88 01 00 1d add %g4, %i5, %g4
case 9 : c+=k[8];
400238fc: fa 08 60 08 ldub [ %g1 + 8 ], %i5
40023900: 88 01 00 1d add %g4, %i5, %g4
case 8 : b+=((uint32_t)k[7])<<24;
40023904: fa 08 60 07 ldub [ %g1 + 7 ], %i5
40023908: bb 2f 60 18 sll %i5, 0x18, %i5
4002390c: 84 00 80 1d add %g2, %i5, %g2
case 7 : b+=((uint32_t)k[6])<<16;
40023910: fa 08 60 06 ldub [ %g1 + 6 ], %i5
40023914: bb 2f 60 10 sll %i5, 0x10, %i5
40023918: 84 00 80 1d add %g2, %i5, %g2
case 6 : b+=((uint32_t)k[5])<<8;
4002391c: fa 08 60 05 ldub [ %g1 + 5 ], %i5
40023920: bb 2f 60 08 sll %i5, 8, %i5
40023924: 84 00 80 1d add %g2, %i5, %g2
case 5 : b+=k[4];
40023928: fa 08 60 04 ldub [ %g1 + 4 ], %i5
4002392c: 84 00 80 1d add %g2, %i5, %g2
case 4 : a+=((uint32_t)k[3])<<24;
40023930: fa 08 60 03 ldub [ %g1 + 3 ], %i5
40023934: bb 2f 60 18 sll %i5, 0x18, %i5
40023938: 86 00 c0 1d add %g3, %i5, %g3
case 3 : a+=((uint32_t)k[2])<<16;
4002393c: fa 08 60 02 ldub [ %g1 + 2 ], %i5
40023940: bb 2f 60 10 sll %i5, 0x10, %i5
40023944: 86 00 c0 1d add %g3, %i5, %g3
case 2 : a+=((uint32_t)k[1])<<8;
40023948: fa 08 60 01 ldub [ %g1 + 1 ], %i5
4002394c: bb 2f 60 08 sll %i5, 8, %i5
40023950: 86 00 c0 1d add %g3, %i5, %g3
case 1 : a+=k[0];
40023954: c2 08 40 00 ldub [ %g1 ], %g1
break;
case 0 : return c;
}
}
final(a,b,c);
40023958: bb 30 a0 12 srl %g2, 0x12, %i5
case 6 : b+=((uint32_t)k[5])<<8;
case 5 : b+=k[4];
case 4 : a+=((uint32_t)k[3])<<24;
case 3 : a+=((uint32_t)k[2])<<16;
case 2 : a+=((uint32_t)k[1])<<8;
case 1 : a+=k[0];
4002395c: 86 00 c0 01 add %g3, %g1, %g3
break;
case 0 : return c;
}
}
final(a,b,c);
40023960: 83 28 a0 0e sll %g2, 0xe, %g1
40023964: 82 17 40 01 or %i5, %g1, %g1
40023968: 88 19 00 02 xor %g4, %g2, %g4
4002396c: 88 21 00 01 sub %g4, %g1, %g4
40023970: bb 29 20 0b sll %g4, 0xb, %i5
40023974: 83 31 20 15 srl %g4, 0x15, %g1
40023978: 82 17 40 01 or %i5, %g1, %g1
4002397c: 86 19 00 03 xor %g4, %g3, %g3
40023980: 86 20 c0 01 sub %g3, %g1, %g3
40023984: bb 28 e0 19 sll %g3, 0x19, %i5
40023988: 83 30 e0 07 srl %g3, 7, %g1
4002398c: 82 17 40 01 or %i5, %g1, %g1
40023990: 84 18 c0 02 xor %g3, %g2, %g2
40023994: 84 20 80 01 sub %g2, %g1, %g2
40023998: bb 28 a0 10 sll %g2, 0x10, %i5
4002399c: 83 30 a0 10 srl %g2, 0x10, %g1
400239a0: 82 17 40 01 or %i5, %g1, %g1
400239a4: 88 18 80 04 xor %g2, %g4, %g4
400239a8: 88 21 00 01 sub %g4, %g1, %g4
400239ac: bb 29 20 04 sll %g4, 4, %i5
400239b0: 83 31 20 1c srl %g4, 0x1c, %g1
400239b4: 82 17 40 01 or %i5, %g1, %g1
400239b8: 86 19 00 03 xor %g4, %g3, %g3
400239bc: 86 20 c0 01 sub %g3, %g1, %g3
400239c0: 84 18 c0 02 xor %g3, %g2, %g2
400239c4: 83 28 e0 0e sll %g3, 0xe, %g1
400239c8: 87 30 e0 12 srl %g3, 0x12, %g3
400239cc: 86 10 40 03 or %g1, %g3, %g3
400239d0: 84 20 80 03 sub %g2, %g3, %g2
400239d4: 88 18 80 04 xor %g2, %g4, %g4
400239d8: b1 28 a0 18 sll %g2, 0x18, %i0
400239dc: 85 30 a0 08 srl %g2, 8, %g2
400239e0: 84 16 00 02 or %i0, %g2, %g2
400239e4: 88 21 00 02 sub %g4, %g2, %g4
return c;
}
400239e8: 81 c7 e0 08 ret
400239ec: 91 e8 00 04 restore %g0, %g4, %o0
4001dfe8 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
4001dfe8: 9d e3 bf 40 save %sp, -192, %sp
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001dfec: 90 10 20 00 clr %o0
4001dff0: 13 01 00 00 sethi %hi(0x4000000), %o1
4001dff4: 7f ff dc 2c call 400150a4 <rtems_rfs_trace>
4001dff8: a2 10 00 18 mov %i0, %l1
4001dffc: 80 8a 20 ff btst 0xff, %o0
4001e000: 12 80 00 1c bne 4001e070 <rtems_rfs_dir_lookup_ino+0x88> <== NEVER TAKEN
4001e004: 92 10 00 19 mov %i1, %o1
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
4001e008: c0 27 00 00 clr [ %i4 ]
*offset = 0;
4001e00c: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, inode, &map);
4001e010: 90 10 00 11 mov %l1, %o0
4001e014: 7f ff f9 ff call 4001c810 <rtems_rfs_block_map_open>
4001e018: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001e01c: b0 92 20 00 orcc %o0, 0, %i0
4001e020: 24 80 00 30 ble,a 4001e0e0 <rtems_rfs_dir_lookup_ino+0xf8><== ALWAYS TAKEN
4001e024: 92 10 00 1b mov %i3, %o1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001e028: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e02c: 7f ff dc 1e call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001e030: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001e034: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e038: 32 80 00 04 bne,a 4001e048 <rtems_rfs_dir_lookup_ino+0x60><== NOT EXECUTED
4001e03c: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001e040: 81 c7 e0 08 ret <== NOT EXECUTED
4001e044: 81 e8 00 00 restore <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, inode, &map);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
4001e048: 40 00 20 97 call 400262a4 <strerror> <== NOT EXECUTED
4001e04c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001e050: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001e054: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001e058: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
4001e05c: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e060: 40 00 1c 47 call 4002517c <printf> <== NOT EXECUTED
4001e064: 90 12 20 80 or %o0, 0x80, %o0 ! 40038480 <CSWTCH.2+0x690> <== NOT EXECUTED
4001e068: 81 c7 e0 08 ret <== NOT EXECUTED
4001e06c: 81 e8 00 00 restore <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
4001e070: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001e074: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e078: 40 00 1c 41 call 4002517c <printf> <== NOT EXECUTED
4001e07c: 90 12 20 38 or %o0, 0x38, %o0 ! 40038438 <CSWTCH.2+0x648> <== NOT EXECUTED
4001e080: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
4001e084: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
4001e088: 04 80 00 08 ble 4001e0a8 <rtems_rfs_dir_lookup_ino+0xc0> <== NOT EXECUTED
4001e08c: a0 06 80 1b add %i2, %i3, %l0 <== NOT EXECUTED
printf ("%c", name[c]);
4001e090: d0 4e 00 00 ldsb [ %i0 ], %o0 <== NOT EXECUTED
4001e094: 40 00 1c a4 call 40025324 <putchar> <== NOT EXECUTED
4001e098: 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++)
4001e09c: 80 a6 00 10 cmp %i0, %l0 <== NOT EXECUTED
4001e0a0: 32 bf ff fd bne,a 4001e094 <rtems_rfs_dir_lookup_ino+0xac><== NOT EXECUTED
4001e0a4: d0 4e 00 00 ldsb [ %i0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
4001e0a8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001e0ac: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e0b0: 40 00 1c 33 call 4002517c <printf> <== NOT EXECUTED
4001e0b4: 90 12 20 70 or %o0, 0x70, %o0 ! 40038470 <CSWTCH.2+0x680> <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
4001e0b8: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
*offset = 0;
4001e0bc: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, inode, &map);
4001e0c0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001e0c4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001e0c8: 7f ff f9 d2 call 4001c810 <rtems_rfs_block_map_open> <== NOT EXECUTED
4001e0cc: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
if (rc > 0)
4001e0d0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4001e0d4: 14 bf ff d6 bg 4001e02c <rtems_rfs_dir_lookup_ino+0x44> <== NOT EXECUTED
4001e0d8: 90 10 20 00 clr %o0 <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
4001e0dc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001e0e0: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001e0e4: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001e0e8: c0 27 bf ac clr [ %fp + -84 ]
4001e0ec: 40 00 15 a3 call 40023778 <rtems_rfs_dir_hash>
4001e0f0: 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);
4001e0f4: 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);
4001e0f8: a6 10 00 08 mov %o0, %l3
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
4001e0fc: 94 10 20 00 clr %o2
4001e100: 90 10 00 11 mov %l1, %o0
4001e104: 96 10 20 00 clr %o3
4001e108: 7f ff fa f1 call 4001cccc <rtems_rfs_block_map_seek>
4001e10c: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
4001e110: b0 92 20 00 orcc %o0, 0, %i0
4001e114: 04 80 00 15 ble 4001e168 <rtems_rfs_dir_lookup_ino+0x180> <== ALWAYS TAKEN
4001e118: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001e11c: 7f ff db e2 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001e120: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001e124: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e128: 12 80 00 bf bne 4001e424 <rtems_rfs_dir_lookup_ino+0x43c> <== NOT EXECUTED
4001e12c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
rc, strerror (rc));
if (rc == ENXIO)
4001e130: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
4001e134: 22 80 00 02 be,a 4001e13c <rtems_rfs_dir_lookup_ino+0x154><== NOT EXECUTED
4001e138: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4001e13c: 92 07 bf a4 add %fp, -92, %o1
4001e140: 7f ff fd 3e call 4001d638 <rtems_rfs_buffer_handle_release>
4001e144: 90 10 00 11 mov %l1, %o0
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
4001e148: 90 10 00 11 mov %l1, %o0
handle->dirty = false;
4001e14c: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001e150: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001e154: c0 27 bf ac clr [ %fp + -84 ]
4001e158: 7f ff fa 0f call 4001c994 <rtems_rfs_block_map_close>
4001e15c: 92 07 bf b0 add %fp, -80, %o1
4001e160: 81 c7 e0 08 ret
4001e164: 81 e8 00 00 restore
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
4001e168: 2d 10 00 e1 sethi %hi(0x40038400), %l6
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001e16c: 25 00 00 3f sethi %hi(0xfc00), %l2
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
4001e170: 2b 10 00 e1 sethi %hi(0x40038400), %l5
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
4001e174: ac 15 a1 00 or %l6, 0x100, %l6
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001e178: a4 14 a3 ff or %l2, 0x3ff, %l2
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
4001e17c: aa 15 61 d0 or %l5, 0x1d0, %l5
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
4001e180: 80 a6 20 00 cmp %i0, 0
4001e184: 12 80 00 6b bne 4001e330 <rtems_rfs_dir_lookup_ino+0x348> <== NEVER TAKEN
4001e188: c2 07 bf a0 ld [ %fp + -96 ], %g1
4001e18c: 80 a0 60 00 cmp %g1, 0
4001e190: 02 80 00 d3 be 4001e4dc <rtems_rfs_dir_lookup_ino+0x4f4> <== NEVER TAKEN
4001e194: 90 10 20 00 clr %o0
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001e198: 7f ff db c3 call 400150a4 <rtems_rfs_trace>
4001e19c: 13 01 00 00 sethi %hi(0x4000000), %o1
4001e1a0: 80 8a 20 ff btst 0xff, %o0
4001e1a4: 32 80 00 87 bne,a 4001e3c0 <rtems_rfs_dir_lookup_ino+0x3d8><== NEVER TAKEN
4001e1a8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
4001e1ac: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001e1b0: 90 10 00 11 mov %l1, %o0
4001e1b4: 92 07 bf a4 add %fp, -92, %o1
4001e1b8: 7f ff fd 9a call 4001d820 <rtems_rfs_buffer_handle_request>
4001e1bc: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001e1c0: a8 92 20 00 orcc %o0, 0, %l4
4001e1c4: 14 80 00 b3 bg 4001e490 <rtems_rfs_dir_lookup_ino+0x4a8> <== NEVER TAKEN
4001e1c8: c2 07 bf ac ld [ %fp + -84 ], %g1
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001e1cc: d8 04 60 08 ld [ %l1 + 8 ], %o4
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
4001e1d0: c0 27 bf c4 clr [ %fp + -60 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001e1d4: 80 a3 20 0a cmp %o4, 0xa
4001e1d8: 12 80 00 0a bne 4001e200 <rtems_rfs_dir_lookup_ino+0x218> <== ALWAYS TAKEN
4001e1dc: e0 00 60 1c ld [ %g1 + 0x1c ], %l0
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
4001e1e0: 10 80 00 47 b 4001e2fc <rtems_rfs_dir_lookup_ino+0x314> <== NOT EXECUTED
4001e1e4: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001e1e8: 86 03 3f f6 add %o4, -10, %g3
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
4001e1ec: 84 05 c0 02 add %l7, %g2, %g2
4001e1f0: c4 27 bf c4 st %g2, [ %fp + -60 ]
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001e1f4: 80 a0 c0 02 cmp %g3, %g2
4001e1f8: 08 80 00 40 bleu 4001e2f8 <rtems_rfs_dir_lookup_ino+0x310><== NEVER TAKEN
4001e1fc: a0 04 00 17 add %l0, %l7, %l0
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
4001e200: c4 0c 00 00 ldub [ %l0 ], %g2
4001e204: d0 0c 20 01 ldub [ %l0 + 1 ], %o0
4001e208: d2 0c 20 03 ldub [ %l0 + 3 ], %o1
4001e20c: d4 0c 20 02 ldub [ %l0 + 2 ], %o2
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
4001e210: d6 0c 20 04 ldub [ %l0 + 4 ], %o3
4001e214: c8 0c 20 05 ldub [ %l0 + 5 ], %g4
4001e218: da 0c 20 07 ldub [ %l0 + 7 ], %o5
4001e21c: c6 0c 20 06 ldub [ %l0 + 6 ], %g3
elength = rtems_rfs_dir_entry_length (entry);
4001e220: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
4001e224: de 0c 20 09 ldub [ %l0 + 9 ], %o7
*ino = rtems_rfs_dir_entry_ino (entry);
4001e228: 85 28 a0 18 sll %g2, 0x18, %g2
4001e22c: 91 2a 20 10 sll %o0, 0x10, %o0
4001e230: 95 2a a0 08 sll %o2, 8, %o2
4001e234: 84 10 80 08 or %g2, %o0, %g2
4001e238: 84 10 80 09 or %g2, %o1, %g2
4001e23c: 84 10 80 0a or %g2, %o2, %g2
4001e240: c4 27 00 00 st %g2, [ %i4 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
4001e244: 97 2a e0 18 sll %o3, 0x18, %o3
4001e248: 89 29 20 10 sll %g4, 0x10, %g4
4001e24c: 87 28 e0 08 sll %g3, 8, %g3
4001e250: 88 12 c0 04 or %o3, %g4, %g4
elength = rtems_rfs_dir_entry_length (entry);
4001e254: 83 28 60 08 sll %g1, 8, %g1
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
4001e258: 88 11 00 0d or %g4, %o5, %g4
elength = rtems_rfs_dir_entry_length (entry);
4001e25c: ae 10 40 0f or %g1, %o7, %l7
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
4001e260: 80 a5 c0 12 cmp %l7, %l2
4001e264: 02 80 00 25 be 4001e2f8 <rtems_rfs_dir_lookup_ino+0x310>
4001e268: 86 11 00 03 or %g4, %g3, %g3
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
4001e26c: 80 a5 e0 0a cmp %l7, 0xa
4001e270: 24 80 00 34 ble,a 4001e340 <rtems_rfs_dir_lookup_ino+0x358><== NEVER TAKEN
4001e274: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e278: de 04 60 1c ld [ %l1 + 0x1c ], %o7
4001e27c: 80 a5 c0 0f cmp %l7, %o7
4001e280: 1a 80 00 2f bcc 4001e33c <rtems_rfs_dir_lookup_ino+0x354> <== NEVER TAKEN
4001e284: 80 a0 a0 00 cmp %g2, 0
4001e288: 22 80 00 2e be,a 4001e340 <rtems_rfs_dir_lookup_ino+0x358><== NEVER TAKEN
4001e28c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e290: c8 04 60 14 ld [ %l1 + 0x14 ], %g4
4001e294: 80 a0 80 04 cmp %g2, %g4
4001e298: 18 80 00 29 bgu 4001e33c <rtems_rfs_dir_lookup_ino+0x354> <== NEVER TAKEN
4001e29c: 80 a0 c0 13 cmp %g3, %l3
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
4001e2a0: 12 bf ff d2 bne 4001e1e8 <rtems_rfs_dir_lookup_ino+0x200>
4001e2a4: c4 07 bf c4 ld [ %fp + -60 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
4001e2a8: 90 10 20 00 clr %o0
4001e2ac: 7f ff db 7e call 400150a4 <rtems_rfs_trace>
4001e2b0: 13 02 00 00 sethi %hi(0x8000000), %o1
4001e2b4: 80 8a 20 ff btst 0xff, %o0
4001e2b8: 32 80 00 32 bne,a 4001e380 <rtems_rfs_dir_lookup_ino+0x398><== NEVER TAKEN
4001e2bc: c8 0c 20 01 ldub [ %l0 + 1 ], %g4 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
4001e2c0: 90 04 20 0a add %l0, 0xa, %o0
4001e2c4: 92 10 00 1a mov %i2, %o1
4001e2c8: 40 00 1a 76 call 40024ca0 <memcmp>
4001e2cc: 94 10 00 1b mov %i3, %o2
4001e2d0: 80 a2 20 00 cmp %o0, 0
4001e2d4: 02 80 00 5d be 4001e448 <rtems_rfs_dir_lookup_ino+0x460> <== ALWAYS TAKEN
4001e2d8: c4 07 bf c4 ld [ %fp + -60 ], %g2
4001e2dc: d8 04 60 08 ld [ %l1 + 8 ], %o4 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
4001e2e0: 84 05 c0 02 add %l7, %g2, %g2 <== NOT EXECUTED
4001e2e4: c4 27 bf c4 st %g2, [ %fp + -60 ] <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001e2e8: 86 03 3f f6 add %o4, -10, %g3 <== NOT EXECUTED
4001e2ec: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
4001e2f0: 18 bf ff c4 bgu 4001e200 <rtems_rfs_dir_lookup_ino+0x218> <== NOT EXECUTED
4001e2f4: a0 04 00 17 add %l0, %l7, %l0 <== NOT EXECUTED
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
4001e2f8: 80 a5 20 00 cmp %l4, 0
4001e2fc: 32 bf ff 90 bne,a 4001e13c <rtems_rfs_dir_lookup_ino+0x154><== NEVER TAKEN
4001e300: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001e304: 90 10 00 11 mov %l1, %o0
4001e308: 92 07 bf b0 add %fp, -80, %o1
4001e30c: 7f ff fa 8d call 4001cd40 <rtems_rfs_block_map_next_block>
4001e310: 94 07 bf a0 add %fp, -96, %o2
if ((rc > 0) && (rc != ENXIO))
4001e314: 80 a2 20 06 cmp %o0, 6
4001e318: 12 80 00 2f bne 4001e3d4 <rtems_rfs_dir_lookup_ino+0x3ec> <== NEVER TAKEN
4001e31c: b0 10 00 08 mov %o0, %i0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
4001e320: 80 a6 20 06 cmp %i0, 6
4001e324: 12 bf ff 98 bne 4001e184 <rtems_rfs_dir_lookup_ino+0x19c> <== NEVER TAKEN
4001e328: 80 a6 20 00 cmp %i0, 0
rc = ENOENT;
4001e32c: b0 10 20 02 mov 2, %i0
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
4001e330: a8 10 00 18 mov %i0, %l4
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
4001e334: 10 bf ff 82 b 4001e13c <rtems_rfs_dir_lookup_ino+0x154>
4001e338: b0 10 00 14 mov %l4, %i0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001e33c: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e340: 7f ff db 59 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001e344: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001e348: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e34c: 12 80 00 04 bne 4001e35c <rtems_rfs_dir_lookup_ino+0x374> <== NOT EXECUTED
4001e350: a8 10 20 05 mov 5, %l4 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
4001e354: 10 bf ff 7a b 4001e13c <rtems_rfs_dir_lookup_ino+0x154> <== NOT EXECUTED
4001e358: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
4001e35c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001e360: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
4001e364: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
4001e368: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED
4001e36c: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e370: 40 00 1b 83 call 4002517c <printf> <== NOT EXECUTED
4001e374: 90 12 21 80 or %o0, 0x180, %o0 ! 40038580 <CSWTCH.2+0x790><== NOT EXECUTED
4001e378: 10 bf ff 71 b 4001e13c <rtems_rfs_dir_lookup_ino+0x154> <== NOT EXECUTED
4001e37c: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
4001e380: c4 0c 20 02 ldub [ %l0 + 2 ], %g2 <== NOT EXECUTED
4001e384: da 0c 00 00 ldub [ %l0 ], %o5 <== NOT EXECUTED
4001e388: c6 0c 20 03 ldub [ %l0 + 3 ], %g3 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
4001e38c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001e390: 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));
4001e394: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
4001e398: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
4001e39c: 9b 2b 60 18 sll %o5, 0x18, %o5 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
4001e3a0: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
4001e3a4: 9a 13 40 04 or %o5, %g4, %o5 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
4001e3a8: 98 10 00 17 mov %l7, %o4 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
4001e3ac: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
4001e3b0: 40 00 1b 73 call 4002517c <printf> <== NOT EXECUTED
4001e3b4: 9a 13 40 02 or %o5, %g2, %o5 <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
4001e3b8: 10 bf ff c3 b 4001e2c4 <rtems_rfs_dir_lookup_ino+0x2dc> <== NOT EXECUTED
4001e3bc: 90 04 20 0a add %l0, 0xa, %o0 <== NOT EXECUTED
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
4001e3c0: d4 07 bf c0 ld [ %fp + -64 ], %o2 <== NOT EXECUTED
4001e3c4: 40 00 1b 6e call 4002517c <printf> <== NOT EXECUTED
4001e3c8: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
4001e3cc: 10 bf ff 79 b 4001e1b0 <rtems_rfs_dir_lookup_ino+0x1c8> <== NOT EXECUTED
4001e3d0: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if ((rc > 0) && (rc != ENXIO))
4001e3d4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001e3d8: 04 bf ff d3 ble 4001e324 <rtems_rfs_dir_lookup_ino+0x33c> <== NOT EXECUTED
4001e3dc: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001e3e0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e3e4: 7f ff db 30 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001e3e8: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001e3ec: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e3f0: 22 bf ff cd be,a 4001e324 <rtems_rfs_dir_lookup_ino+0x33c><== NOT EXECUTED
4001e3f4: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
4001e3f8: e0 06 60 08 ld [ %i1 + 8 ], %l0 <== NOT EXECUTED
4001e3fc: 40 00 1f aa call 400262a4 <strerror> <== NOT EXECUTED
4001e400: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001e404: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4001e408: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001e40c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
4001e410: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e414: 40 00 1b 5a call 4002517c <printf> <== NOT EXECUTED
4001e418: 90 12 22 78 or %o0, 0x278, %o0 ! 40038678 <CSWTCH.2+0x888><== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
4001e41c: 10 bf ff 5a b 4001e184 <rtems_rfs_dir_lookup_ino+0x19c> <== NOT EXECUTED
4001e420: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
4001e424: 40 00 1f a0 call 400262a4 <strerror> <== NOT EXECUTED
4001e428: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001e42c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001e430: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001e434: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e438: 40 00 1b 51 call 4002517c <printf> <== NOT EXECUTED
4001e43c: 90 12 20 c0 or %o0, 0xc0, %o0 ! 400384c0 <CSWTCH.2+0x6d0> <== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
4001e440: 10 bf ff 3d b 4001e134 <rtems_rfs_dir_lookup_ino+0x14c> <== NOT EXECUTED
4001e444: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
{
*offset = rtems_rfs_block_map_pos (fs, &map);
4001e448: 90 10 00 11 mov %l1, %o0
4001e44c: 7f ff f8 bc call 4001c73c <rtems_rfs_block_get_pos>
4001e450: 92 07 bf c0 add %fp, -64, %o1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001e454: 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);
4001e458: d2 27 40 00 st %o1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001e45c: 7f ff db 12 call 400150a4 <rtems_rfs_trace>
4001e460: 13 04 00 00 sethi %hi(0x10000000), %o1
4001e464: 80 8a 20 ff btst 0xff, %o0
4001e468: 22 bf ff 36 be,a 4001e140 <rtems_rfs_dir_lookup_ino+0x158><== ALWAYS TAKEN
4001e46c: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-lookup-ino: "
4001e470: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001e474: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
4001e478: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
4001e47c: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e480: 40 00 1b 3f call 4002517c <printf> <== NOT EXECUTED
4001e484: 90 12 22 30 or %o0, 0x230, %o0 ! 40038630 <CSWTCH.2+0x840><== 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);
4001e488: 10 bf ff 2e b 4001e140 <rtems_rfs_dir_lookup_ino+0x158> <== NOT EXECUTED
4001e48c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001e490: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001e494: 7f ff db 04 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001e498: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001e49c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e4a0: 22 bf ff 27 be,a 4001e13c <rtems_rfs_dir_lookup_ino+0x154><== NOT EXECUTED
4001e4a4: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
4001e4a8: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
4001e4ac: fa 07 bf a0 ld [ %fp + -96 ], %i5 <== NOT EXECUTED
4001e4b0: 40 00 1f 7d call 400262a4 <strerror> <== NOT EXECUTED
4001e4b4: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
4001e4b8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001e4bc: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001e4c0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001e4c4: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
4001e4c8: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
4001e4cc: 40 00 1b 2c call 4002517c <printf> <== NOT EXECUTED
4001e4d0: 90 12 21 38 or %o0, 0x138, %o0 <== NOT EXECUTED
4001e4d4: 10 bf ff 1a b 4001e13c <rtems_rfs_dir_lookup_ino+0x154> <== NOT EXECUTED
4001e4d8: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
4001e4dc: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
4001e4e0: 7f ff da f1 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001e4e4: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001e4e8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001e4ec: 22 bf ff 15 be,a 4001e140 <rtems_rfs_dir_lookup_ino+0x158><== NOT EXECUTED
4001e4f0: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
4001e4f4: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
4001e4f8: 40 00 1f 6b call 400262a4 <strerror> <== NOT EXECUTED
4001e4fc: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
4001e500: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4001e504: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001e508: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED
4001e50c: 11 10 00 e1 sethi %hi(0x40038400), %o0 <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
4001e510: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
4001e514: 40 00 1b 1a call 4002517c <printf> <== NOT EXECUTED
4001e518: 90 12 22 c8 or %o0, 0x2c8, %o0 <== NOT EXECUTED
4001e51c: 10 bf ff 09 b 4001e140 <rtems_rfs_dir_lookup_ino+0x158> <== NOT EXECUTED
4001e520: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001eda0 <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)
{
4001eda0: 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))
4001eda4: 90 10 20 00 clr %o0
4001eda8: 7f ff d8 bf call 400150a4 <rtems_rfs_trace>
4001edac: 13 20 00 00 sethi %hi(0x80000000), %o1
4001edb0: 80 8a 20 ff btst 0xff, %o0
4001edb4: 32 80 00 27 bne,a 4001ee50 <rtems_rfs_dir_read+0xb0> <== NEVER TAKEN
4001edb8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
rtems_rfs_inode_ino (dir), offset);
*length = 0;
4001edbc: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, dir, &map);
4001edc0: 90 10 00 18 mov %i0, %o0
4001edc4: 92 10 00 19 mov %i1, %o1
4001edc8: 7f ff f6 92 call 4001c810 <rtems_rfs_block_map_open>
4001edcc: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
4001edd0: a0 92 20 00 orcc %o0, 0, %l0
4001edd4: 24 80 00 04 ble,a 4001ede4 <rtems_rfs_dir_read+0x44> <== ALWAYS TAKEN
4001edd8: e0 06 20 08 ld [ %i0 + 8 ], %l0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001eddc: 81 c7 e0 08 ret
4001ede0: 91 e8 00 10 restore %g0, %l0, %o0
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
4001ede4: 90 10 00 1a mov %i2, %o0
4001ede8: a2 10 00 10 mov %l0, %l1
4001edec: 92 10 00 1b mov %i3, %o1
4001edf0: a0 10 20 00 clr %l0
4001edf4: 96 10 00 11 mov %l1, %o3
4001edf8: 40 00 4c 40 call 40031ef8 <__moddi3>
4001edfc: 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) -
4001ee00: 92 a4 40 09 subcc %l1, %o1, %o1
4001ee04: 90 64 00 08 subx %l0, %o0, %o0
4001ee08: 80 a2 20 00 cmp %o0, 0
4001ee0c: 04 80 00 18 ble 4001ee6c <rtems_rfs_dir_read+0xcc> <== ALWAYS TAKEN
4001ee10: 01 00 00 00 nop
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
4001ee14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001ee18: 92 07 bf b0 add %fp, -80, %o1
4001ee1c: 94 10 00 1a mov %i2, %o2
4001ee20: 96 10 00 1b mov %i3, %o3
4001ee24: 7f ff f7 aa call 4001cccc <rtems_rfs_block_map_seek>
4001ee28: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
4001ee2c: a0 92 20 00 orcc %o0, 0, %l0
4001ee30: 04 80 00 25 ble 4001eec4 <rtems_rfs_dir_read+0x124> <== ALWAYS TAKEN
4001ee34: 80 a4 20 06 cmp %l0, 6
{
if (rc == ENXIO)
4001ee38: 02 80 00 1f be 4001eeb4 <rtems_rfs_dir_read+0x114> <== NOT EXECUTED
4001ee3c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
4001ee40: 7f ff f6 d5 call 4001c994 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001ee44: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
4001ee48: 81 c7 e0 08 ret <== NOT EXECUTED
4001ee4c: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
4001ee50: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001ee54: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001ee58: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4001ee5c: 40 00 18 c8 call 4002517c <printf> <== NOT EXECUTED
4001ee60: 90 12 21 e8 or %o0, 0x1e8, %o0 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), offset);
*length = 0;
4001ee64: 10 bf ff d7 b 4001edc0 <rtems_rfs_dir_read+0x20> <== NOT EXECUTED
4001ee68: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
4001ee6c: 32 80 00 06 bne,a 4001ee84 <rtems_rfs_dir_read+0xe4> <== NEVER TAKEN
4001ee70: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4001ee74: 80 a2 60 0a cmp %o1, 0xa
4001ee78: 38 bf ff e8 bgu,a 4001ee18 <rtems_rfs_dir_read+0x78> <== ALWAYS TAKEN
4001ee7c: 90 10 00 18 mov %i0, %o0
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
4001ee80: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4001ee84: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001ee88: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
4001ee8c: 40 00 4b 30 call 40031b4c <__divdi3> <== NOT EXECUTED
4001ee90: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
4001ee94: 96 82 60 01 addcc %o1, 1, %o3 <== NOT EXECUTED
4001ee98: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4001ee9c: 94 42 20 00 addx %o0, 0, %o2 <== NOT EXECUTED
4001eea0: 40 00 4a f9 call 40031a84 <__muldi3> <== NOT EXECUTED
4001eea4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001eea8: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
4001eeac: 10 bf ff da b 4001ee14 <rtems_rfs_dir_read+0x74> <== NOT EXECUTED
4001eeb0: b6 10 00 09 mov %o1, %i3 <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
if (rc > 0)
{
if (rc == ENXIO)
rc = ENOENT;
4001eeb4: a0 10 20 02 mov 2, %l0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
4001eeb8: 7f ff f6 b7 call 4001c994 <rtems_rfs_block_map_close> <== NOT EXECUTED
4001eebc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001eec0: 30 bf ff e2 b,a 4001ee48 <rtems_rfs_dir_read+0xa8> <== NOT EXECUTED
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
4001eec4: 29 00 00 3f sethi %hi(0xfc00), %l4
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001eec8: 2b 10 00 e2 sethi %hi(0x40038800), %l5
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4001eecc: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001eed0: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001eed4: 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)
4001eed8: a8 15 23 ff or %l4, 0x3ff, %l4
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001eedc: aa 15 62 98 or %l5, 0x298, %l5
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
4001eee0: d4 07 bf a0 ld [ %fp + -96 ], %o2
4001eee4: 96 10 20 01 mov 1, %o3
4001eee8: 92 07 bf a4 add %fp, -92, %o1
4001eeec: 7f ff fa 4d call 4001d820 <rtems_rfs_buffer_handle_request>
4001eef0: 90 10 00 18 mov %i0, %o0
if (rc > 0)
4001eef4: a0 92 20 00 orcc %o0, 0, %l0
4001eef8: 14 80 00 32 bg 4001efc0 <rtems_rfs_dir_read+0x220> <== NEVER TAKEN
4001eefc: c2 07 bf ac ld [ %fp + -84 ], %g1
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
4001ef00: e4 07 bf c4 ld [ %fp + -60 ], %l2
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
4001ef04: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001ef08: 90 10 20 00 clr %o0
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
4001ef0c: a2 00 40 12 add %g1, %l2, %l1
elength = rtems_rfs_dir_entry_length (entry);
4001ef10: c4 0c 60 09 ldub [ %l1 + 9 ], %g2
4001ef14: e6 0c 60 08 ldub [ %l1 + 8 ], %l3
eino = rtems_rfs_dir_entry_ino (entry);
4001ef18: c8 08 40 12 ldub [ %g1 + %l2 ], %g4
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
4001ef1c: a7 2c e0 08 sll %l3, 8, %l3
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001ef20: 13 20 00 00 sethi %hi(0x80000000), %o1
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
4001ef24: a6 14 c0 02 or %l3, %g2, %l3
eino = rtems_rfs_dir_entry_ino (entry);
4001ef28: c6 0c 60 01 ldub [ %l1 + 1 ], %g3
4001ef2c: c2 0c 60 02 ldub [ %l1 + 2 ], %g1
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
4001ef30: 80 a4 c0 14 cmp %l3, %l4
4001ef34: 12 80 00 2d bne 4001efe8 <rtems_rfs_dir_read+0x248>
4001ef38: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
4001ef3c: c4 06 20 08 ld [ %i0 + 8 ], %g2
4001ef40: c2 07 40 00 ld [ %i5 ], %g1
4001ef44: a4 20 80 12 sub %g2, %l2, %l2
4001ef48: a4 00 40 12 add %g1, %l2, %l2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001ef4c: 7f ff d8 56 call 400150a4 <rtems_rfs_trace>
4001ef50: e4 27 40 00 st %l2, [ %i5 ]
4001ef54: 80 8a 20 ff btst 0xff, %o0
4001ef58: 12 80 00 0d bne 4001ef8c <rtems_rfs_dir_read+0x1ec> <== NEVER TAKEN
4001ef5c: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001ef60: 92 07 bf b0 add %fp, -80, %o1
4001ef64: 7f ff f7 77 call 4001cd40 <rtems_rfs_block_map_next_block>
4001ef68: 94 07 bf a0 add %fp, -96, %o2
if (rc == ENXIO)
4001ef6c: 80 a2 20 06 cmp %o0, 6
4001ef70: 02 80 00 13 be 4001efbc <rtems_rfs_dir_read+0x21c> <== ALWAYS TAKEN
4001ef74: 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)
4001ef78: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001ef7c: 02 bf ff da be 4001eee4 <rtems_rfs_dir_read+0x144> <== NOT EXECUTED
4001ef80: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4001ef84: 10 80 00 10 b 4001efc4 <rtems_rfs_dir_read+0x224> <== NOT EXECUTED
4001ef88: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
4001ef8c: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
4001ef90: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
4001ef94: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4001ef98: 40 00 18 79 call 4002517c <printf> <== NOT EXECUTED
4001ef9c: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
4001efa0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001efa4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
4001efa8: 7f ff f7 66 call 4001cd40 <rtems_rfs_block_map_next_block><== NOT EXECUTED
4001efac: 94 07 bf a0 add %fp, -96, %o2 <== NOT EXECUTED
if (rc == ENXIO)
4001efb0: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED
4001efb4: 12 bf ff f1 bne 4001ef78 <rtems_rfs_dir_read+0x1d8> <== NOT EXECUTED
4001efb8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
rc = ENOENT;
4001efbc: a0 10 20 02 mov 2, %l0
4001efc0: 92 07 bf a4 add %fp, -92, %o1
4001efc4: 7f ff f9 9d call 4001d638 <rtems_rfs_buffer_handle_release>
4001efc8: 90 10 00 18 mov %i0, %o0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
4001efcc: 90 10 00 18 mov %i0, %o0
handle->dirty = false;
4001efd0: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
4001efd4: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
4001efd8: c0 27 bf ac clr [ %fp + -84 ]
4001efdc: 7f ff f6 6e call 4001c994 <rtems_rfs_block_map_close>
4001efe0: 92 07 bf b0 add %fp, -80, %o1
4001efe4: 30 bf ff 7e b,a 4001eddc <rtems_rfs_dir_read+0x3c>
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
4001efe8: 89 29 20 18 sll %g4, 0x18, %g4
4001efec: 86 08 e0 ff and %g3, 0xff, %g3
4001eff0: 84 08 a0 ff and %g2, 0xff, %g2
4001eff4: 87 28 e0 10 sll %g3, 0x10, %g3
4001eff8: 82 08 60 ff and %g1, 0xff, %g1
4001effc: 88 11 00 03 or %g4, %g3, %g4
4001f000: 83 28 60 08 sll %g1, 8, %g1
4001f004: 84 11 00 02 or %g4, %g2, %g2
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
4001f008: 80 a4 e0 0a cmp %l3, 0xa
4001f00c: 04 80 00 0d ble 4001f040 <rtems_rfs_dir_read+0x2a0> <== NEVER TAKEN
4001f010: a8 10 80 01 or %g2, %g1, %l4
4001f014: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4001f018: 80 a4 c0 01 cmp %l3, %g1
4001f01c: 1a 80 00 0a bcc 4001f044 <rtems_rfs_dir_read+0x2a4> <== NEVER TAKEN
4001f020: 90 10 20 00 clr %o0
4001f024: 80 a5 20 00 cmp %l4, 0
4001f028: 02 80 00 08 be 4001f048 <rtems_rfs_dir_read+0x2a8> <== NEVER TAKEN
4001f02c: 13 20 00 00 sethi %hi(0x80000000), %o1
4001f030: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4001f034: 80 a5 00 01 cmp %l4, %g1
4001f038: 08 80 00 12 bleu 4001f080 <rtems_rfs_dir_read+0x2e0> <== ALWAYS TAKEN
4001f03c: 90 10 00 1c mov %i4, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001f040: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001f044: 13 20 00 00 sethi %hi(0x80000000), %o1 <== NOT EXECUTED
4001f048: 7f ff d8 17 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001f04c: a0 10 20 05 mov 5, %l0 <== NOT EXECUTED
4001f050: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f054: 22 bf ff dc be,a 4001efc4 <rtems_rfs_dir_read+0x224> <== NOT EXECUTED
4001f058: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
4001f05c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
4001f060: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
4001f064: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
4001f068: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001f06c: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
4001f070: 40 00 18 43 call 4002517c <printf> <== NOT EXECUTED
4001f074: 90 12 22 18 or %o0, 0x218, %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);
4001f078: 10 bf ff d3 b 4001efc4 <rtems_rfs_dir_read+0x224> <== NOT EXECUTED
4001f07c: 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));
4001f080: 92 10 20 00 clr %o1
4001f084: 40 00 17 c0 call 40024f84 <memset>
4001f088: 94 10 21 18 mov 0x118, %o2
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
4001f08c: c2 07 40 00 ld [ %i5 ], %g1
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
4001f090: 84 10 21 18 mov 0x118, %g2
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
4001f094: f4 3f 20 08 std %i2, [ %i4 + 8 ]
dirent->d_reclen = sizeof (struct dirent);
4001f098: c4 37 20 10 sth %g2, [ %i4 + 0x10 ]
*length += elength;
4001f09c: 82 04 c0 01 add %l3, %g1, %g1
4001f0a0: c2 27 40 00 st %g1, [ %i5 ]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
4001f0a4: c4 06 20 08 ld [ %i0 + 8 ], %g2
4001f0a8: 84 20 80 12 sub %g2, %l2, %g2
4001f0ac: 84 20 80 13 sub %g2, %l3, %g2
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
4001f0b0: 80 a0 a0 0a cmp %g2, 0xa
4001f0b4: 14 80 00 04 bg 4001f0c4 <rtems_rfs_dir_read+0x324> <== ALWAYS TAKEN
4001f0b8: a6 04 ff f6 add %l3, -10, %l3
*length += remaining;
4001f0bc: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
4001f0c0: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED
4001f0c4: 80 a4 e0 ff cmp %l3, 0xff
4001f0c8: 34 80 00 02 bg,a 4001f0d0 <rtems_rfs_dir_read+0x330> <== NEVER TAKEN
4001f0cc: a6 10 20 ff mov 0xff, %l3 <== NOT EXECUTED
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
4001f0d0: 92 04 60 0a add %l1, 0xa, %o1
4001f0d4: 94 10 00 13 mov %l3, %o2
4001f0d8: ba 07 20 14 add %i4, 0x14, %i5
4001f0dc: 40 00 17 1b call 40024d48 <memcpy>
4001f0e0: 90 10 00 1d mov %i5, %o0
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
4001f0e4: c8 0c 40 00 ldub [ %l1 ], %g4
4001f0e8: c6 0c 60 01 ldub [ %l1 + 1 ], %g3
4001f0ec: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
4001f0f0: c2 0c 60 02 ldub [ %l1 + 2 ], %g1
4001f0f4: 89 29 20 18 sll %g4, 0x18, %g4
4001f0f8: 87 28 e0 10 sll %g3, 0x10, %g3
4001f0fc: 83 28 60 08 sll %g1, 8, %g1
4001f100: 86 11 00 03 or %g4, %g3, %g3
4001f104: 84 10 c0 02 or %g3, %g2, %g2
4001f108: 82 10 80 01 or %g2, %g1, %g1
dirent->d_namlen = elength;
4001f10c: e6 37 20 12 sth %l3, [ %i4 + 0x12 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
4001f110: 90 10 20 00 clr %o0
4001f114: 13 20 00 00 sethi %hi(0x80000000), %o1
4001f118: 7f ff d7 e3 call 400150a4 <rtems_rfs_trace>
4001f11c: c2 27 00 00 st %g1, [ %i4 ]
4001f120: 80 8a 20 ff btst 0xff, %o0
4001f124: 22 bf ff a8 be,a 4001efc4 <rtems_rfs_dir_read+0x224> <== ALWAYS TAKEN
4001f128: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
4001f12c: c4 1f 20 08 ldd [ %i4 + 8 ], %g2 <== NOT EXECUTED
4001f130: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
4001f134: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
4001f138: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
4001f13c: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001f140: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
4001f144: 40 00 18 0e call 4002517c <printf> <== NOT EXECUTED
4001f148: 90 12 22 60 or %o0, 0x260, %o0 <== NOT EXECUTED
4001f14c: 10 bf ff 9e b 4001efc4 <rtems_rfs_dir_read+0x224> <== NOT EXECUTED
4001f150: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
4001f724 <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
4001f724: 9d e3 bf a0 save %sp, -96, %sp
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001f728: 90 10 20 10 mov 0x10, %o0
4001f72c: 92 10 20 00 clr %o1
4001f730: 7f ff d6 5d call 400150a4 <rtems_rfs_trace>
4001f734: ba 10 00 18 mov %i0, %i5
4001f738: 80 8a 20 ff btst 0xff, %o0
4001f73c: 32 80 00 87 bne,a 4001f958 <rtems_rfs_file_close+0x234> <== NEVER TAKEN
4001f740: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
if (handle->shared->references > 0)
4001f744: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001f748: c2 02 60 08 ld [ %o1 + 8 ], %g1
4001f74c: 80 a0 60 00 cmp %g1, 0
4001f750: 04 80 00 04 ble 4001f760 <rtems_rfs_file_close+0x3c> <== NEVER TAKEN
4001f754: 82 00 7f ff add %g1, -1, %g1
handle->shared->references--;
4001f758: c2 22 60 08 st %g1, [ %o1 + 8 ]
if (handle->shared->references == 0)
4001f75c: 80 a0 60 00 cmp %g1, 0
4001f760: 12 80 00 74 bne 4001f930 <rtems_rfs_file_close+0x20c> <== NEVER TAKEN
4001f764: 90 10 00 1d mov %i5, %o0
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
4001f768: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
4001f76c: 80 a0 60 00 cmp %g1, 0
4001f770: 22 80 00 a7 be,a 4001fa0c <rtems_rfs_file_close+0x2e8> <== ALWAYS TAKEN
4001f774: 92 02 60 0c add %o1, 0xc, %o1
if (rrc == 0)
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
4001f778: c4 02 60 8c ld [ %o1 + 0x8c ], %g2
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001f77c: 86 10 20 01 mov 1, %g3
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
4001f780: 89 30 a0 18 srl %g2, 0x18, %g4
4001f784: c8 28 60 10 stb %g4, [ %g1 + 0x10 ]
4001f788: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
4001f78c: 89 30 a0 10 srl %g2, 0x10, %g4
4001f790: c8 28 60 11 stb %g4, [ %g1 + 0x11 ]
4001f794: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
4001f798: 89 30 a0 08 srl %g2, 8, %g4
4001f79c: c8 28 60 12 stb %g4, [ %g1 + 0x12 ]
4001f7a0: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
4001f7a4: c4 28 60 13 stb %g2, [ %g1 + 0x13 ]
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
4001f7a8: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001f7ac: c6 2a 60 1c stb %g3, [ %o1 + 0x1c ]
4001f7b0: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4001f7b4: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
4001f7b8: b9 30 60 18 srl %g1, 0x18, %i4
4001f7bc: f8 29 20 14 stb %i4, [ %g4 + 0x14 ]
4001f7c0: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
4001f7c4: b9 30 60 10 srl %g1, 0x10, %i4
4001f7c8: f8 29 20 15 stb %i4, [ %g4 + 0x15 ]
4001f7cc: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
4001f7d0: b9 30 60 08 srl %g1, 8, %i4
4001f7d4: f8 29 20 16 stb %i4, [ %g4 + 0x16 ]
4001f7d8: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
4001f7dc: c2 29 20 17 stb %g1, [ %g4 + 0x17 ]
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
4001f7e0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001f7e4: c6 28 a0 1c stb %g3, [ %g2 + 0x1c ]
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
4001f7e8: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001f7ec: c4 00 60 94 ld [ %g1 + 0x94 ], %g2
4001f7f0: b9 30 a0 18 srl %g2, 0x18, %i4
4001f7f4: f8 29 20 18 stb %i4, [ %g4 + 0x18 ]
4001f7f8: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001f7fc: b9 30 a0 10 srl %g2, 0x10, %i4
4001f800: f8 29 20 19 stb %i4, [ %g4 + 0x19 ]
4001f804: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001f808: b9 30 a0 08 srl %g2, 8, %i4
4001f80c: f8 29 20 1a stb %i4, [ %g4 + 0x1a ]
4001f810: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
4001f814: c4 29 20 1b stb %g2, [ %g4 + 0x1b ]
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
4001f818: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001f81c: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
4001f820: c4 02 60 3c ld [ %o1 + 0x3c ], %g2
4001f824: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
4001f828: 80 a0 40 02 cmp %g1, %g2
4001f82c: 02 80 00 72 be 4001f9f4 <rtems_rfs_file_close+0x2d0> <== ALWAYS TAKEN
4001f830: c4 02 60 88 ld [ %o1 + 0x88 ], %g2
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
4001f834: c2 22 60 3c st %g1, [ %o1 + 0x3c ] <== NOT EXECUTED
4001f838: c4 22 60 40 st %g2, [ %o1 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
4001f83c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4001f840: b0 10 20 00 clr %i0 <== NOT EXECUTED
4001f844: c2 2a 60 34 stb %g1, [ %o1 + 0x34 ] <== NOT EXECUTED
&handle->shared->map.size))
rtems_rfs_block_map_set_size (&handle->shared->map,
&handle->shared->size);
}
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
4001f848: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f84c: 7f ff f4 52 call 4001c994 <rtems_rfs_block_map_close>
4001f850: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
4001f854: b8 92 20 00 orcc %o0, 0, %i4
4001f858: 04 80 00 0a ble 4001f880 <rtems_rfs_file_close+0x15c> <== ALWAYS TAKEN
4001f85c: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001f860: 7f ff d6 11 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001f864: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001f868: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f86c: 32 80 00 57 bne,a 4001f9c8 <rtems_rfs_file_close+0x2a4> <== NOT EXECUTED
4001f870: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
4001f874: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001f878: 22 80 00 02 be,a 4001f880 <rtems_rfs_file_close+0x15c> <== NOT EXECUTED
4001f87c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
4001f880: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
4001f884: 90 10 00 1d mov %i5, %o0
4001f888: 7f ff cf d8 call 400137e8 <rtems_rfs_inode_close>
4001f88c: 92 02 60 0c add %o1, 0xc, %o1
if (rc > 0)
4001f890: b8 92 20 00 orcc %o0, 0, %i4
4001f894: 04 80 00 0a ble 4001f8bc <rtems_rfs_file_close+0x198> <== ALWAYS TAKEN
4001f898: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001f89c: 7f ff d6 02 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001f8a0: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001f8a4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f8a8: 32 80 00 3d bne,a 4001f99c <rtems_rfs_file_close+0x278> <== NOT EXECUTED
4001f8ac: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
4001f8b0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001f8b4: 22 80 00 2f be,a 4001f970 <rtems_rfs_file_close+0x24c> <== NOT EXECUTED
4001f8b8: d0 06 60 1c ld [ %i1 + 0x1c ], %o0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
4001f8bc: 7f ff ea e8 call 4001a45c <_Chain_Extract>
4001f8c0: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
4001f8c4: 7f ff a6 19 call 40009128 <free>
4001f8c8: 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);
4001f8cc: 90 10 00 1d mov %i5, %o0
4001f8d0: 7f ff f7 5a call 4001d638 <rtems_rfs_buffer_handle_release>
4001f8d4: 92 06 60 04 add %i1, 4, %o1
handle->dirty = false;
4001f8d8: c0 2e 60 04 clrb [ %i1 + 4 ]
handle->bnum = 0;
4001f8dc: 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)
4001f8e0: 80 a6 20 00 cmp %i0, 0
4001f8e4: 04 80 00 19 ble 4001f948 <rtems_rfs_file_close+0x224> <== ALWAYS TAKEN
4001f8e8: c0 26 60 0c clr [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
4001f8ec: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED
4001f8f0: 7f ff d5 ed call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001f8f4: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001f8f8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f8fc: 02 80 00 13 be 4001f948 <rtems_rfs_file_close+0x224> <== NOT EXECUTED
4001f900: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
4001f904: 40 00 1a 68 call 400262a4 <strerror> <== NOT EXECUTED
4001f908: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001f90c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001f910: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001f914: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
4001f918: 40 00 16 19 call 4002517c <printf> <== NOT EXECUTED
4001f91c: 90 12 20 c8 or %o0, 0xc8, %o0 ! 40038cc8 <CSWTCH.2+0xed8> <== NOT EXECUTED
}
free (handle);
4001f920: 7f ff a6 02 call 40009128 <free> <== NOT EXECUTED
4001f924: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
4001f928: 81 c7 e0 08 ret <== NOT EXECUTED
4001f92c: 81 e8 00 00 restore <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4001f930: 92 06 60 04 add %i1, 4, %o1 <== NOT EXECUTED
4001f934: 7f ff f7 41 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f938: b0 10 20 00 clr %i0 <== NOT EXECUTED
handle->dirty = false;
4001f93c: c0 2e 60 04 clrb [ %i1 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
4001f940: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
handle->buffer = NULL;
4001f944: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
4001f948: 7f ff a5 f8 call 40009128 <free>
4001f94c: 90 10 00 19 mov %i1, %o0
4001f950: 81 c7 e0 08 ret
4001f954: 81 e8 00 00 restore
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
4001f958: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
4001f95c: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED
4001f960: 40 00 16 07 call 4002517c <printf> <== NOT EXECUTED
4001f964: 90 12 20 20 or %o0, 0x20, %o0 <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
4001f968: 10 bf ff 78 b 4001f748 <rtems_rfs_file_close+0x24> <== NOT EXECUTED
4001f96c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED
4001f970: 7f ff ea bb call 4001a45c <_Chain_Extract> <== NOT EXECUTED
4001f974: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
if (rrc == 0)
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
4001f978: 7f ff a5 ec call 40009128 <free> <== NOT EXECUTED
4001f97c: d0 06 60 1c ld [ %i1 + 0x1c ], %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4001f980: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4001f984: 7f ff f7 2d call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f988: 92 06 60 04 add %i1, 4, %o1 <== NOT EXECUTED
handle->dirty = false;
4001f98c: c0 2e 60 04 clrb [ %i1 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
4001f990: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
handle->buffer = NULL;
4001f994: 10 bf ff d6 b 4001f8ec <rtems_rfs_file_close+0x1c8> <== NOT EXECUTED
4001f998: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
4001f99c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001f9a0: 40 00 1a 41 call 400262a4 <strerror> <== NOT EXECUTED
4001f9a4: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
4001f9a8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001f9ac: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001f9b0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001f9b4: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
4001f9b8: 40 00 15 f1 call 4002517c <printf> <== NOT EXECUTED
4001f9bc: 90 12 20 88 or %o0, 0x88, %o0 ! 40038c88 <CSWTCH.2+0xe98> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
4001f9c0: 10 bf ff bd b 4001f8b4 <rtems_rfs_file_close+0x190> <== NOT EXECUTED
4001f9c4: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
4001f9c8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001f9cc: 40 00 1a 36 call 400262a4 <strerror> <== NOT EXECUTED
4001f9d0: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
4001f9d4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4001f9d8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001f9dc: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001f9e0: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
4001f9e4: 40 00 15 e6 call 4002517c <printf> <== NOT EXECUTED
4001f9e8: 90 12 20 48 or %o0, 0x48, %o0 ! 40038c48 <CSWTCH.2+0xe58> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
4001f9ec: 10 bf ff a3 b 4001f878 <rtems_rfs_file_close+0x154> <== NOT EXECUTED
4001f9f0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
4001f9f4: c6 02 60 40 ld [ %o1 + 0x40 ], %g3
4001f9f8: 80 a0 80 03 cmp %g2, %g3
4001f9fc: 12 bf ff 8e bne 4001f834 <rtems_rfs_file_close+0x110> <== NEVER TAKEN
4001fa00: b0 10 20 00 clr %i0
&handle->shared->map.size))
rtems_rfs_block_map_set_size (&handle->shared->map,
&handle->shared->size);
}
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
4001fa04: 10 bf ff 92 b 4001f84c <rtems_rfs_file_close+0x128>
4001fa08: 90 10 00 1d mov %i5, %o0
handle->shared->references--;
if (handle->shared->references == 0)
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
4001fa0c: 7f ff ce d2 call 40013554 <rtems_rfs_inode_load>
4001fa10: 90 10 00 1d mov %i5, %o0
4001fa14: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
if (rrc == 0)
4001fa18: 80 a2 20 00 cmp %o0, 0
4001fa1c: 12 bf ff 8b bne 4001f848 <rtems_rfs_file_close+0x124> <== NEVER TAKEN
4001fa20: b0 10 00 08 mov %o0, %i0
4001fa24: 10 bf ff 55 b 4001f778 <rtems_rfs_file_close+0x54>
4001fa28: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
400203d4 <rtems_rfs_file_get_shared>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
400203d4: c2 02 20 74 ld [ %o0 + 0x74 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
400203d8: 90 02 20 78 add %o0, 0x78, %o0
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
400203dc: 80 a0 40 08 cmp %g1, %o0
400203e0: 32 80 00 08 bne,a 40020400 <rtems_rfs_file_get_shared+0x2c>
400203e4: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
400203e8: 81 c3 e0 08 retl
400203ec: 90 10 20 00 clr %o0
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
400203f0: 80 a0 40 08 cmp %g1, %o0
400203f4: 22 80 00 08 be,a 40020414 <rtems_rfs_file_get_shared+0x40><== ALWAYS TAKEN
400203f8: 90 10 20 00 clr %o0
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
400203fc: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED
40020400: 80 a0 80 09 cmp %g2, %o1
40020404: 32 bf ff fb bne,a 400203f0 <rtems_rfs_file_get_shared+0x1c>
40020408: c2 00 40 00 ld [ %g1 ], %g1
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
4002040c: 81 c3 e0 08 retl
40020410: 90 10 00 01 mov %g1, %o0
40020414: 81 c3 e0 08 retl
4001fc70 <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
4001fc70: 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))
4001fc74: 90 10 20 20 mov 0x20, %o0
4001fc78: 92 10 20 00 clr %o1
4001fc7c: 7f ff d5 0a call 400150a4 <rtems_rfs_trace>
4001fc80: ba 10 00 18 mov %i0, %i5
4001fc84: 80 8a 20 ff btst 0xff, %o0
4001fc88: 22 80 00 0c be,a 4001fcb8 <rtems_rfs_file_io_end+0x48> <== ALWAYS TAKEN
4001fc8c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
4001fc90: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001fc94: 12 80 00 22 bne 4001fd1c <rtems_rfs_file_io_end+0xac> <== NOT EXECUTED
4001fc98: 13 10 00 dd sethi %hi(0x40037400), %o1 <== NOT EXECUTED
4001fc9c: 13 10 00 e3 sethi %hi(0x40038c00), %o1 <== NOT EXECUTED
4001fca0: 92 12 60 f0 or %o1, 0xf0, %o1 ! 40038cf0 <CSWTCH.2+0xf00> <== NOT EXECUTED
4001fca4: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
4001fca8: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4001fcac: 40 00 15 34 call 4002517c <printf> <== NOT EXECUTED
4001fcb0: 90 12 21 b0 or %o0, 0x1b0, %o0 <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001fcb4: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
4001fcb8: 80 a0 60 00 cmp %g1, 0
4001fcbc: 02 80 00 1a be 4001fd24 <rtems_rfs_file_io_end+0xb4> <== NEVER TAKEN
4001fcc0: 80 a6 a0 00 cmp %i2, 0
{
if (!read)
4001fcc4: 12 80 00 8b bne 4001fef0 <rtems_rfs_file_io_end+0x280>
4001fcc8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001fccc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
{
if (!read)
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
4001fcd0: 82 10 20 01 mov 1, %g1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001fcd4: 92 07 60 04 add %i5, 4, %o1
4001fcd8: 7f ff f6 58 call 4001d638 <rtems_rfs_buffer_handle_release>
4001fcdc: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
rtems_rfs_file_buffer (handle));
if (rc > 0)
4001fce0: b0 92 20 00 orcc %o0, 0, %i0
4001fce4: 04 80 00 11 ble 4001fd28 <rtems_rfs_file_io_end+0xb8> <== ALWAYS TAKEN
4001fce8: 39 10 00 e3 sethi %hi(0x40038c00), %i4
{
printf (
4001fcec: b8 17 20 f0 or %i4, 0xf0, %i4 ! 40038cf0 <CSWTCH.2+0xf00> <== NOT EXECUTED
4001fcf0: 40 00 19 6d call 400262a4 <strerror> <== NOT EXECUTED
4001fcf4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001fcf8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001fcfc: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001fd00: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4001fd04: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
4001fd08: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
4001fd0c: 40 00 15 1c call 4002517c <printf> <== NOT EXECUTED
4001fd10: 90 12 21 d8 or %o0, 0x1d8, %o0 <== NOT EXECUTED
"rtems-rfs: file-io: end: error on release: %s size=%zu: %d: %s\n",
read ? "read" : "write", size, rc, strerror (rc));
return rc;
4001fd14: 81 c7 e0 08 ret <== NOT EXECUTED
4001fd18: 81 e8 00 00 restore <== NOT EXECUTED
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
4001fd1c: 10 bf ff e2 b 4001fca4 <rtems_rfs_file_io_end+0x34> <== NOT EXECUTED
4001fd20: 92 12 60 d0 or %o1, 0xd0, %o1 <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
4001fd24: b0 10 20 00 clr %i0 <== NOT EXECUTED
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001fd28: 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;
4001fd2c: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001fd30: c4 00 60 98 ld [ %g1 + 0x98 ], %g2
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
4001fd34: b2 06 40 03 add %i1, %g3, %i1
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001fd38: 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 >=
4001fd3c: 80 a6 40 02 cmp %i1, %g2
4001fd40: 0a 80 00 07 bcs 4001fd5c <rtems_rfs_file_io_end+0xec>
4001fd44: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
4001fd48: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001fd4c: 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++;
4001fd50: 86 00 e0 01 inc %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001fd54: 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++;
4001fd58: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
}
length = false;
mtime = false;
if (!read &&
4001fd5c: 80 a6 a0 00 cmp %i2, 0
4001fd60: 32 80 00 11 bne,a 4001fda4 <rtems_rfs_file_io_end+0x134>
4001fd64: f2 07 40 00 ld [ %i5 ], %i1
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001fd68: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
}
length = false;
mtime = false;
if (!read &&
4001fd6c: 80 a0 a0 00 cmp %g2, 0
4001fd70: 02 80 00 05 be 4001fd84 <rtems_rfs_file_io_end+0x114>
4001fd74: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001fd78: 80 a0 e0 00 cmp %g3, 0
4001fd7c: 22 80 00 25 be,a 4001fe10 <rtems_rfs_file_io_end+0x1a0> <== NEVER TAKEN
4001fd80: c6 07 60 14 ld [ %i5 + 0x14 ], %g3 <== NOT EXECUTED
4001fd84: 80 a0 c0 02 cmp %g3, %g2
4001fd88: 28 80 00 22 bleu,a 4001fe10 <rtems_rfs_file_io_end+0x1a0>
4001fd8c: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
4001fd90: 86 00 ff ff add %g3, -1, %g3
4001fd94: 80 a0 80 03 cmp %g2, %g3
4001fd98: 22 80 00 5f be,a 4001ff14 <rtems_rfs_file_io_end+0x2a4>
4001fd9c: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001fda0: f2 07 40 00 ld [ %i5 ], %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001fda4: b8 10 20 00 clr %i4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001fda8: b2 0e 60 01 and %i1, 1, %i1
4001fdac: b2 1e 60 01 xor %i1, 1, %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
length = rtems_rfs_file_update_length (handle) && length;
4001fdb0: b6 10 20 00 clr %i3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001fdb4: 90 10 20 20 mov 0x20, %o0
4001fdb8: 92 10 20 00 clr %o1
4001fdbc: 7f ff d4 ba call 400150a4 <rtems_rfs_trace>
4001fdc0: b2 0e 60 ff and %i1, 0xff, %i1
4001fdc4: 80 8a 20 ff btst 0xff, %o0
4001fdc8: 12 80 00 22 bne 4001fe50 <rtems_rfs_file_io_end+0x1e0> <== NEVER TAKEN
4001fdcc: 80 a0 00 19 cmp %g0, %i1
4001fdd0: b8 0f 20 ff and %i4, 0xff, %i4
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
handle->bpos.bno, handle->bpos.boff,
atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
if (atime || mtime)
4001fdd4: 80 a7 20 00 cmp %i4, 0
4001fdd8: 12 80 00 33 bne 4001fea4 <rtems_rfs_file_io_end+0x234>
4001fddc: b6 0e e0 ff and %i3, 0xff, %i3
4001fde0: 80 a6 60 00 cmp %i1, 0
4001fde4: 12 80 00 30 bne 4001fea4 <rtems_rfs_file_io_end+0x234> <== ALWAYS TAKEN
4001fde8: 80 a6 e0 00 cmp %i3, 0
if (read && atime)
handle->shared->atime = now;
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
4001fdec: 02 80 00 17 be 4001fe48 <rtems_rfs_file_io_end+0x1d8>
4001fdf0: 01 00 00 00 nop
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
4001fdf4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
4001fdf8: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
4001fdfc: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
4001fe00: c6 20 60 84 st %g3, [ %g1 + 0x84 ]
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
4001fe04: c4 20 60 88 st %g2, [ %g1 + 0x88 ]
4001fe08: 81 c7 e0 08 ret
4001fe0c: 81 e8 00 00 restore
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001fe10: c4 07 40 00 ld [ %i5 ], %g2
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
4001fe14: c6 20 60 40 st %g3, [ %g1 + 0x40 ]
map->dirty = true;
4001fe18: 86 10 20 01 mov 1, %g3
4001fe1c: c6 28 60 34 stb %g3, [ %g1 + 0x34 ]
4001fe20: b2 08 a0 01 and %g2, 1, %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001fe24: b9 30 a0 01 srl %g2, 1, %i4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001fe28: b2 1e 60 01 xor %i1, 1, %i1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
4001fe2c: b8 1f 20 01 xor %i4, 1, %i4
length = rtems_rfs_file_update_length (handle) && length;
4001fe30: b6 10 20 01 mov 1, %i3
4001fe34: 80 88 a0 04 btst 4, %g2
4001fe38: 02 bf ff df be 4001fdb4 <rtems_rfs_file_io_end+0x144> <== ALWAYS TAKEN
4001fe3c: b8 0f 20 01 and %i4, 1, %i4
4001fe40: 10 bf ff dd b 4001fdb4 <rtems_rfs_file_io_end+0x144> <== NOT EXECUTED
4001fe44: b6 10 20 00 clr %i3 <== NOT EXECUTED
handle->shared->size.offset =
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
4001fe48: 81 c7 e0 08 ret
4001fe4c: 81 e8 00 00 restore
atime = rtems_rfs_file_update_atime (handle);
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
length = rtems_rfs_file_update_length (handle) && length;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
4001fe50: b8 0f 20 ff and %i4, 0xff, %i4 <== NOT EXECUTED
4001fe54: 96 40 3f ff addx %g0, -1, %o3 <== NOT EXECUTED
4001fe58: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
4001fe5c: 80 a0 00 1c cmp %g0, %i4 <== NOT EXECUTED
4001fe60: d4 07 60 14 ld [ %i5 + 0x14 ], %o2 <== NOT EXECUTED
4001fe64: 98 40 3f ff addx %g0, -1, %o4 <== NOT EXECUTED
4001fe68: b6 0e e0 ff and %i3, 0xff, %i3 <== NOT EXECUTED
4001fe6c: 80 a0 00 1b cmp %g0, %i3 <== NOT EXECUTED
4001fe70: 96 0a ff ec and %o3, -20, %o3 <== NOT EXECUTED
4001fe74: 9a 40 3f ff addx %g0, -1, %o5 <== NOT EXECUTED
4001fe78: 98 0b 3f e0 and %o4, -32, %o4 <== NOT EXECUTED
4001fe7c: 9a 0b 7f e1 and %o5, -31, %o5 <== NOT EXECUTED
4001fe80: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
4001fe84: 96 02 e0 41 add %o3, 0x41, %o3 <== NOT EXECUTED
4001fe88: 90 12 22 20 or %o0, 0x220, %o0 <== NOT EXECUTED
4001fe8c: 98 03 20 4d add %o4, 0x4d, %o4 <== NOT EXECUTED
4001fe90: 40 00 14 bb call 4002517c <printf> <== NOT EXECUTED
4001fe94: 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)
4001fe98: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4001fe9c: 02 bf ff d2 be 4001fde4 <rtems_rfs_file_io_end+0x174> <== NOT EXECUTED
4001fea0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
{
time_t now = time (NULL);
4001fea4: 40 00 24 fa call 4002928c <time>
4001fea8: 90 10 20 00 clr %o0
if (read && atime)
4001feac: 80 a6 60 00 cmp %i1, 0
4001feb0: 02 80 00 06 be 4001fec8 <rtems_rfs_file_io_end+0x258> <== NEVER TAKEN
4001feb4: 80 a7 20 00 cmp %i4, 0
4001feb8: 80 a6 a0 00 cmp %i2, 0
4001febc: 32 80 00 0b bne,a 4001fee8 <rtems_rfs_file_io_end+0x278>
4001fec0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
handle->shared->atime = now;
if (!read && mtime)
4001fec4: 80 a7 20 00 cmp %i4, 0
4001fec8: 02 bf ff c9 be 4001fdec <rtems_rfs_file_io_end+0x17c>
4001fecc: 80 a6 e0 00 cmp %i3, 0
4001fed0: 80 a6 a0 01 cmp %i2, 1
4001fed4: 02 bf ff c6 be 4001fdec <rtems_rfs_file_io_end+0x17c> <== NEVER TAKEN
4001fed8: 80 a6 e0 00 cmp %i3, 0
handle->shared->mtime = now;
4001fedc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001fee0: 10 bf ff c3 b 4001fdec <rtems_rfs_file_io_end+0x17c>
4001fee4: d0 20 60 90 st %o0, [ %g1 + 0x90 ]
if (atime || mtime)
{
time_t now = time (NULL);
if (read && atime)
handle->shared->atime = now;
4001fee8: 10 bf ff f7 b 4001fec4 <rtems_rfs_file_io_end+0x254>
4001feec: d0 20 60 8c st %o0, [ %g1 + 0x8c ]
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
{
if (!read)
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001fef0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001fef4: 92 07 60 04 add %i5, 4, %o1
4001fef8: 7f ff f5 d0 call 4001d638 <rtems_rfs_buffer_handle_release>
4001fefc: 39 10 00 dd sethi %hi(0x40037400), %i4
rtems_rfs_file_buffer (handle));
if (rc > 0)
4001ff00: b0 92 20 00 orcc %o0, 0, %i0
4001ff04: 14 bf ff 7b bg 4001fcf0 <rtems_rfs_file_io_end+0x80> <== NEVER TAKEN
4001ff08: b8 17 20 d0 or %i4, 0xd0, %i4
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
4001ff0c: 10 bf ff 88 b 4001fd2c <rtems_rfs_file_io_end+0xbc>
4001ff10: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
length = false;
mtime = false;
if (!read &&
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
4001ff14: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
4001ff18: 80 a0 c0 02 cmp %g3, %g2
4001ff1c: 28 bf ff a2 bleu,a 4001fda4 <rtems_rfs_file_io_end+0x134>
4001ff20: f2 07 40 00 ld [ %i5 ], %i1
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
4001ff24: 10 bf ff bc b 4001fe14 <rtems_rfs_file_io_end+0x1a4>
4001ff28: c4 07 40 00 ld [ %i5 ], %g2
4001ff2c <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))
4001ff2c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4001ff30: 80 a0 60 00 cmp %g1, 0
4001ff34: 02 80 00 07 be 4001ff50 <rtems_rfs_file_io_release+0x24> <== ALWAYS TAKEN
4001ff38: 92 02 20 04 add %o0, 4, %o1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4001ff3c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED
4001ff40: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
4001ff44: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4001ff48: 7f ff f5 bc call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001ff4c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
4001ff50: 81 c3 e0 08 retl
4001ff54: 90 10 20 00 clr %o0
4001fa2c <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
4001fa2c: 9d e3 bf 98 save %sp, -104, %sp
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001fa30: 90 10 20 20 mov 0x20, %o0
4001fa34: 92 10 20 00 clr %o1
4001fa38: 7f ff d5 9b call 400150a4 <rtems_rfs_trace>
4001fa3c: ba 10 00 18 mov %i0, %i5
4001fa40: 80 8a 20 ff btst 0xff, %o0
4001fa44: 22 80 00 0d be,a 4001fa78 <rtems_rfs_file_io_start+0x4c> <== ALWAYS TAKEN
4001fa48: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4001fa4c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001fa50: 02 80 00 2f be 4001fb0c <rtems_rfs_file_io_start+0xe0> <== NOT EXECUTED
4001fa54: 13 10 00 e3 sethi %hi(0x40038c00), %o1 <== NOT EXECUTED
4001fa58: 13 10 00 dd sethi %hi(0x40037400), %o1 <== NOT EXECUTED
4001fa5c: 92 12 60 d0 or %o1, 0xd0, %o1 ! 400374d0 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001fa60: d4 07 60 10 ld [ %i5 + 0x10 ], %o2 <== NOT EXECUTED
4001fa64: d6 07 60 14 ld [ %i5 + 0x14 ], %o3 <== NOT EXECUTED
4001fa68: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
4001fa6c: 40 00 15 c4 call 4002517c <printf> <== NOT EXECUTED
4001fa70: 90 12 20 f8 or %o0, 0xf8, %o0 ! 40038cf8 <CSWTCH.2+0xf08> <== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
4001fa74: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
4001fa78: 80 a0 60 00 cmp %g1, 0
4001fa7c: 22 80 00 2c be,a 4001fb2c <rtems_rfs_file_io_start+0x100>
4001fa80: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
block, request_read);
if (rc > 0)
return rc;
}
if (read
4001fa84: 80 a6 a0 00 cmp %i2, 0
4001fa88: 02 80 00 0d be 4001fabc <rtems_rfs_file_io_start+0x90>
4001fa8c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
4001fa90: c4 00 60 44 ld [ %g1 + 0x44 ], %g2
4001fa94: 80 a0 a0 00 cmp %g2, 0
4001fa98: 12 80 00 1f bne 4001fb14 <rtems_rfs_file_io_start+0xe8>
4001fa9c: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
4001faa0: 80 a0 e0 00 cmp %g3, 0
4001faa4: 12 80 00 1d bne 4001fb18 <rtems_rfs_file_io_start+0xec> <== ALWAYS TAKEN
4001faa8: 86 00 ff ff add %g3, -1, %g3
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001faac: f8 00 60 40 ld [ %g1 + 0x40 ], %i4 <== NOT EXECUTED
4001fab0: 80 a7 20 00 cmp %i4, 0
4001fab4: 32 80 00 05 bne,a 4001fac8 <rtems_rfs_file_io_start+0x9c>
4001fab8: 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));
4001fabc: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
4001fac0: f8 00 60 08 ld [ %g1 + 8 ], %i4
*available = size - rtems_rfs_file_block_offset (handle);
4001fac4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001fac8: 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);
4001facc: 82 27 00 01 sub %i4, %g1, %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001fad0: 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);
4001fad4: c2 26 40 00 st %g1, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001fad8: 7f ff d5 73 call 400150a4 <rtems_rfs_trace>
4001fadc: b0 10 20 00 clr %i0
4001fae0: 80 8a 20 ff btst 0xff, %o0
4001fae4: 32 80 00 04 bne,a 4001faf4 <rtems_rfs_file_io_start+0xc8><== NEVER TAKEN
4001fae8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
*available, size);
return 0;
}
4001faec: 81 c7 e0 08 ret
4001faf0: 81 e8 00 00 restore
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
*available = size - rtems_rfs_file_block_offset (handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
4001faf4: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4001faf8: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
4001fafc: 40 00 15 a0 call 4002517c <printf> <== NOT EXECUTED
4001fb00: 90 12 21 80 or %o0, 0x180, %o0 ! 40038d80 <CSWTCH.2+0xf90><== NOT EXECUTED
*available, size);
return 0;
}
4001fb04: 81 c7 e0 08 ret <== NOT EXECUTED
4001fb08: 81 e8 00 00 restore <== NOT EXECUTED
bool read)
{
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4001fb0c: 10 bf ff d5 b 4001fa60 <rtems_rfs_file_io_start+0x34> <== NOT EXECUTED
4001fb10: 92 12 60 f0 or %o1, 0xf0, %o1 <== NOT EXECUTED
if (rc > 0)
return rc;
}
if (read
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
4001fb14: 86 00 ff ff add %g3, -1, %g3
4001fb18: 80 a0 80 03 cmp %g2, %g3
4001fb1c: 32 bf ff e9 bne,a 4001fac0 <rtems_rfs_file_io_start+0x94>
4001fb20: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001fb24: 10 bf ff e3 b 4001fab0 <rtems_rfs_file_io_start+0x84>
4001fb28: f8 00 60 40 ld [ %g1 + 0x40 ], %i4
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
4001fb2c: 94 07 60 10 add %i5, 0x10, %o2
4001fb30: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001fb34: 96 07 bf fc add %fp, -4, %o3
4001fb38: 7f ff f4 0b call 4001cb64 <rtems_rfs_block_map_find>
4001fb3c: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
4001fb40: b0 92 20 00 orcc %o0, 0, %i0
4001fb44: 04 80 00 0a ble 4001fb6c <rtems_rfs_file_io_start+0x140>
4001fb48: 80 a6 20 06 cmp %i0, 6
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
4001fb4c: 32 bf ff e8 bne,a 4001faec <rtems_rfs_file_io_start+0xc0><== NEVER TAKEN
4001fb50: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
4001fb54: 80 a6 a0 00 cmp %i2, 0
4001fb58: 22 80 00 2d be,a 4001fc0c <rtems_rfs_file_io_start+0x1e0><== ALWAYS TAKEN
4001fb5c: 80 a6 20 06 cmp %i0, 6
{
*available = 0;
4001fb60: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
return 0;
4001fb64: 81 c7 e0 08 ret <== NOT EXECUTED
4001fb68: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
/*
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
4001fb6c: 80 a6 a0 00 cmp %i2, 0
4001fb70: 12 80 00 0d bne 4001fba4 <rtems_rfs_file_io_start+0x178>
4001fb74: 82 10 00 1a mov %i2, %g1
4001fb78: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
4001fb7c: 80 a0 a0 00 cmp %g2, 0
4001fb80: 12 80 00 09 bne 4001fba4 <rtems_rfs_file_io_start+0x178>
4001fb84: 82 10 20 01 mov 1, %g1
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001fb88: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
(rtems_rfs_file_block_offset (handle) ||
4001fb8c: c6 06 40 00 ld [ %i1 ], %g3
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001fb90: c4 00 a0 98 ld [ %g2 + 0x98 ], %g2
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
(rtems_rfs_file_block_offset (handle) ||
4001fb94: c4 00 a0 08 ld [ %g2 + 8 ], %g2
4001fb98: 80 a0 c0 02 cmp %g3, %g2
4001fb9c: 3a 80 00 02 bcc,a 4001fba4 <rtems_rfs_file_io_start+0x178><== NEVER TAKEN
4001fba0: 82 10 20 00 clr %g1 <== NOT EXECUTED
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001fba4: 90 10 20 20 mov 0x20, %o0
4001fba8: 92 10 20 00 clr %o1
4001fbac: 7f ff d5 3e call 400150a4 <rtems_rfs_trace>
4001fbb0: b8 08 60 ff and %g1, 0xff, %i4
4001fbb4: 80 8a 20 ff btst 0xff, %o0
4001fbb8: 22 80 00 0b be,a 4001fbe4 <rtems_rfs_file_io_start+0x1b8><== ALWAYS TAKEN
4001fbbc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001fbc0: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4001fbc4: 02 80 00 24 be 4001fc54 <rtems_rfs_file_io_start+0x228> <== NOT EXECUTED
4001fbc8: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
4001fbcc: 15 10 00 db sethi %hi(0x40036c00), %o2 <== NOT EXECUTED
4001fbd0: 94 12 a3 50 or %o2, 0x350, %o2 ! 40036f50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
4001fbd4: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
4001fbd8: 40 00 15 69 call 4002517c <printf> <== NOT EXECUTED
4001fbdc: 90 12 21 48 or %o0, 0x148, %o0 ! 40038d48 <CSWTCH.2+0xf58><== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
4001fbe0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
4001fbe4: d4 07 bf fc ld [ %fp + -4 ], %o2
4001fbe8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001fbec: 92 07 60 04 add %i5, 4, %o1
4001fbf0: 7f ff f7 0c call 4001d820 <rtems_rfs_buffer_handle_request>
4001fbf4: 96 10 00 1c mov %i4, %o3
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
4001fbf8: b0 92 20 00 orcc %o0, 0, %i0
4001fbfc: 04 bf ff a3 ble 4001fa88 <rtems_rfs_file_io_start+0x5c> <== ALWAYS TAKEN
4001fc00: 80 a6 a0 00 cmp %i2, 0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
*available, size);
return 0;
}
4001fc04: 81 c7 e0 08 ret <== NOT EXECUTED
4001fc08: 81 e8 00 00 restore <== NOT EXECUTED
{
*available = 0;
return 0;
}
if (rc != ENXIO)
4001fc0c: 12 bf ff b8 bne 4001faec <rtems_rfs_file_io_start+0xc0> <== NEVER TAKEN
4001fc10: 90 10 20 20 mov 0x20, %o0
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001fc14: 7f ff d5 24 call 400150a4 <rtems_rfs_trace>
4001fc18: 92 10 20 00 clr %o1
4001fc1c: 80 8a 20 ff btst 0xff, %o0
4001fc20: 12 80 00 10 bne 4001fc60 <rtems_rfs_file_io_start+0x234> <== NEVER TAKEN
4001fc24: 11 10 00 e3 sethi %hi(0x40038c00), %o0
printf ("rtems-rfs: file-io: start: grow\n");
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001fc28: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001fc2c: 94 10 20 01 mov 1, %o2
4001fc30: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001fc34: 96 07 bf fc add %fp, -4, %o3
4001fc38: 7f ff f4 4f call 4001cd74 <rtems_rfs_block_map_grow>
4001fc3c: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
4001fc40: b0 92 20 00 orcc %o0, 0, %i0
4001fc44: 14 bf ff aa bg 4001faec <rtems_rfs_file_io_start+0xc0>
4001fc48: 82 10 20 00 clr %g1
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001fc4c: 10 bf ff d7 b 4001fba8 <rtems_rfs_file_io_start+0x17c>
4001fc50: 90 10 20 20 mov 0x20, %o0
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001fc54: 15 10 00 d5 sethi %hi(0x40035400), %o2 <== NOT EXECUTED
4001fc58: 10 bf ff df b 4001fbd4 <rtems_rfs_file_io_start+0x1a8> <== NOT EXECUTED
4001fc5c: 94 12 a0 60 or %o2, 0x60, %o2 ! 40035460 <Callbacks.6428+0x218><== NOT EXECUTED
if (rc != ENXIO)
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: grow\n");
4001fc60: 40 00 15 df call 400253dc <puts> <== NOT EXECUTED
4001fc64: 90 12 21 28 or %o0, 0x128, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
4001fc68: 10 bf ff f1 b 4001fc2c <rtems_rfs_file_io_start+0x200> <== NOT EXECUTED
4001fc6c: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
4001f3e0 <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)
{
4001f3e0: 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))
4001f3e4: 90 10 20 08 mov 8, %o0
4001f3e8: 92 10 20 00 clr %o1
4001f3ec: 7f ff d7 2e call 400150a4 <rtems_rfs_trace>
4001f3f0: a0 10 00 18 mov %i0, %l0
4001f3f4: 80 8a 20 ff btst 0xff, %o0
4001f3f8: 12 80 00 2b bne 4001f4a4 <rtems_rfs_file_open+0xc4> <== NEVER TAKEN
4001f3fc: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
4001f400: c0 26 c0 00 clr [ %i3 ]
/*
* Allocate a new handle and initialise it. Do this before we deal with the
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
4001f404: 90 10 20 20 mov 0x20, %o0
4001f408: 7f ff a8 e5 call 4000979c <malloc>
4001f40c: b0 10 20 0c mov 0xc, %i0
if (!handle)
4001f410: 80 a2 20 00 cmp %o0, 0
4001f414: 02 80 00 4f be 4001f550 <rtems_rfs_file_open+0x170> <== NEVER TAKEN
4001f418: b8 10 00 08 mov %o0, %i4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4001f41c: fa 04 20 74 ld [ %l0 + 0x74 ], %i5
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
4001f420: c0 22 00 00 clr [ %o0 ]
4001f424: c0 22 20 04 clr [ %o0 + 4 ]
4001f428: c0 22 20 10 clr [ %o0 + 0x10 ]
4001f42c: c0 22 20 14 clr [ %o0 + 0x14 ]
4001f430: c0 22 20 18 clr [ %o0 + 0x18 ]
4001f434: c0 22 20 1c clr [ %o0 + 0x1c ]
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
4001f438: c0 22 20 08 clr [ %o0 + 8 ]
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
4001f43c: 84 04 20 78 add %l0, 0x78, %g2
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
4001f440: 80 a7 40 02 cmp %i5, %g2
4001f444: 12 80 00 06 bne 4001f45c <rtems_rfs_file_open+0x7c>
4001f448: c0 22 20 0c clr [ %o0 + 0xc ]
4001f44c: 30 80 00 1b b,a 4001f4b8 <rtems_rfs_file_open+0xd8>
4001f450: 80 a7 40 02 cmp %i5, %g2
4001f454: 02 80 00 19 be 4001f4b8 <rtems_rfs_file_open+0xd8> <== ALWAYS TAKEN
4001f458: 01 00 00 00 nop
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
4001f45c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4001f460: 80 a6 40 01 cmp %i1, %g1
4001f464: 32 bf ff fb bne,a 4001f450 <rtems_rfs_file_open+0x70> <== ALWAYS TAKEN
4001f468: fa 07 40 00 ld [ %i5 ], %i5
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
4001f46c: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001f470: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
4001f474: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001f478: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001f47c: 7f ff d7 0a call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001f480: c2 27 60 08 st %g1, [ %i5 + 8 ] <== NOT EXECUTED
4001f484: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f488: 12 80 00 34 bne 4001f558 <rtems_rfs_file_open+0x178> <== NOT EXECUTED
4001f48c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = oflag;
4001f490: f4 27 00 00 st %i2, [ %i4 ] <== NOT EXECUTED
handle->shared = shared;
4001f494: fa 27 20 1c st %i5, [ %i4 + 0x1c ]
*file = handle;
4001f498: f8 26 c0 00 st %i4, [ %i3 ]
return 0;
4001f49c: 81 c7 e0 08 ret
4001f4a0: 91 e8 20 00 restore %g0, 0, %o0
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
4001f4a4: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001f4a8: 40 00 17 35 call 4002517c <printf> <== NOT EXECUTED
4001f4ac: 90 12 23 38 or %o0, 0x338, %o0 ! 40038b38 <CSWTCH.2+0xd48><== NOT EXECUTED
*file = NULL;
4001f4b0: 10 bf ff d5 b 4001f404 <rtems_rfs_file_open+0x24> <== NOT EXECUTED
4001f4b4: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
{
/*
* None exists so create. Copy in the shared parts of the inode we hold in
* memory.
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
4001f4b8: 7f ff a8 b9 call 4000979c <malloc>
4001f4bc: 90 10 20 9c mov 0x9c, %o0
if (!shared)
4001f4c0: ba 92 20 00 orcc %o0, 0, %i5
4001f4c4: 02 80 00 46 be 4001f5dc <rtems_rfs_file_open+0x1fc> <== NEVER TAKEN
4001f4c8: 92 10 20 00 clr %o1
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
4001f4cc: 40 00 16 ae call 40024f84 <memset>
4001f4d0: 94 10 20 9c mov 0x9c, %o2
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
4001f4d4: a2 07 60 0c add %i5, 0xc, %l1
4001f4d8: 90 10 00 10 mov %l0, %o0
4001f4dc: 92 10 00 19 mov %i1, %o1
4001f4e0: 94 10 00 11 mov %l1, %o2
4001f4e4: 7f ff d0 49 call 40013608 <rtems_rfs_inode_open>
4001f4e8: 96 10 20 01 mov 1, %o3
if (rc > 0)
4001f4ec: b0 92 20 00 orcc %o0, 0, %i0
4001f4f0: 04 80 00 23 ble 4001f57c <rtems_rfs_file_open+0x19c> <== ALWAYS TAKEN
4001f4f4: 90 10 20 08 mov 8, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001f4f8: 7f ff d6 eb call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001f4fc: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001f500: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f504: 02 80 00 09 be 4001f528 <rtems_rfs_file_open+0x148> <== NOT EXECUTED
4001f508: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
4001f50c: 40 00 1b 66 call 400262a4 <strerror> <== NOT EXECUTED
4001f510: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001f514: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001f518: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001f51c: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001f520: 40 00 17 17 call 4002517c <printf> <== NOT EXECUTED
4001f524: 90 12 23 80 or %o0, 0x380, %o0 ! 40038b80 <CSWTCH.2+0xd90><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
free (shared);
4001f528: 7f ff a7 00 call 40009128 <free> <== NOT EXECUTED
4001f52c: 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);
4001f530: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001f534: 7f ff f8 41 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f538: 92 07 20 04 add %i4, 4, %o1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
4001f53c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
handle->dirty = false;
4001f540: c0 2f 20 04 clrb [ %i4 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
4001f544: c0 27 20 08 clr [ %i4 + 8 ] <== NOT EXECUTED
4001f548: 7f ff a6 f8 call 40009128 <free> <== NOT EXECUTED
4001f54c: c0 27 20 0c clr [ %i4 + 0xc ] <== NOT EXECUTED
return rc;
4001f550: 81 c7 e0 08 ret <== NOT EXECUTED
4001f554: 81 e8 00 00 restore <== NOT EXECUTED
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
4001f558: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
handle->flags = oflag;
handle->shared = shared;
*file = handle;
return 0;
4001f55c: b0 10 20 00 clr %i0 <== NOT EXECUTED
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
4001f560: 40 00 17 07 call 4002517c <printf> <== NOT EXECUTED
4001f564: 90 12 23 58 or %o0, 0x358, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = oflag;
4001f568: f4 27 00 00 st %i2, [ %i4 ] <== NOT EXECUTED
handle->shared = shared;
4001f56c: fa 27 20 1c st %i5, [ %i4 + 0x1c ] <== NOT EXECUTED
*file = handle;
4001f570: f8 26 c0 00 st %i4, [ %i3 ] <== NOT EXECUTED
return 0;
4001f574: 81 c7 e0 08 ret <== NOT EXECUTED
4001f578: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
4001f57c: 90 10 00 10 mov %l0, %o0
4001f580: 92 10 00 11 mov %l1, %o1
4001f584: 7f ff f4 a3 call 4001c810 <rtems_rfs_block_map_open>
4001f588: 94 07 60 34 add %i5, 0x34, %o2
if (rc > 0)
4001f58c: b0 92 20 00 orcc %o0, 0, %i0
4001f590: 24 80 00 1e ble,a 4001f608 <rtems_rfs_file_open+0x228> <== ALWAYS TAKEN
4001f594: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001f598: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
4001f59c: 7f ff d6 c2 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4001f5a0: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001f5a4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4001f5a8: 22 80 00 0a be,a 4001f5d0 <rtems_rfs_file_open+0x1f0> <== NOT EXECUTED
4001f5ac: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
4001f5b0: 40 00 1b 3d call 400262a4 <strerror> <== NOT EXECUTED
4001f5b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001f5b8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4001f5bc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001f5c0: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001f5c4: 40 00 16 ee call 4002517c <printf> <== NOT EXECUTED
4001f5c8: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 40038bb8 <CSWTCH.2+0xdc8><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
4001f5cc: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
4001f5d0: 7f ff d0 86 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
4001f5d4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4001f5d8: 30 bf ff d4 b,a 4001f528 <rtems_rfs_file_open+0x148> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4001f5dc: 92 07 20 04 add %i4, 4, %o1 <== NOT EXECUTED
4001f5e0: 7f ff f8 16 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f5e4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
shared = malloc (sizeof (rtems_rfs_file_shared));
if (!shared)
{
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
4001f5e8: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
if (!shared)
{
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
4001f5ec: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
handle->dirty = false;
4001f5f0: c0 2f 20 04 clrb [ %i4 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
4001f5f4: c0 27 20 08 clr [ %i4 + 8 ] <== NOT EXECUTED
4001f5f8: 7f ff a6 cc call 40009128 <free> <== NOT EXECUTED
4001f5fc: c0 27 20 0c clr [ %i4 + 0xc ] <== NOT EXECUTED
return ENOMEM;
4001f600: 81 c7 e0 08 ret <== NOT EXECUTED
4001f604: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
shared->references = 1;
4001f608: 84 10 20 01 mov 1, %g2
4001f60c: c4 27 60 08 st %g2, [ %i5 + 8 ]
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
4001f610: f0 08 60 0c ldub [ %g1 + 0xc ], %i0
4001f614: c8 08 60 0d ldub [ %g1 + 0xd ], %g4
4001f618: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
4001f61c: c4 08 60 0e ldub [ %g1 + 0xe ], %g2
4001f620: b1 2e 20 18 sll %i0, 0x18, %i0
4001f624: 89 29 20 10 sll %g4, 0x10, %g4
4001f628: 85 28 a0 08 sll %g2, 8, %g2
4001f62c: 88 16 00 04 or %i0, %g4, %g4
4001f630: 86 11 00 03 or %g4, %g3, %g3
4001f634: 84 10 c0 02 or %g3, %g2, %g2
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
4001f638: c4 27 60 84 st %g2, [ %i5 + 0x84 ]
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
4001f63c: 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);
4001f640: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
4001f644: 90 04 20 74 add %l0, 0x74, %o0
4001f648: 85 28 a0 08 sll %g2, 8, %g2
4001f64c: 84 10 c0 02 or %g3, %g2, %g2
4001f650: c4 27 60 88 st %g2, [ %i5 + 0x88 ]
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
4001f654: f0 08 60 10 ldub [ %g1 + 0x10 ], %i0
4001f658: c8 08 60 11 ldub [ %g1 + 0x11 ], %g4
4001f65c: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
4001f660: c4 08 60 12 ldub [ %g1 + 0x12 ], %g2
4001f664: b1 2e 20 18 sll %i0, 0x18, %i0
4001f668: 89 29 20 10 sll %g4, 0x10, %g4
4001f66c: 85 28 a0 08 sll %g2, 8, %g2
4001f670: 88 16 00 04 or %i0, %g4, %g4
4001f674: 86 11 00 03 or %g4, %g3, %g3
4001f678: 84 10 c0 02 or %g3, %g2, %g2
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
4001f67c: c4 27 60 8c st %g2, [ %i5 + 0x8c ]
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
4001f680: f0 08 60 14 ldub [ %g1 + 0x14 ], %i0
4001f684: c8 08 60 15 ldub [ %g1 + 0x15 ], %g4
4001f688: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
4001f68c: c4 08 60 16 ldub [ %g1 + 0x16 ], %g2
4001f690: b1 2e 20 18 sll %i0, 0x18, %i0
4001f694: 89 29 20 10 sll %g4, 0x10, %g4
4001f698: 85 28 a0 08 sll %g2, 8, %g2
4001f69c: 88 16 00 04 or %i0, %g4, %g4
4001f6a0: 86 11 00 03 or %g4, %g3, %g3
4001f6a4: 84 10 c0 02 or %g3, %g2, %g2
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
4001f6a8: c4 27 60 90 st %g2, [ %i5 + 0x90 ]
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
4001f6ac: c8 08 60 18 ldub [ %g1 + 0x18 ], %g4
4001f6b0: c6 08 60 19 ldub [ %g1 + 0x19 ], %g3
4001f6b4: c4 08 60 1b ldub [ %g1 + 0x1b ], %g2
4001f6b8: c2 08 60 1a ldub [ %g1 + 0x1a ], %g1
4001f6bc: 89 29 20 18 sll %g4, 0x18, %g4
4001f6c0: 87 28 e0 10 sll %g3, 0x10, %g3
4001f6c4: 83 28 60 08 sll %g1, 8, %g1
4001f6c8: 86 11 00 03 or %g4, %g3, %g3
4001f6cc: 84 10 c0 02 or %g3, %g2, %g2
4001f6d0: 82 10 80 01 or %g2, %g1, %g1
4001f6d4: 92 10 00 1d mov %i5, %o1
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
4001f6d8: c2 27 60 94 st %g1, [ %i5 + 0x94 ]
4001f6dc: 7f ff bc d4 call 4000ea2c <_Chain_Append>
4001f6e0: e0 27 60 98 st %l0, [ %i5 + 0x98 ]
shared->fs = fs;
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
4001f6e4: 92 10 00 11 mov %l1, %o1
4001f6e8: 94 10 20 00 clr %o2
4001f6ec: 7f ff cf fe call 400136e4 <rtems_rfs_inode_unload>
4001f6f0: 90 10 00 10 mov %l0, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
4001f6f4: 90 10 20 08 mov 8, %o0
4001f6f8: 7f ff d6 6b call 400150a4 <rtems_rfs_trace>
4001f6fc: 92 10 20 00 clr %o1
4001f700: 80 8a 20 ff btst 0xff, %o0
4001f704: 22 bf ff 64 be,a 4001f494 <rtems_rfs_file_open+0xb4> <== ALWAYS TAKEN
4001f708: f4 27 00 00 st %i2, [ %i4 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
4001f70c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4001f710: 11 10 00 e2 sethi %hi(0x40038800), %o0 <== NOT EXECUTED
4001f714: 40 00 16 9a call 4002517c <printf> <== NOT EXECUTED
4001f718: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 40038bf0 <CSWTCH.2+0xe00><== NOT EXECUTED
}
handle->flags = oflag;
4001f71c: 10 bf ff 5e b 4001f494 <rtems_rfs_file_open+0xb4> <== NOT EXECUTED
4001f720: f4 27 00 00 st %i2, [ %i4 ] <== NOT EXECUTED
4001ff58 <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
4001ff58: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4001ff5c: 90 10 20 20 mov 0x20, %o0
4001ff60: 92 10 20 00 clr %o1
4001ff64: 7f ff d4 50 call 400150a4 <rtems_rfs_trace>
4001ff68: ba 10 00 18 mov %i0, %i5
4001ff6c: 80 8a 20 ff btst 0xff, %o0
4001ff70: 32 80 00 2b bne,a 4002001c <rtems_rfs_file_seek+0xc4> <== NEVER TAKEN
4001ff74: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
* file, this function does not itself extend the size of the file."
*
* This means the file needs to set the file size to the pos only when a
* write occurs.
*/
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
4001ff78: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001ff7c: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001ff80: 7f ff f2 0e call 4001c7b8 <rtems_rfs_block_get_size>
4001ff84: 92 02 60 84 add %o1, 0x84, %o1
4001ff88: 80 a6 40 08 cmp %i1, %o0
4001ff8c: 18 80 00 1b bgu 4001fff8 <rtems_rfs_file_seek+0xa0> <== NEVER TAKEN
4001ff90: 01 00 00 00 nop
4001ff94: 02 80 00 17 be 4001fff0 <rtems_rfs_file_seek+0x98> <== ALWAYS TAKEN
4001ff98: 80 a6 80 09 cmp %i2, %o1
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
4001ff9c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
4001ffa0: b8 07 60 10 add %i5, 0x10, %i4
4001ffa4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4001ffa8: 92 10 00 19 mov %i1, %o1
4001ffac: 94 10 00 1a mov %i2, %o2
4001ffb0: 7f ff f1 d3 call 4001c6fc <rtems_rfs_block_get_bpos>
4001ffb4: 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))
4001ffb8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4001ffbc: 80 a0 60 00 cmp %g1, 0
4001ffc0: 02 80 00 13 be 4002000c <rtems_rfs_file_seek+0xb4>
4001ffc4: 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),
4001ffc8: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
4001ffcc: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4001ffd0: 96 07 bf fc add %fp, -4, %o3
4001ffd4: 7f ff f2 e4 call 4001cb64 <rtems_rfs_block_map_find>
4001ffd8: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
4001ffdc: b0 92 20 00 orcc %o0, 0, %i0
4001ffe0: 24 80 00 15 ble,a 40020034 <rtems_rfs_file_seek+0xdc> <== ALWAYS TAKEN
4001ffe4: c4 07 60 08 ld [ %i5 + 8 ], %g2
return rc;
}
*new_pos = pos;
return 0;
}
4001ffe8: 81 c7 e0 08 ret <== NOT EXECUTED
4001ffec: 81 e8 00 00 restore <== NOT EXECUTED
* file, this function does not itself extend the size of the file."
*
* This means the file needs to set the file size to the pos only when a
* write occurs.
*/
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
4001fff0: 28 bf ff ec bleu,a 4001ffa0 <rtems_rfs_file_seek+0x48>
4001fff4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
{
/*
* The seek is outside the current file so release any buffer. A write will
* extend the file.
*/
int rc = rtems_rfs_file_io_release (handle);
4001fff8: 7f ff ff cd call 4001ff2c <rtems_rfs_file_io_release>
4001fffc: 90 10 00 1d mov %i5, %o0
if (rc > 0)
40020000: b0 92 20 00 orcc %o0, 0, %i0
40020004: 14 80 00 16 bg 4002005c <rtems_rfs_file_seek+0x104> <== NEVER TAKEN
40020008: 01 00 00 00 nop
return rc;
}
*new_pos = pos;
4002000c: f2 26 c0 00 st %i1, [ %i3 ]
40020010: f4 26 e0 04 st %i2, [ %i3 + 4 ]
return 0;
}
40020014: 81 c7 e0 08 ret
40020018: 91 e8 20 00 restore %g0, 0, %o0
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
4002001c: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
40020020: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40020024: 40 00 14 56 call 4002517c <printf> <== NOT EXECUTED
40020028: 90 12 22 58 or %o0, 0x258, %o0 <== NOT EXECUTED
* file, this function does not itself extend the size of the file."
*
* This means the file needs to set the file size to the pos only when a
* write occurs.
*/
if (pos <= rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
4002002c: 10 bf ff d4 b 4001ff7c <rtems_rfs_file_seek+0x24> <== NOT EXECUTED
40020030: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
return rc;
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
40020034: c2 07 bf fc ld [ %fp + -4 ], %g1
40020038: 80 a0 80 01 cmp %g2, %g1
4002003c: 02 bf ff f4 be 4002000c <rtems_rfs_file_seek+0xb4> <== ALWAYS TAKEN
40020040: 92 07 60 04 add %i5, 4, %o1
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
40020044: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
40020048: 7f ff f5 7c call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4002004c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
if (rc > 0)
40020050: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40020054: 24 bf ff ef ble,a 40020010 <rtems_rfs_file_seek+0xb8> <== NOT EXECUTED
40020058: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED
return rc;
}
*new_pos = pos;
return 0;
}
4002005c: 81 c7 e0 08 ret <== NOT EXECUTED
40020060: 81 e8 00 00 restore <== NOT EXECUTED
40020064 <rtems_rfs_file_set_size>:
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
40020064: 9d e3 bf 90 save %sp, -112, %sp
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
40020068: f6 06 20 1c ld [ %i0 + 0x1c ], %i3
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
4002006c: 90 10 20 20 mov 0x20, %o0
40020070: 92 10 20 00 clr %o1
40020074: 7f ff d4 0c call 400150a4 <rtems_rfs_trace>
40020078: b8 10 00 19 mov %i1, %i4
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
4002007c: ba 10 00 1a mov %i2, %i5
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
40020080: 80 8a 20 ff btst 0xff, %o0
40020084: 12 80 00 92 bne 400202cc <rtems_rfs_file_set_size+0x268> <== NEVER TAKEN
40020088: b2 06 e0 34 add %i3, 0x34, %i1
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
size = rtems_rfs_file_size (handle);
4002008c: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
40020090: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
40020094: 7f ff f1 c9 call 4001c7b8 <rtems_rfs_block_get_size>
40020098: 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)
4002009c: 80 a7 00 08 cmp %i4, %o0
400200a0: 02 80 00 98 be 40020300 <rtems_rfs_file_set_size+0x29c> <== ALWAYS TAKEN
400200a4: 80 a7 40 09 cmp %i5, %o1
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
400200a8: 80 97 00 1d orcc %i4, %i5, %g0 <== NOT EXECUTED
400200ac: 22 80 00 9a be,a 40020314 <rtems_rfs_file_set_size+0x2b0><== NOT EXECUTED
400200b0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
400200b4: 80 a7 00 08 cmp %i4, %o0 <== NOT EXECUTED
400200b8: 08 80 00 57 bleu 40020214 <rtems_rfs_file_set_size+0x1b0> <== ALWAYS TAKEN
400200bc: 01 00 00 00 nop
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
400200c0: e8 06 20 1c ld [ %i0 + 0x1c ], %l4 <== NOT EXECUTED
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
400200c4: ba a7 40 09 subcc %i5, %o1, %i5
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
400200c8: c2 05 20 98 ld [ %l4 + 0x98 ], %g1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
400200cc: b8 67 00 08 subx %i4, %o0, %i4
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
400200d0: a6 10 00 14 mov %l4, %l3
400200d4: f4 00 60 08 ld [ %g1 + 8 ], %i2
read_block = false;
while (count)
400200d8: a4 10 20 00 clr %l2
400200dc: a2 10 20 01 mov 1, %l1
400200e0: 80 97 00 1d orcc %i4, %i5, %g0
400200e4: 12 80 00 2a bne 4002018c <rtems_rfs_file_set_size+0x128> <== ALWAYS TAKEN
400200e8: a0 06 20 04 add %i0, 4, %l0
400200ec: 10 80 00 92 b 40020334 <rtems_rfs_file_set_size+0x2d0> <== NOT EXECUTED
400200f0: f4 06 e0 3c ld [ %i3 + 0x3c ], %i2 <== NOT EXECUTED
map, 1, &block);
if (rc > 0)
return rc;
}
if (count < (length - bpos.boff))
400200f4: 80 a0 80 1d cmp %g2, %i5
400200f8: 28 80 00 45 bleu,a 4002020c <rtems_rfs_file_set_size+0x1a8>
400200fc: c0 26 e0 40 clr [ %i3 + 0x40 ]
{
length = count + bpos.boff;
40020100: b4 00 40 1d add %g1, %i5, %i2
40020104: e2 2e e0 34 stb %l1, [ %i3 + 0x34 ]
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
40020108: f4 26 e0 40 st %i2, [ %i3 + 0x40 ]
read_block = true;
4002010c: a4 10 20 01 mov 1, %l2
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
40020110: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
40020114: d4 07 bf f0 ld [ %fp + -16 ], %o2
40020118: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
4002011c: 92 10 00 10 mov %l0, %o1
40020120: 7f ff f5 c0 call 4001d820 <rtems_rfs_buffer_handle_request>
40020124: 96 0c a0 01 and %l2, 1, %o3
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
40020128: 82 92 20 00 orcc %o0, 0, %g1
4002012c: 14 80 00 66 bg 400202c4 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
40020130: 92 10 20 00 clr %o1
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
40020134: c4 06 20 0c ld [ %i0 + 0xc ], %g2
memset (dst + bpos.boff, 0, length - bpos.boff);
40020138: c2 07 bf f8 ld [ %fp + -8 ], %g1
4002013c: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
40020140: 94 26 80 01 sub %i2, %g1, %o2
40020144: 40 00 13 90 call 40024f84 <memset>
40020148: 90 02 00 01 add %o0, %g1, %o0
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
4002014c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
memset (dst + bpos.boff, 0, length - bpos.boff);
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
40020150: e2 2e 20 04 stb %l1, [ %i0 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
40020154: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
40020158: 7f ff f5 38 call 4001d638 <rtems_rfs_buffer_handle_release>
4002015c: 92 10 00 10 mov %l0, %o1
rtems_rfs_file_buffer (handle));
if (rc > 0)
40020160: 82 92 20 00 orcc %o0, 0, %g1
40020164: 14 80 00 58 bg 400202c4 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
40020168: 01 00 00 00 nop
return rc;
count -= length - bpos.boff;
4002016c: c2 07 bf f8 ld [ %fp + -8 ], %g1
40020170: 82 26 80 01 sub %i2, %g1, %g1
40020174: ba a7 40 01 subcc %i5, %g1, %i5
40020178: 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)
4002017c: 80 97 00 1d orcc %i4, %i5, %g0
40020180: 22 80 00 6c be,a 40020330 <rtems_rfs_file_set_size+0x2cc>
40020184: e8 06 20 1c ld [ %i0 + 0x1c ], %l4
40020188: e6 06 20 1c ld [ %i0 + 0x1c ], %l3
/*
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
4002018c: c2 06 e0 40 ld [ %i3 + 0x40 ], %g1
40020190: c4 06 e0 3c ld [ %i3 + 0x3c ], %g2
40020194: c2 27 bf f8 st %g1, [ %fp + -8 ]
40020198: c4 27 bf f4 st %g2, [ %fp + -12 ]
4002019c: 80 a0 60 00 cmp %g1, 0
400201a0: 02 80 00 04 be 400201b0 <rtems_rfs_file_set_size+0x14c>
400201a4: c0 27 bf fc clr [ %fp + -4 ]
400201a8: 84 00 bf ff add %g2, -1, %g2
400201ac: c4 27 bf f4 st %g2, [ %fp + -12 ]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
400201b0: d0 04 e0 98 ld [ %l3 + 0x98 ], %o0
400201b4: 92 10 00 19 mov %i1, %o1
400201b8: 94 07 bf f4 add %fp, -12, %o2
400201bc: 7f ff f2 6a call 4001cb64 <rtems_rfs_block_map_find>
400201c0: 96 07 bf f0 add %fp, -16, %o3
map, &bpos, &block);
if (rc > 0)
400201c4: 82 92 20 00 orcc %o0, 0, %g1
400201c8: 04 80 00 0c ble 400201f8 <rtems_rfs_file_set_size+0x194>
400201cc: 80 a0 60 06 cmp %g1, 6
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
400201d0: 12 80 00 3d bne 400202c4 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
400201d4: 92 10 00 19 mov %i1, %o1
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
400201d8: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
400201dc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
400201e0: 94 10 20 01 mov 1, %o2
400201e4: 7f ff f2 e4 call 4001cd74 <rtems_rfs_block_map_grow>
400201e8: 96 07 bf f0 add %fp, -16, %o3
map, 1, &block);
if (rc > 0)
400201ec: 82 92 20 00 orcc %o0, 0, %g1
400201f0: 14 80 00 35 bg 400202c4 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
400201f4: 01 00 00 00 nop
return rc;
}
if (count < (length - bpos.boff))
400201f8: c2 07 bf f8 ld [ %fp + -8 ], %g1
400201fc: 80 a7 20 00 cmp %i4, 0
40020200: 02 bf ff bd be 400200f4 <rtems_rfs_file_set_size+0x90> <== ALWAYS TAKEN
40020204: 84 26 80 01 sub %i2, %g1, %g2
40020208: c0 26 e0 40 clr [ %i3 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
4002020c: 10 bf ff c1 b 40020110 <rtems_rfs_file_set_size+0xac>
40020210: e2 2e e0 34 stb %l1, [ %i3 + 0x34 ]
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
40020214: 02 80 00 54 be 40020364 <rtems_rfs_file_set_size+0x300> <== ALWAYS TAKEN
40020218: 80 a7 40 09 cmp %i5, %o1
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
4002021c: e6 06 20 1c ld [ %i0 + 0x1c ], %l3 <== NOT EXECUTED
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
40020220: f4 06 e0 3c ld [ %i3 + 0x3c ], %i2
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
40020224: e0 04 e0 98 ld [ %l3 + 0x98 ], %l0
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
40020228: 92 87 7f ff addcc %i5, -1, %o1
4002022c: f2 04 20 08 ld [ %l0 + 8 ], %i1
40020230: 90 47 3f ff addx %i4, -1, %o0
40020234: 96 10 00 19 mov %i1, %o3
40020238: 40 00 48 24 call 400322c8 <__udivdi3>
4002023c: 94 10 20 00 clr %o2
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
40020240: 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));
40020244: 96 10 00 19 mov %i1, %o3
40020248: 94 10 20 00 clr %o2
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
4002024c: b2 02 40 1a add %o1, %i2, %i1
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
40020250: 90 10 00 1c mov %i4, %o0
40020254: 40 00 48 f1 call 40032618 <__umoddi3>
40020258: 92 10 00 1d mov %i5, %o1
if (blocks)
4002025c: 80 a6 60 00 cmp %i1, 0
40020260: 12 80 00 4e bne 40020398 <rtems_rfs_file_set_size+0x334>
40020264: 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),
40020268: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4002026c: 84 10 20 01 mov 1, %g2
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
40020270: fa 26 e0 40 st %i5, [ %i3 + 0x40 ]
40020274: 80 a0 60 00 cmp %g1, 0
40020278: 02 80 00 3f be 40020374 <rtems_rfs_file_set_size+0x310>
4002027c: c4 2e e0 34 stb %g2, [ %i3 + 0x34 ]
40020280: 80 a6 a0 00 cmp %i2, 0
40020284: 12 80 00 3d bne 40020378 <rtems_rfs_file_set_size+0x314> <== ALWAYS TAKEN
40020288: 80 a0 40 1a cmp %g1, %i2
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
4002028c: f4 26 20 10 st %i2, [ %i0 + 0x10 ] <== NOT EXECUTED
40020290: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
40020294: 80 a7 60 00 cmp %i5, 0
40020298: 02 80 00 3e be 40020390 <rtems_rfs_file_set_size+0x32c> <== NEVER TAKEN
4002029c: c0 26 20 18 clr [ %i0 + 0x18 ]
400202a0: 82 06 bf ff add %i2, -1, %g1
400202a4: a8 10 00 13 mov %l3, %l4
400202a8: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
400202ac: c2 06 00 00 ld [ %i0 ], %g1
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
400202b0: f4 25 20 84 st %i2, [ %l4 + 0x84 ]
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
400202b4: 80 88 60 02 btst 2, %g1
400202b8: 02 80 00 25 be 4002034c <rtems_rfs_file_set_size+0x2e8> <== ALWAYS TAKEN
400202bc: fa 25 20 88 st %i5, [ %l4 + 0x88 ]
handle->shared->mtime = time (NULL);
}
return 0;
400202c0: 82 10 20 00 clr %g1
}
400202c4: 81 c7 e0 08 ret
400202c8: 91 e8 00 01 restore %g0, %g1, %o0
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
400202cc: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
400202d0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
400202d4: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
400202d8: 40 00 13 a9 call 4002517c <printf> <== NOT EXECUTED
400202dc: 90 12 22 78 or %o0, 0x278, %o0 ! 40038e78 <CSWTCH.2+0x1088><== NOT EXECUTED
size = rtems_rfs_file_size (handle);
400202e0: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
400202e4: d0 02 60 98 ld [ %o1 + 0x98 ], %o0 <== NOT EXECUTED
400202e8: 7f ff f1 34 call 4001c7b8 <rtems_rfs_block_get_size> <== NOT EXECUTED
400202ec: 92 02 60 84 add %o1, 0x84, %o1 <== NOT EXECUTED
/*
* If the file is same size do nothing else grow or shrink it ?
*
* If the file does not change size do not update the times.
*/
if (size != new_size)
400202f0: 80 a7 00 08 cmp %i4, %o0 <== NOT EXECUTED
400202f4: 12 bf ff 6e bne 400200ac <rtems_rfs_file_set_size+0x48> <== NOT EXECUTED
400202f8: 80 97 00 1d orcc %i4, %i5, %g0 <== NOT EXECUTED
400202fc: 80 a7 40 09 cmp %i5, %o1 <== NOT EXECUTED
40020300: 02 bf ff f0 be 400202c0 <rtems_rfs_file_set_size+0x25c>
40020304: 80 97 00 1d orcc %i4, %i5, %g0
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
40020308: 12 bf ff 6c bne 400200b8 <rtems_rfs_file_set_size+0x54>
4002030c: 80 a7 00 08 cmp %i4, %o0
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
40020310: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
40020314: 92 10 00 19 mov %i1, %o1
40020318: 7f ff f4 55 call 4001d46c <rtems_rfs_block_map_free_all>
4002031c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
if (rc > 0)
40020320: 82 92 20 00 orcc %o0, 0, %g1
40020324: 14 bf ff e8 bg 400202c4 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
40020328: 01 00 00 00 nop
4002032c: e8 06 20 1c ld [ %i0 + 0x1c ], %l4
40020330: f4 06 e0 3c ld [ %i3 + 0x3c ], %i2
40020334: fa 06 e0 40 ld [ %i3 + 0x40 ], %i5
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
40020338: c2 06 00 00 ld [ %i0 ], %g1
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
4002033c: f4 25 20 84 st %i2, [ %l4 + 0x84 ]
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
40020340: 80 88 60 02 btst 2, %g1
40020344: 12 bf ff df bne 400202c0 <rtems_rfs_file_set_size+0x25c> <== NEVER TAKEN
40020348: fa 25 20 88 st %i5, [ %l4 + 0x88 ]
handle->shared->mtime = time (NULL);
4002034c: 40 00 23 d0 call 4002928c <time>
40020350: 90 10 20 00 clr %o0
}
return 0;
40020354: 82 10 20 00 clr %g1
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
40020358: d0 25 20 90 st %o0, [ %l4 + 0x90 ]
}
return 0;
}
4002035c: 81 c7 e0 08 ret
40020360: 91 e8 00 01 restore %g0, %g1, %o0
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
40020364: 28 bf ff af bleu,a 40020220 <rtems_rfs_file_set_size+0x1bc>
40020368: e6 06 20 1c ld [ %i0 + 0x1c ], %l3
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4002036c: 10 bf ff 56 b 400200c4 <rtems_rfs_file_set_size+0x60>
40020370: e8 06 20 1c ld [ %i0 + 0x1c ], %l4
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
40020374: 80 a0 40 1a cmp %g1, %i2
40020378: 3a bf ff c6 bcc,a 40020290 <rtems_rfs_file_set_size+0x22c><== NEVER TAKEN
4002037c: f4 26 20 10 st %i2, [ %i0 + 0x10 ] <== NOT EXECUTED
40020380: 84 06 bf ff add %i2, -1, %g2
40020384: 80 a0 40 02 cmp %g1, %g2
40020388: 22 80 00 0e be,a 400203c0 <rtems_rfs_file_set_size+0x35c><== ALWAYS TAKEN
4002038c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40020390: 10 bf ff c7 b 400202ac <rtems_rfs_file_set_size+0x248> <== NOT EXECUTED
40020394: a8 10 00 13 mov %l3, %l4 <== NOT EXECUTED
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
40020398: 90 10 00 10 mov %l0, %o0
4002039c: 92 04 e0 34 add %l3, 0x34, %o1
400203a0: 7f ff f3 6b call 4001d14c <rtems_rfs_block_map_shrink>
400203a4: 94 10 00 19 mov %i1, %o2
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
400203a8: 82 92 20 00 orcc %o0, 0, %g1
400203ac: 14 bf ff c6 bg 400202c4 <rtems_rfs_file_set_size+0x260> <== NEVER TAKEN
400203b0: 01 00 00 00 nop
400203b4: f4 06 e0 3c ld [ %i3 + 0x3c ], %i2
400203b8: 10 bf ff ac b 40020268 <rtems_rfs_file_set_size+0x204>
400203bc: e6 06 20 1c ld [ %i0 + 0x1c ], %l3
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
400203c0: 80 a7 40 01 cmp %i5, %g1
400203c4: 2a bf ff b3 bcs,a 40020290 <rtems_rfs_file_set_size+0x22c>
400203c8: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
400203cc: 10 bf ff b8 b 400202ac <rtems_rfs_file_set_size+0x248>
400203d0: a8 10 00 13 mov %l3, %l4
40011e78 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
40011e78: 9d e3 be c8 save %sp, -312, %sp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
40011e7c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40011e80: 80 a0 60 00 cmp %g1, 0
40011e84: 32 80 00 88 bne,a 400120a4 <rtems_rfs_format+0x22c> <== NEVER TAKEN
40011e88: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
printf ("rtems-rfs: format: %s\n", name);
memset (&fs, 0, sizeof (rtems_rfs_file_system));
40011e8c: 92 10 20 00 clr %o1
40011e90: 94 10 20 84 mov 0x84, %o2
40011e94: 40 00 4c 3c call 40024f84 <memset>
40011e98: 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;
40011e9c: 82 07 bf c4 add %fp, -60, %g1
40011ea0: c2 27 bf c0 st %g1, [ %fp + -64 ]
head->previous = NULL;
tail->previous = head;
40011ea4: 82 07 bf c0 add %fp, -64, %g1
40011ea8: 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;
40011eac: 82 07 bf d4 add %fp, -44, %g1
40011eb0: c2 27 bf d0 st %g1, [ %fp + -48 ]
head->previous = NULL;
tail->previous = head;
40011eb4: 82 07 bf d0 add %fp, -48, %g1
40011eb8: 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;
40011ebc: 82 07 bf e4 add %fp, -28, %g1
40011ec0: c2 27 bf e0 st %g1, [ %fp + -32 ]
head->previous = NULL;
tail->previous = head;
40011ec4: 82 07 bf e0 add %fp, -32, %g1
40011ec8: 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;
40011ecc: 82 07 bf f4 add %fp, -12, %g1
40011ed0: c2 27 bf f0 st %g1, [ %fp + -16 ]
head->previous = NULL;
tail->previous = head;
40011ed4: 82 07 bf f0 add %fp, -16, %g1
40011ed8: 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;
40011edc: 82 10 20 05 mov 5, %g1
40011ee0: 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;
40011ee4: 82 10 20 02 mov 2, %g1
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
40011ee8: 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;
40011eec: c2 27 bf 7c st %g1, [ %fp + -132 ]
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
40011ef0: 40 00 2f 04 call 4001db00 <rtems_rfs_buffer_open>
40011ef4: 92 07 bf 7c add %fp, -132, %o1
if (rc > 0)
40011ef8: ba 92 20 00 orcc %o0, 0, %i5
40011efc: 14 80 02 bd bg 400129f0 <rtems_rfs_format+0xb78> <== NEVER TAKEN
40011f00: c2 07 bf 8c ld [ %fp + -116 ], %g1
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
40011f04: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
40011f08: 80 a7 20 00 cmp %i4, 0
40011f0c: 02 80 02 c2 be 40012a14 <rtems_rfs_format+0xb9c> <== NEVER TAKEN
40011f10: 92 10 20 00 clr %o1
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
40011f14: fa 06 40 00 ld [ %i1 ], %i5
if (!fs->block_size)
40011f18: 80 a7 60 00 cmp %i5, 0
40011f1c: 02 80 00 d1 be 40012260 <rtems_rfs_format+0x3e8>
40011f20: fa 27 bf 84 st %i5, [ %fp + -124 ]
if (fs->block_size > (4 * 1024))
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
40011f24: 90 10 00 1d mov %i5, %o0
40011f28: 40 00 7e 2b call 400317d4 <.urem>
40011f2c: 92 10 00 1c mov %i4, %o1
40011f30: 80 a2 20 00 cmp %o0, 0
40011f34: 32 80 00 ef bne,a 400122f0 <rtems_rfs_format+0x478> <== NEVER TAKEN
40011f38: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
40011f3c: c2 06 60 04 ld [ %i1 + 4 ], %g1
{
/*
* The number of blocks per group is defined by the number of bits in a
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
40011f40: bb 2f 60 03 sll %i5, 3, %i5
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
if (!fs->group_blocks)
40011f44: 80 a0 60 00 cmp %g1, 0
40011f48: 12 80 00 50 bne 40012088 <rtems_rfs_format+0x210> <== NEVER TAKEN
40011f4c: c2 27 bf a4 st %g1, [ %fp + -92 ]
{
/*
* The number of blocks per group is defined by the number of bits in a
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
40011f50: fa 27 bf a4 st %i5, [ %fp + -92 ]
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
40011f54: 40 00 39 3b call 40020440 <rtems_rfs_fs_media_size>
40011f58: 90 07 bf 7c add %fp, -132, %o0
40011f5c: fa 07 bf 84 ld [ %fp + -124 ], %i5
40011f60: 94 10 20 00 clr %o2
40011f64: 40 00 80 d9 call 400322c8 <__udivdi3>
40011f68: 96 10 00 1d mov %i5, %o3
40011f6c: d2 27 bf 80 st %o1, [ %fp + -128 ]
40011f70: b8 10 00 09 mov %o1, %i4
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
40011f74: b5 2f 60 03 sll %i5, 3, %i2
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
40011f78: 80 a2 60 00 cmp %o1, 0
40011f7c: 02 80 00 06 be 40011f94 <rtems_rfs_format+0x11c> <== NEVER TAKEN
40011f80: a0 10 20 01 mov 1, %l0
return 1;
return ((dividend - 1) / divisor) + 1;
40011f84: 90 02 7f ff add %o1, -1, %o0
40011f88: 7f ff c1 c6 call 400026a0 <.udiv>
40011f8c: 92 10 00 1a mov %i2, %o1
40011f90: a0 02 20 01 add %o0, 1, %l0
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
40011f94: f6 06 60 08 ld [ %i1 + 8 ], %i3
if (!fs->group_inodes)
40011f98: 80 a6 e0 00 cmp %i3, 0
40011f9c: 02 80 01 38 be 4001247c <rtems_rfs_format+0x604> <== ALWAYS TAKEN
40011fa0: e0 27 bf a0 st %l0, [ %fp + -96 ]
40011fa4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40011fa8: 7f ff c1 be call 400026a0 <.udiv> <== NOT EXECUTED
40011fac: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
40011fb0: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
40011fb4: d0 27 bf ac st %o0, [ %fp + -84 ] <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
40011fb8: 90 06 ff ff add %i3, -1, %o0 <== NOT EXECUTED
40011fbc: 7f ff c1 b9 call 400026a0 <.udiv>
40011fc0: 92 10 00 1c mov %i4, %o1
40011fc4: 90 02 20 01 inc %o0
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
fs->inodes_per_block) * fs->inodes_per_block;
40011fc8: 7f ff c1 7c call 400025b8 <.umul>
40011fcc: 92 10 00 1c mov %i4, %o1
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
40011fd0: 80 a6 80 08 cmp %i2, %o0
40011fd4: 0a 80 01 25 bcs 40012468 <rtems_rfs_format+0x5f0> <== NEVER TAKEN
40011fd8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
if (!fs->max_name_length)
40011fdc: 80 a0 60 00 cmp %g1, 0
40011fe0: 12 80 01 25 bne 40012474 <rtems_rfs_format+0x5fc> <== NEVER TAKEN
40011fe4: d0 27 bf a8 st %o0, [ %fp + -88 ]
{
fs->max_name_length = 512;
40011fe8: 82 10 22 00 mov 0x200, %g1
40011fec: c2 27 bf 98 st %g1, [ %fp + -104 ]
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
40011ff0: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40011ff4: 80 a0 60 00 cmp %g1, 0
40011ff8: 12 80 00 c5 bne 4001230c <rtems_rfs_format+0x494> <== NEVER TAKEN
40011ffc: 01 00 00 00 nop
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
40012000: 92 10 00 1d mov %i5, %o1
40012004: 40 00 2f 72 call 4001ddcc <rtems_rfs_buffer_setblksize>
40012008: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
4001200c: ba 92 20 00 orcc %o0, 0, %i5
40012010: 14 80 02 33 bg 400128dc <rtems_rfs_format+0xa64> <== NEVER TAKEN
40012014: 92 07 bf 30 add %fp, -208, %o1
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
40012018: c0 2f bf 30 clrb [ %fp + -208 ]
handle->bnum = 0;
4001201c: c0 27 bf 34 clr [ %fp + -204 ]
handle->buffer = NULL;
40012020: 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);
40012024: 90 07 bf 7c add %fp, -132, %o0
40012028: 94 10 20 00 clr %o2
4001202c: 40 00 2d fd call 4001d820 <rtems_rfs_buffer_handle_request>
40012030: 96 10 20 00 clr %o3
if (rc > 0)
40012034: ba 92 20 00 orcc %o0, 0, %i5
40012038: 04 80 00 20 ble 400120b8 <rtems_rfs_format+0x240> <== ALWAYS TAKEN
4001203c: 92 07 bf 30 add %fp, -208, %o1
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40012040: 40 00 2d 7e call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012044: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
40012048: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
4001204c: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
40012050: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
40012054: 40 00 50 94 call 400262a4 <strerror> <== NOT EXECUTED
40012058: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
4001205c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40012060: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012064: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012068: 40 00 4c 45 call 4002517c <printf> <== NOT EXECUTED
4001206c: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 400367f0 <_CPU_Trap_slot_template+0x308><== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
40012070: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
return -1;
40012074: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
40012078: 40 00 4c d9 call 400253dc <puts> <== NOT EXECUTED
4001207c: 90 12 21 20 or %o0, 0x120, %o0 <== NOT EXECUTED
40012080: 81 c7 e0 08 ret <== NOT EXECUTED
40012084: 81 e8 00 00 restore <== NOT EXECUTED
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
40012088: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED
4001208c: 08 bf ff b2 bleu 40011f54 <rtems_rfs_format+0xdc> <== NOT EXECUTED
40012090: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
{
printf ("group block count is higher than bits in block\n");
40012094: 40 00 4c d2 call 400253dc <puts> <== NOT EXECUTED
40012098: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 400365a8 <_CPU_Trap_slot_template+0xc0><== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
4001209c: 81 c7 e0 08 ret <== NOT EXECUTED
400120a0: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
printf ("rtems-rfs: format: %s\n", name);
400120a4: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
400120a8: 40 00 4c 35 call 4002517c <printf> <== NOT EXECUTED
400120ac: 90 12 20 f8 or %o0, 0xf8, %o0 ! 400364f8 <_CPU_Trap_slot_template+0x10><== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
400120b0: 10 bf ff 78 b 40011e90 <rtems_rfs_format+0x18> <== NOT EXECUTED
400120b4: 92 10 20 00 clr %o1 <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
400120b8: 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));
400120bc: 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);
400120c0: 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));
400120c4: 92 10 20 ff mov 0xff, %o1
400120c8: 40 00 4b af call 40024f84 <memset>
400120cc: 90 10 00 1d mov %i5, %o0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
400120d0: 82 10 20 28 mov 0x28, %g1
400120d4: c2 2f 40 00 stb %g1, [ %i5 ]
400120d8: 82 10 20 09 mov 9, %g1
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400120dc: 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);
400120e0: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
400120e4: c0 2f 60 05 clrb [ %i5 + 5 ]
400120e8: c0 2f 60 06 clrb [ %i5 + 6 ]
400120ec: 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);
400120f0: 84 10 20 01 mov 1, %g2
400120f4: 82 10 20 20 mov 0x20, %g1
400120f8: c4 2f 60 03 stb %g2, [ %i5 + 3 ]
400120fc: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40012100: c6 0f bf 84 ldub [ %fp + -124 ], %g3
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
40012104: c2 07 bf 80 ld [ %fp + -128 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40012108: c6 2f 60 08 stb %g3, [ %i5 + 8 ]
4001210c: c6 17 bf 84 lduh [ %fp + -124 ], %g3
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
40012110: c2 2f 60 0f stb %g1, [ %i5 + 0xf ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40012114: c6 2f 60 09 stb %g3, [ %i5 + 9 ]
40012118: c8 07 bf 84 ld [ %fp + -124 ], %g4
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
4001211c: 87 30 60 18 srl %g1, 0x18, %g3
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40012120: 89 31 20 08 srl %g4, 8, %g4
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
40012124: c6 2f 60 0c stb %g3, [ %i5 + 0xc ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40012128: c8 2f 60 0a stb %g4, [ %i5 + 0xa ]
4001212c: c6 07 bf 84 ld [ %fp + -124 ], %g3
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
40012130: 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));
40012134: c6 2f 60 0b stb %g3, [ %i5 + 0xb ]
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
40012138: 87 30 60 10 srl %g1, 0x10, %g3
4001213c: 83 30 60 08 srl %g1, 8, %g1
40012140: c6 2f 60 0d stb %g3, [ %i5 + 0xd ]
40012144: c2 2f 60 0e stb %g1, [ %i5 + 0xe ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
40012148: c2 0f bf 94 ldub [ %fp + -108 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
4001214c: 92 07 bf 30 add %fp, -208, %o1
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
40012150: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
40012154: c2 17 bf 94 lduh [ %fp + -108 ], %g1
40012158: c2 2f 60 11 stb %g1, [ %i5 + 0x11 ]
4001215c: c2 07 bf 94 ld [ %fp + -108 ], %g1
40012160: 83 30 60 08 srl %g1, 8, %g1
40012164: c2 2f 60 12 stb %g1, [ %i5 + 0x12 ]
40012168: c2 07 bf 94 ld [ %fp + -108 ], %g1
4001216c: c2 2f 60 13 stb %g1, [ %i5 + 0x13 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
40012170: c2 0f bf 98 ldub [ %fp + -104 ], %g1
40012174: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
40012178: c2 17 bf 98 lduh [ %fp + -104 ], %g1
4001217c: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
40012180: c2 07 bf 98 ld [ %fp + -104 ], %g1
40012184: 83 30 60 08 srl %g1, 8, %g1
40012188: c2 2f 60 16 stb %g1, [ %i5 + 0x16 ]
4001218c: c2 07 bf 98 ld [ %fp + -104 ], %g1
40012190: c2 2f 60 17 stb %g1, [ %i5 + 0x17 ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
40012194: c2 0f bf a0 ldub [ %fp + -96 ], %g1
40012198: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ]
4001219c: c2 17 bf a0 lduh [ %fp + -96 ], %g1
400121a0: c2 2f 60 19 stb %g1, [ %i5 + 0x19 ]
400121a4: c2 07 bf a0 ld [ %fp + -96 ], %g1
400121a8: 83 30 60 08 srl %g1, 8, %g1
400121ac: c2 2f 60 1a stb %g1, [ %i5 + 0x1a ]
400121b0: c2 07 bf a0 ld [ %fp + -96 ], %g1
400121b4: c2 2f 60 1b stb %g1, [ %i5 + 0x1b ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
400121b8: c2 0f bf a4 ldub [ %fp + -92 ], %g1
400121bc: c2 2f 60 1c stb %g1, [ %i5 + 0x1c ]
400121c0: c2 17 bf a4 lduh [ %fp + -92 ], %g1
400121c4: c2 2f 60 1d stb %g1, [ %i5 + 0x1d ]
400121c8: c2 07 bf a4 ld [ %fp + -92 ], %g1
400121cc: 83 30 60 08 srl %g1, 8, %g1
400121d0: c2 2f 60 1e stb %g1, [ %i5 + 0x1e ]
400121d4: c2 07 bf a4 ld [ %fp + -92 ], %g1
400121d8: c2 2f 60 1f stb %g1, [ %i5 + 0x1f ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
400121dc: c2 0f bf a8 ldub [ %fp + -88 ], %g1
400121e0: c2 2f 60 20 stb %g1, [ %i5 + 0x20 ]
400121e4: c2 17 bf a8 lduh [ %fp + -88 ], %g1
400121e8: c2 2f 60 21 stb %g1, [ %i5 + 0x21 ]
400121ec: c2 07 bf a8 ld [ %fp + -88 ], %g1
400121f0: 83 30 60 08 srl %g1, 8, %g1
400121f4: c2 2f 60 22 stb %g1, [ %i5 + 0x22 ]
400121f8: c2 07 bf a8 ld [ %fp + -88 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
400121fc: 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);
40012200: c2 2f 60 23 stb %g1, [ %i5 + 0x23 ]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
40012204: c0 2f 60 25 clrb [ %i5 + 0x25 ]
40012208: c0 2f 60 26 clrb [ %i5 + 0x26 ]
4001220c: 82 10 20 38 mov 0x38, %g1
40012210: c2 2f 60 27 stb %g1, [ %i5 + 0x27 ]
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
40012214: 40 00 2d 09 call 4001d638 <rtems_rfs_buffer_handle_release>
40012218: c4 2f bf 30 stb %g2, [ %fp + -208 ]
if (rc > 0)
4001221c: ba 92 20 00 orcc %o0, 0, %i5
40012220: 04 80 00 e3 ble 400125ac <rtems_rfs_format+0x734> <== ALWAYS TAKEN
40012224: 92 07 bf 30 add %fp, -208, %o1
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40012228: 40 00 2d 04 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001222c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
40012230: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
40012234: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
40012238: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
4001223c: 40 00 50 1a call 400262a4 <strerror> <== NOT EXECUTED
40012240: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
40012244: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40012248: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4001224c: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
40012250: 40 00 4b cb call 4002517c <printf> <== NOT EXECUTED
40012254: 90 12 20 28 or %o0, 0x28, %o0 ! 40036828 <_CPU_Trap_slot_template+0x340><== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
40012258: 10 bf ff 87 b 40012074 <rtems_rfs_format+0x1fc> <== NOT EXECUTED
4001225c: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
if (!fs->block_size)
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
40012260: 40 00 38 78 call 40020440 <rtems_rfs_fs_media_size>
40012264: 90 07 bf 7c add %fp, -132, %o0
if (total_size >= GIGS (1))
40012268: 80 a2 20 00 cmp %o0, 0
4001226c: 22 80 00 9f be,a 400124e8 <rtems_rfs_format+0x670> <== ALWAYS TAKEN
40012270: 03 00 03 ff sethi %hi(0xffc00), %g1
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
40012274: b4 10 20 00 clr %i2 <== NOT EXECUTED
40012278: 37 00 04 00 sethi %hi(0x100000), %i3 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
4001227c: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
40012280: ba 82 40 1b addcc %o1, %i3, %i5 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
40012284: 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);
40012288: b8 42 00 1a addx %o0, %i2, %i4 <== NOT EXECUTED
4001228c: 85 37 60 14 srl %i5, 0x14, %g2 <== NOT EXECUTED
40012290: 89 2f 20 0c sll %i4, 0xc, %g4 <== NOT EXECUTED
40012294: 10 80 00 04 b 400122a4 <rtems_rfs_format+0x42c> <== NOT EXECUTED
40012298: 84 11 00 02 or %g4, %g2, %g2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
4001229c: 02 80 00 06 be 400122b4 <rtems_rfs_format+0x43c> <== NOT EXECUTED
400122a0: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
400122a4: bb 28 c0 01 sll %g3, %g1, %i5 <== NOT EXECUTED
400122a8: 80 8f 40 02 btst %i5, %g2 <== NOT EXECUTED
400122ac: 02 bf ff fc be 4001229c <rtems_rfs_format+0x424> <== NOT EXECUTED
400122b0: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
break;
fs->block_size = 1 << b;
}
if (fs->block_size < 512)
400122b4: 80 a7 61 ff cmp %i5, 0x1ff <== NOT EXECUTED
400122b8: 18 80 00 94 bgu 40012508 <rtems_rfs_format+0x690> <== NOT EXECUTED
400122bc: fa 27 bf 84 st %i5, [ %fp + -124 ] <== NOT EXECUTED
400122c0: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
fs->block_size = 512;
400122c4: ba 10 22 00 mov 0x200, %i5
400122c8: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
400122cc: 82 10 22 00 mov 0x200, %g1
if (fs->block_size > (4 * 1024))
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
400122d0: 90 10 00 1d mov %i5, %o0
break;
fs->block_size = 1 << b;
}
if (fs->block_size < 512)
fs->block_size = 512;
400122d4: c2 27 bf 84 st %g1, [ %fp + -124 ]
if (fs->block_size > (4 * 1024))
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
400122d8: 40 00 7d 3f call 400317d4 <.urem>
400122dc: 92 10 00 1c mov %i4, %o1
400122e0: 80 a2 20 00 cmp %o0, 0
400122e4: 22 bf ff 17 be,a 40011f40 <rtems_rfs_format+0xc8> <== ALWAYS TAKEN
400122e8: c2 06 60 04 ld [ %i1 + 4 ], %g1
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
400122ec: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400122f0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
400122f4: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
400122f8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
400122fc: 40 00 4b a0 call 4002517c <printf> <== NOT EXECUTED
40012300: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED
40012304: 81 c7 e0 08 ret <== NOT EXECUTED
40012308: 81 e8 00 00 restore <== NOT EXECUTED
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
4001230c: 40 00 38 4d call 40020440 <rtems_rfs_fs_media_size> <== NOT EXECUTED
40012310: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
40012314: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED
40012318: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4001231c: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012320: 40 00 4b 97 call 4002517c <printf> <== NOT EXECUTED
40012324: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 400365d8 <_CPU_Trap_slot_template+0xf0><== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
rtems_rfs_fs_media_blocks (&fs));
40012328: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
4001232c: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012330: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
40012334: 40 00 4b 92 call 4002517c <printf> <== NOT EXECUTED
40012338: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
rtems_rfs_fs_media_block_size (&fs));
4001233c: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
40012340: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012344: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 <== NOT EXECUTED
40012348: 40 00 4b 8d call 4002517c <printf> <== NOT EXECUTED
4001234c: 90 12 22 28 or %o0, 0x228, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
40012350: 40 00 38 33 call 4002041c <rtems_rfs_fs_size> <== NOT EXECUTED
40012354: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
40012358: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED
4001235c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40012360: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012364: 40 00 4b 86 call 4002517c <printf> <== NOT EXECUTED
40012368: 90 12 22 58 or %o0, 0x258, %o0 ! 40036658 <_CPU_Trap_slot_template+0x170><== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
4001236c: d2 07 bf 80 ld [ %fp + -128 ], %o1 <== NOT EXECUTED
40012370: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012374: 40 00 4b 82 call 4002517c <printf> <== NOT EXECUTED
40012378: 90 12 22 78 or %o0, 0x278, %o0 ! 40036678 <_CPU_Trap_slot_template+0x190><== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
4001237c: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
40012380: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012384: 40 00 4b 7e call 4002517c <printf> <== NOT EXECUTED
40012388: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 400366a0 <_CPU_Trap_slot_template+0x1b8><== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4001238c: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
40012390: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012394: 93 2a 60 03 sll %o1, 3, %o1 <== NOT EXECUTED
40012398: 40 00 4b 79 call 4002517c <printf> <== NOT EXECUTED
4001239c: 90 12 22 c8 or %o0, 0x2c8, %o0 <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
400123a0: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
400123a4: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
400123a8: 40 00 4b 75 call 4002517c <printf> <== NOT EXECUTED
400123ac: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 400366f0 <_CPU_Trap_slot_template+0x208><== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
400123b0: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
400123b4: 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",
400123b8: 7f ff c0 80 call 400025b8 <.umul> <== NOT EXECUTED
400123bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
400123c0: 83 2f 60 03 sll %i5, 3, %g1 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
400123c4: 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,
400123c8: bb 2f 60 06 sll %i5, 6, %i5 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
400123cc: f8 07 bf 84 ld [ %fp + -124 ], %i4 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
400123d0: ba a7 40 01 subcc %i5, %g1, %i5 <== NOT EXECUTED
400123d4: 12 80 00 55 bne 40012528 <rtems_rfs_format+0x6b0> <== NOT EXECUTED
400123d8: 90 10 27 d0 mov 0x7d0, %o0 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
400123dc: 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));
400123e0: 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))
400123e4: 92 00 7f ff add %g1, -1, %o1 <== NOT EXECUTED
400123e8: 80 a7 00 09 cmp %i4, %o1 <== NOT EXECUTED
400123ec: 28 80 00 02 bleu,a 400123f4 <rtems_rfs_format+0x57c> <== NOT EXECUTED
400123f0: 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;
400123f4: 7f ff c0 ad call 400026a8 <.div> <== NOT EXECUTED
400123f8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
400123fc: 92 10 20 0a mov 0xa, %o1 ! a <PROM_START+0xa> <== NOT EXECUTED
40012400: 7f ff c0 aa call 400026a8 <.div> <== NOT EXECUTED
40012404: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
40012408: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
4001240c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
40012410: 40 00 7c f3 call 400317dc <.rem> <== NOT EXECUTED
40012414: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40012418: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4001241c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40012420: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40012424: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012428: 40 00 4b 55 call 4002517c <printf> <== NOT EXECUTED
4001242c: 90 12 23 18 or %o0, 0x318, %o0 ! 40036718 <_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);
40012430: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
40012434: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012438: 40 00 4b 51 call 4002517c <printf> <== NOT EXECUTED
4001243c: 90 12 23 48 or %o0, 0x348, %o0 ! 40036748 <_CPU_Trap_slot_template+0x260><== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
40012440: d2 07 bf a4 ld [ %fp + -92 ], %o1 <== NOT EXECUTED
40012444: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012448: 40 00 4b 4d call 4002517c <printf> <== NOT EXECUTED
4001244c: 90 12 23 68 or %o0, 0x368, %o0 ! 40036768 <_CPU_Trap_slot_template+0x280><== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
40012450: d2 07 bf a8 ld [ %fp + -88 ], %o1 <== NOT EXECUTED
40012454: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012458: 40 00 4b 49 call 4002517c <printf> <== NOT EXECUTED
4001245c: 90 12 23 90 or %o0, 0x390, %o0 ! 40036790 <_CPU_Trap_slot_template+0x2a8><== NOT EXECUTED
40012460: 10 bf fe e8 b 40012000 <rtems_rfs_format+0x188> <== NOT EXECUTED
40012464: fa 07 bf 84 ld [ %fp + -124 ], %i5 <== NOT EXECUTED
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
if (!fs->max_name_length)
40012468: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001246c: 02 bf fe df be 40011fe8 <rtems_rfs_format+0x170> <== NOT EXECUTED
40012470: f4 27 bf a8 st %i2, [ %fp + -88 ] <== NOT EXECUTED
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
40012474: 10 bf fe df b 40011ff0 <rtems_rfs_format+0x178> <== NOT EXECUTED
40012478: c2 27 bf 98 st %g1, [ %fp + -104 ] <== NOT EXECUTED
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
/*
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
4001247c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40012480: 80 a0 60 00 cmp %g1, 0
40012484: 02 80 00 03 be 40012490 <rtems_rfs_format+0x618> <== ALWAYS TAKEN
40012488: 90 10 20 01 mov 1, %o0
4001248c: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
40012490: 7f ff c0 4a call 400025b8 <.umul>
40012494: 92 07 3f ff add %i4, -1, %o1
40012498: 92 10 20 64 mov 0x64, %o1
4001249c: 7f ff c0 81 call 400026a0 <.udiv>
400124a0: b6 10 20 01 mov 1, %i3
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
400124a4: 80 a2 20 00 cmp %o0, 0
400124a8: 32 80 00 30 bne,a 40012568 <rtems_rfs_format+0x6f0>
400124ac: 92 10 00 10 mov %l0, %o1
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
400124b0: 92 10 20 38 mov 0x38, %o1
400124b4: 7f ff c0 7b call 400026a0 <.udiv>
400124b8: 90 10 00 1d mov %i5, %o0
400124bc: b8 10 00 08 mov %o0, %i4
400124c0: 90 10 00 1b mov %i3, %o0
400124c4: 7f ff c0 3d call 400025b8 <.umul>
400124c8: 92 10 00 1c mov %i4, %o1
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
400124cc: f8 27 bf ac st %i4, [ %fp + -84 ]
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
400124d0: b6 10 00 08 mov %o0, %i3
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
400124d4: 80 a6 e0 00 cmp %i3, 0
400124d8: 02 bf fe bc be 40011fc8 <rtems_rfs_format+0x150> <== NEVER TAKEN
400124dc: 90 10 20 01 mov 1, %o0
return 1;
return ((dividend - 1) / divisor) + 1;
400124e0: 10 bf fe b7 b 40011fbc <rtems_rfs_format+0x144>
400124e4: 90 06 ff ff add %i3, -1, %o0
fs->block_size = config->block_size;
if (!fs->block_size)
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
if (total_size >= GIGS (1))
400124e8: 82 10 63 ff or %g1, 0x3ff, %g1
400124ec: 80 a2 40 01 cmp %o1, %g1
400124f0: 18 bf ff 62 bgu 40012278 <rtems_rfs_format+0x400> <== NEVER TAKEN
400124f4: b4 10 20 00 clr %i2
400124f8: fa 07 bf 84 ld [ %fp + -124 ], %i5
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
}
if (fs->block_size < 512)
400124fc: 80 a7 61 ff cmp %i5, 0x1ff
40012500: 08 bf ff 71 bleu 400122c4 <rtems_rfs_format+0x44c> <== ALWAYS TAKEN
40012504: c2 07 bf 8c ld [ %fp + -116 ], %g1
fs->block_size = 512;
if (fs->block_size > (4 * 1024))
40012508: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
4001250c: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
40012510: 08 80 02 06 bleu 40012d28 <rtems_rfs_format+0xeb0> <== NOT EXECUTED
40012514: c4 07 bf 8c ld [ %fp + -116 ], %g2 <== NOT EXECUTED
fs->block_size = (4 * 1024);
40012518: c2 27 bf 84 st %g1, [ %fp + -124 ] <== NOT EXECUTED
4001251c: f8 00 a0 20 ld [ %g2 + 0x20 ], %i4 <== NOT EXECUTED
40012520: 10 bf fe 81 b 40011f24 <rtems_rfs_format+0xac> <== NOT EXECUTED
40012524: ba 10 00 01 mov %g1, %i5 <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
40012528: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001252c: 7f ff c0 5d call 400026a0 <.udiv> <== NOT EXECUTED
40012530: 90 07 7f ff add %i5, -1, %o0 <== NOT EXECUTED
40012534: 90 02 20 02 add %o0, 2, %o0 <== NOT EXECUTED
40012538: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
4001253c: 85 2a 20 07 sll %o0, 7, %g2 <== NOT EXECUTED
40012540: 84 20 80 01 sub %g2, %g1, %g2 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
40012544: c2 07 bf 80 ld [ %fp + -128 ], %g1 <== NOT EXECUTED
40012548: 84 00 80 08 add %g2, %o0, %g2 <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
4001254c: 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))
40012550: 92 00 7f ff add %g1, -1, %o1 <== NOT EXECUTED
40012554: 80 a7 00 09 cmp %i4, %o1 <== NOT EXECUTED
40012558: 18 bf ff a7 bgu 400123f4 <rtems_rfs_format+0x57c> <== NOT EXECUTED
4001255c: 91 28 a0 03 sll %g2, 3, %o0 <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
40012560: 10 bf ff a5 b 400123f4 <rtems_rfs_format+0x57c> <== NOT EXECUTED
40012564: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
40012568: 7f ff c0 4e call 400026a0 <.udiv>
4001256c: 90 02 3f ff add %o0, -1, %o0
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40012570: 92 10 20 38 mov 0x38, %o1
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
40012574: b6 02 20 01 add %o0, 1, %i3
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40012578: 7f ff c0 4a call 400026a0 <.udiv>
4001257c: 90 10 00 1d mov %i5, %o0
40012580: b8 10 00 08 mov %o0, %i4
40012584: 90 10 00 1b mov %i3, %o0
40012588: 7f ff c0 0c call 400025b8 <.umul>
4001258c: 92 10 00 1c mov %i4, %o1
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
40012590: f8 27 bf ac st %i4, [ %fp + -84 ]
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
40012594: b6 10 00 08 mov %o0, %i3
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
40012598: 80 a6 e0 00 cmp %i3, 0
4001259c: 02 bf fe 8b be 40011fc8 <rtems_rfs_format+0x150> <== NEVER TAKEN
400125a0: 90 10 20 01 mov 1, %o0
return 1;
return ((dividend - 1) / divisor) + 1;
400125a4: 10 bf fe 86 b 40011fbc <rtems_rfs_format+0x144>
400125a8: 90 06 ff ff add %i3, -1, %o0
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
400125ac: 90 07 bf 7c add %fp, -132, %o0
400125b0: 40 00 2c 22 call 4001d638 <rtems_rfs_buffer_handle_release>
400125b4: 92 07 bf 30 add %fp, -208, %o1
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
400125b8: c2 07 bf a0 ld [ %fp + -96 ], %g1
400125bc: 80 a0 60 00 cmp %g1, 0
400125c0: 04 80 01 36 ble 40012a98 <rtems_rfs_format+0xc20> <== NEVER TAKEN
400125c4: c2 07 bf 80 ld [ %fp + -128 ], %g1
if (!rtems_rfs_write_group (&fs, group,
400125c8: e2 0e 60 14 ldub [ %i1 + 0x14 ], %l1
400125cc: c4 0e 60 15 ldub [ %i1 + 0x15 ], %g2
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
400125d0: 80 a0 60 00 cmp %g1, 0
400125d4: 02 80 01 2f be 40012a90 <rtems_rfs_format+0xc18> <== NEVER TAKEN
400125d8: f8 07 bf a4 ld [ %fp + -92 ], %i4
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
400125dc: 27 10 00 da sethi %hi(0x40036800), %l3
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
400125e0: 25 10 00 da sethi %hi(0x40036800), %l2
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
400125e4: 2b 10 00 da sethi %hi(0x40036800), %l5
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
400125e8: b6 10 20 01 mov 1, %i3
400125ec: a0 10 20 00 clr %l0
400125f0: b4 10 20 00 clr %i2
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
400125f4: a6 14 e0 a8 or %l3, 0xa8, %l3
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
400125f8: a4 14 a0 e0 or %l2, 0xe0, %l2
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
400125fc: a8 10 20 01 mov 1, %l4
if (verbose)
printf (", inodes");
40012600: aa 15 61 d0 or %l5, 0x1d0, %l5
/*
* Be nice to strange sizes of disks. These are embedded systems after all
* and nice numbers do not always work out. Let the last block pick up the
* remainder of the blocks.
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
40012604: 86 06 c0 1c add %i3, %i4, %g3
40012608: 80 a0 c0 01 cmp %g3, %g1
4001260c: 38 80 00 02 bgu,a 40012614 <rtems_rfs_format+0x79c> <== ALWAYS TAKEN
40012610: b8 20 40 1b sub %g1, %i3, %i4
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
40012614: ac 88 a0 ff andcc %g2, 0xff, %l6
40012618: 12 80 00 3b bne 40012704 <rtems_rfs_format+0x88c> <== NEVER TAKEN
4001261c: 90 10 00 13 mov %l3, %o0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
40012620: c0 2f bf 30 clrb [ %fp + -208 ]
handle->bnum = 0;
40012624: c0 27 bf 34 clr [ %fp + -204 ]
handle->buffer = NULL;
40012628: c0 27 bf 38 clr [ %fp + -200 ]
printf (", blocks");
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
4001262c: 90 07 bf 3c add %fp, -196, %o0
40012630: 92 07 bf 7c add %fp, -132, %o1
40012634: 94 07 bf 30 add %fp, -208, %o2
40012638: 96 10 00 1c mov %i4, %o3
4001263c: 40 00 27 66 call 4001c3d4 <rtems_rfs_bitmap_open>
40012640: 98 10 00 1b mov %i3, %o4
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
40012644: ba 92 20 00 orcc %o0, 0, %i5
40012648: 04 80 00 12 ble 40012690 <rtems_rfs_format+0x818> <== ALWAYS TAKEN
4001264c: 92 07 bf 30 add %fp, -208, %o1
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40012650: 40 00 2b fa call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012654: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
40012658: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
4001265c: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
40012660: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
40012664: 40 00 4f 10 call 400262a4 <strerror> <== NOT EXECUTED
40012668: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
4001266c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40012670: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40012674: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
40012678: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
4001267c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
40012680: 40 00 4a bf call 4002517c <printf> <== NOT EXECUTED
40012684: 90 12 20 f0 or %o0, 0xf0, %o0 <== NOT EXECUTED
40012688: 81 c7 e0 08 ret <== NOT EXECUTED
4001268c: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40012690: c2 07 bf 38 ld [ %fp + -200 ], %g1
40012694: d4 07 bf 84 ld [ %fp + -124 ], %o2
40012698: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
4001269c: 40 00 4a 3a call 40024f84 <memset>
400126a0: 92 10 20 ff mov 0xff, %o1
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
400126a4: 40 00 26 a4 call 4001c134 <rtems_rfs_bitmap_map_clear_all>
400126a8: 90 07 bf 3c add %fp, -196, %o0
if (rc > 0)
400126ac: ba 92 20 00 orcc %o0, 0, %i5
400126b0: 04 80 00 20 ble 40012730 <rtems_rfs_format+0x8b8> <== ALWAYS TAKEN
400126b4: 92 10 20 00 clr %o1
{
rtems_rfs_bitmap_close (&bitmap);
400126b8: 40 00 27 58 call 4001c418 <rtems_rfs_bitmap_close> <== NOT EXECUTED
400126bc: 90 07 bf 3c add %fp, -196, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
400126c0: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
400126c4: 40 00 2b dd call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400126c8: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
400126cc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
400126d0: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
400126d4: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
400126d8: 40 00 4e f3 call 400262a4 <strerror> <== NOT EXECUTED
400126dc: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
400126e0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
400126e4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400126e8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400126ec: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
400126f0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
{
rtems_rfs_bitmap_close (&bitmap);
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
400126f4: 40 00 4a a2 call 4002517c <printf> <== NOT EXECUTED
400126f8: 90 12 21 38 or %o0, 0x138, %o0 <== NOT EXECUTED
400126fc: 81 c7 e0 08 ret <== NOT EXECUTED
40012700: 81 e8 00 00 restore <== NOT EXECUTED
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
40012704: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40012708: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4001270c: 40 00 4a 9c call 4002517c <printf> <== NOT EXECUTED
40012710: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
40012714: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
40012718: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
4001271c: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
40012720: 40 00 4a 97 call 4002517c <printf> <== NOT EXECUTED
40012724: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40012728: 10 bf ff c2 b 40012630 <rtems_rfs_format+0x7b8> <== NOT EXECUTED
4001272c: 90 07 bf 3c add %fp, -196, %o0 <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
40012730: 40 00 25 fa call 4001bf18 <rtems_rfs_bitmap_map_set>
40012734: 90 07 bf 3c add %fp, -196, %o0
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
40012738: 92 10 20 01 mov 1, %o1
4001273c: 40 00 25 f7 call 4001bf18 <rtems_rfs_bitmap_map_set>
40012740: 90 07 bf 3c add %fp, -196, %o0
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
40012744: d0 07 bf a8 ld [ %fp + -88 ], %o0
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
40012748: 80 a2 20 00 cmp %o0, 0
4001274c: 12 80 00 2b bne 400127f8 <rtems_rfs_format+0x980> <== ALWAYS TAKEN
40012750: d2 07 bf ac ld [ %fp + -84 ], %o1
return 1;
40012754: ae 10 20 01 mov 1, %l7 <== NOT EXECUTED
40012758: ba 10 20 00 clr %i5 <== NOT EXECUTED
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
4001275c: 92 07 60 02 add %i5, 2, %o1
40012760: 40 00 25 ee call 4001bf18 <rtems_rfs_bitmap_map_set>
40012764: 90 07 bf 3c add %fp, -196, %o0
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
40012768: ba 07 60 01 inc %i5
4001276c: 80 a7 40 17 cmp %i5, %l7
40012770: 06 bf ff fc bl 40012760 <rtems_rfs_format+0x8e8>
40012774: 92 07 60 02 add %i5, 2, %o1
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
40012778: 40 00 27 28 call 4001c418 <rtems_rfs_bitmap_close>
4001277c: 90 07 bf 3c add %fp, -196, %o0
if (rc > 0)
40012780: ba 92 20 00 orcc %o0, 0, %i5
40012784: 14 80 00 24 bg 40012814 <rtems_rfs_format+0x99c> <== NEVER TAKEN
40012788: 80 a5 a0 00 cmp %l6, 0
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
4001278c: 12 80 00 50 bne 400128cc <rtems_rfs_format+0xa54> <== NEVER TAKEN
40012790: e8 2f bf 30 stb %l4, [ %fp + -208 ]
printf (", inodes");
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
40012794: 90 07 bf 3c add %fp, -196, %o0
40012798: 92 07 bf 7c add %fp, -132, %o1
4001279c: 94 07 bf 30 add %fp, -208, %o2
400127a0: 96 10 00 1c mov %i4, %o3
400127a4: 40 00 27 0c call 4001c3d4 <rtems_rfs_bitmap_open>
400127a8: 98 04 20 02 add %l0, 2, %o4
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
400127ac: ba 92 20 00 orcc %o0, 0, %i5
400127b0: 04 80 00 2a ble 40012858 <rtems_rfs_format+0x9e0> <== ALWAYS TAKEN
400127b4: 92 07 bf 30 add %fp, -208, %o1
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
400127b8: 40 00 2b a0 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400127bc: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
400127c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
400127c4: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
400127c8: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
400127cc: 40 00 4e b6 call 400262a4 <strerror> <== NOT EXECUTED
400127d0: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
400127d4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
400127d8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400127dc: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400127e0: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
400127e4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
400127e8: 40 00 4a 65 call 4002517c <printf> <== NOT EXECUTED
400127ec: 90 12 21 e0 or %o0, 0x1e0, %o0 <== NOT EXECUTED
400127f0: 81 c7 e0 08 ret <== NOT EXECUTED
400127f4: 81 e8 00 00 restore <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
400127f8: 7f ff bf aa call 400026a0 <.udiv>
400127fc: 90 02 3f ff add %o0, -1, %o0
40012800: ae 02 20 01 add %o0, 1, %l7
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
40012804: 80 a5 e0 00 cmp %l7, 0
40012808: 14 bf ff d5 bg 4001275c <rtems_rfs_format+0x8e4> <== ALWAYS TAKEN
4001280c: ba 10 20 00 clr %i5
40012810: 30 bf ff da b,a 40012778 <rtems_rfs_format+0x900> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40012814: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
40012818: 40 00 2b 88 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001281c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
40012820: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
40012824: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
40012828: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
4001282c: 40 00 4e 9e call 400262a4 <strerror> <== NOT EXECUTED
40012830: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
40012834: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40012838: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
4001283c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
40012840: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
40012844: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
40012848: 40 00 4a 4d call 4002517c <printf> <== NOT EXECUTED
4001284c: 90 12 21 88 or %o0, 0x188, %o0 <== NOT EXECUTED
40012850: 81 c7 e0 08 ret <== NOT EXECUTED
40012854: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
40012858: c2 07 bf 38 ld [ %fp + -200 ], %g1
4001285c: d4 07 bf 84 ld [ %fp + -124 ], %o2
40012860: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
40012864: 40 00 49 c8 call 40024f84 <memset>
40012868: 92 10 20 00 clr %o1
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
4001286c: 40 00 26 32 call 4001c134 <rtems_rfs_bitmap_map_clear_all>
40012870: 90 07 bf 3c add %fp, -196, %o0
40012874: ba 10 00 08 mov %o0, %i5
if (rc > 0)
40012878: 80 a7 60 00 cmp %i5, 0
4001287c: 04 80 00 21 ble 40012900 <rtems_rfs_format+0xa88> <== ALWAYS TAKEN
40012880: 90 07 bf 3c add %fp, -196, %o0
{
rtems_rfs_bitmap_close (&bitmap);
40012884: 40 00 26 e5 call 4001c418 <rtems_rfs_bitmap_close> <== NOT EXECUTED
40012888: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
4001288c: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
40012890: 40 00 2b 6a call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012894: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
40012898: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
4001289c: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
400128a0: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
400128a4: 40 00 4e 80 call 400262a4 <strerror> <== NOT EXECUTED
400128a8: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
400128ac: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
400128b0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400128b4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400128b8: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
400128bc: 40 00 4a 30 call 4002517c <printf> <== NOT EXECUTED
400128c0: 90 12 22 28 or %o0, 0x228, %o0 ! 40036a28 <_CPU_Trap_slot_template+0x540><== NOT EXECUTED
400128c4: 81 c7 e0 08 ret <== NOT EXECUTED
400128c8: 81 e8 00 00 restore <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
400128cc: 40 00 4a 2c call 4002517c <printf> <== NOT EXECUTED
400128d0: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
400128d4: 10 bf ff b1 b 40012798 <rtems_rfs_format+0x920> <== NOT EXECUTED
400128d8: 90 07 bf 3c add %fp, -196, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
if (rc > 0)
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
400128dc: 40 00 4e 72 call 400262a4 <strerror> <== NOT EXECUTED
400128e0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400128e4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400128e8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400128ec: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
400128f0: 40 00 4a 23 call 4002517c <printf> <== NOT EXECUTED
400128f4: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 400367b8 <_CPU_Trap_slot_template+0x2d0><== NOT EXECUTED
400128f8: 81 c7 e0 08 ret <== NOT EXECUTED
400128fc: 81 e8 00 00 restore <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
40012900: 40 00 26 c6 call 4001c418 <rtems_rfs_bitmap_close>
40012904: 01 00 00 00 nop
if (rc > 0)
40012908: ba 92 20 00 orcc %o0, 0, %i5
4001290c: 14 80 00 2a bg 400129b4 <rtems_rfs_format+0xb3c> <== NEVER TAKEN
40012910: 80 8c 60 ff btst 0xff, %l1
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
40012914: 02 80 00 46 be 40012a2c <rtems_rfs_format+0xbb4> <== ALWAYS TAKEN
40012918: e8 2f bf 30 stb %l4, [ %fp + -208 ]
{
for (b = 0; b < blocks; b++)
4001291c: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
40012920: 04 80 00 43 ble 40012a2c <rtems_rfs_format+0xbb4> <== NOT EXECUTED
40012924: b6 06 e0 02 add %i3, 2, %i3 <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
40012928: 10 80 00 0a b 40012950 <rtems_rfs_format+0xad8> <== NOT EXECUTED
4001292c: ae 05 c0 1b add %l7, %i3, %l7 <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40012930: c2 07 bf 38 ld [ %fp + -200 ], %g1 <== NOT EXECUTED
40012934: d4 07 bf 84 ld [ %fp + -124 ], %o2 <== NOT EXECUTED
40012938: d0 00 60 1c ld [ %g1 + 0x1c ], %o0 <== NOT EXECUTED
4001293c: 40 00 49 92 call 40024f84 <memset> <== NOT EXECUTED
40012940: b6 06 e0 01 inc %i3 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
40012944: 80 a6 c0 17 cmp %i3, %l7 <== NOT EXECUTED
40012948: 02 80 00 39 be 40012a2c <rtems_rfs_format+0xbb4> <== NOT EXECUTED
4001294c: e8 2f bf 30 stb %l4, [ %fp + -208 ] <== NOT EXECUTED
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
40012950: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
40012954: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
40012958: 96 10 20 00 clr %o3 <== NOT EXECUTED
4001295c: 40 00 2b b1 call 4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40012960: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
40012964: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
40012968: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4001296c: 04 bf ff f1 ble 40012930 <rtems_rfs_format+0xab8> <== NOT EXECUTED
40012970: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40012974: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
40012978: 40 00 2b 30 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001297c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
40012980: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
40012984: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
40012988: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
4001298c: 40 00 4e 46 call 400262a4 <strerror> <== NOT EXECUTED
40012990: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
40012994: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40012998: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
4001299c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
400129a0: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
400129a4: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
400129a8: 40 00 49 f5 call 4002517c <printf> <== NOT EXECUTED
400129ac: 90 12 22 c0 or %o0, 0x2c0, %o0 <== NOT EXECUTED
400129b0: 30 bf fd bb b,a 4001209c <rtems_rfs_format+0x224> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
400129b4: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
400129b8: 40 00 2b 20 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400129bc: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
400129c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
400129c4: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
400129c8: c0 27 bf 34 clr [ %fp + -204 ] <== NOT EXECUTED
400129cc: 40 00 4e 36 call 400262a4 <strerror> <== NOT EXECUTED
400129d0: c0 27 bf 38 clr [ %fp + -200 ] <== NOT EXECUTED
400129d4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
400129d8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
400129dc: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400129e0: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
400129e4: 40 00 49 e6 call 4002517c <printf> <== NOT EXECUTED
400129e8: 90 12 22 78 or %o0, 0x278, %o0 ! 40036a78 <_CPU_Trap_slot_template+0x590><== NOT EXECUTED
400129ec: 30 bf fd ac b,a 4001209c <rtems_rfs_format+0x224> <== NOT EXECUTED
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
if (rc > 0)
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
400129f0: 40 00 4e 2d call 400262a4 <strerror> <== NOT EXECUTED
400129f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400129f8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400129fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012a00: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
40012a04: 40 00 49 de call 4002517c <printf> <== NOT EXECUTED
40012a08: 90 12 21 10 or %o0, 0x110, %o0 ! 40036510 <_CPU_Trap_slot_template+0x28><== NOT EXECUTED
40012a0c: 81 c7 e0 08 ret <== NOT EXECUTED
40012a10: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
40012a14: 11 10 00 d9 sethi %hi(0x40036400), %o0 <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
return -1;
40012a18: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
40012a1c: 40 00 49 d8 call 4002517c <printf> <== NOT EXECUTED
40012a20: 90 12 21 40 or %o0, 0x140, %o0 <== NOT EXECUTED
40012a24: 81 c7 e0 08 ret <== NOT EXECUTED
40012a28: 81 e8 00 00 restore <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40012a2c: 90 07 bf 7c add %fp, -132, %o0
40012a30: 40 00 2b 02 call 4001d638 <rtems_rfs_buffer_handle_release>
40012a34: 92 07 bf 30 add %fp, -208, %o1
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
40012a38: c2 07 bf a0 ld [ %fp + -96 ], %g1
40012a3c: b4 06 a0 01 inc %i2
40012a40: 80 a0 40 1a cmp %g1, %i2
40012a44: 04 80 00 15 ble 40012a98 <rtems_rfs_format+0xc20> <== ALWAYS TAKEN
40012a48: f8 07 bf a4 ld [ %fp + -92 ], %i4
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
40012a4c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
40012a50: 7f ff be da call 400025b8 <.umul> <== NOT EXECUTED
40012a54: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
if (group_base > rtems_rfs_fs_blocks (fs))
40012a58: c2 07 bf 80 ld [ %fp + -128 ], %g1 <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
40012a5c: b6 02 20 01 add %o0, 1, %i3 <== NOT EXECUTED
40012a60: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
40012a64: e2 0e 60 14 ldub [ %i1 + 0x14 ], %l1 <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
40012a68: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
40012a6c: 08 bf fe e6 bleu 40012604 <rtems_rfs_format+0x78c> <== NOT EXECUTED
40012a70: c4 0e 60 15 ldub [ %i1 + 0x15 ], %g2 <== NOT EXECUTED
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
40012a74: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40012a78: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
40012a7c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
40012a80: 40 00 49 bf call 4002517c <printf> <== NOT EXECUTED
40012a84: 90 12 20 68 or %o0, 0x68, %o0 <== NOT EXECUTED
40012a88: 81 c7 e0 08 ret <== NOT EXECUTED
40012a8c: 81 e8 00 00 restore <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
40012a90: 10 bf ff f9 b 40012a74 <rtems_rfs_format+0xbfc> <== NOT EXECUTED
40012a94: b4 10 20 00 clr %i2 <== NOT EXECUTED
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
40012a98: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
40012a9c: 80 a0 60 00 cmp %g1, 0
40012aa0: 02 80 00 04 be 40012ab0 <rtems_rfs_format+0xc38> <== ALWAYS TAKEN
40012aa4: 01 00 00 00 nop
printf ("\n");
40012aa8: 40 00 4a 1f call 40025324 <putchar> <== NOT EXECUTED
40012aac: 90 10 20 0a mov 0xa, %o0 ! a <PROM_START+0xa> <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
40012ab0: 40 00 2d 10 call 4001def0 <rtems_rfs_buffer_close>
40012ab4: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
40012ab8: ba 92 20 00 orcc %o0, 0, %i5
40012abc: 14 80 00 43 bg 40012bc8 <rtems_rfs_format+0xd50> <== NEVER TAKEN
40012ac0: 92 10 20 00 clr %o1
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
40012ac4: 90 10 00 18 mov %i0, %o0
40012ac8: 94 10 20 06 mov 6, %o2
40012acc: 96 10 20 00 clr %o3
40012ad0: 40 00 36 66 call 40020468 <rtems_rfs_fs_open>
40012ad4: 98 07 bf 28 add %fp, -216, %o4
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
40012ad8: 80 a2 20 00 cmp %o0, 0
40012adc: 06 80 00 7b bl 40012cc8 <rtems_rfs_format+0xe50> <== NEVER TAKEN
40012ae0: 92 10 20 01 mov 1, %o1
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
40012ae4: d0 07 bf 28 ld [ %fp + -216 ], %o0
40012ae8: 40 00 02 8c call 40013518 <rtems_rfs_inode_alloc>
40012aec: 94 07 bf 2c add %fp, -212, %o2
if (rc > 0)
40012af0: ba 92 20 00 orcc %o0, 0, %i5
40012af4: 14 80 00 0c bg 40012b24 <rtems_rfs_format+0xcac> <== NEVER TAKEN
40012af8: d2 07 bf 2c ld [ %fp + -212 ], %o1
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
40012afc: 80 a2 60 01 cmp %o1, 1
40012b00: 02 80 00 1c be 40012b70 <rtems_rfs_format+0xcf8> <== ALWAYS TAKEN
40012b04: 11 10 00 da sethi %hi(0x40036800), %o0
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
40012b08: 40 00 49 9d call 4002517c <printf> <== NOT EXECUTED
40012b0c: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 40036ba8 <_CPU_Trap_slot_template+0x6c0><== NOT EXECUTED
rtems_rfs_fs_close (fs);
40012b10: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
40012b14: 40 00 38 81 call 40020d18 <rtems_rfs_fs_close> <== NOT EXECUTED
40012b18: b0 10 20 00 clr %i0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
return 0;
}
40012b1c: 81 c7 e0 08 ret <== NOT EXECUTED
40012b20: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
if (rc > 0)
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
40012b24: 40 00 4d e0 call 400262a4 <strerror> <== NOT EXECUTED
40012b28: 01 00 00 00 nop <== NOT EXECUTED
40012b2c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40012b30: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012b34: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
40012b38: 40 00 49 91 call 4002517c <printf> <== NOT EXECUTED
40012b3c: 90 12 23 70 or %o0, 0x370, %o0 ! 40036b70 <_CPU_Trap_slot_template+0x688><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
40012b40: 40 00 38 76 call 40020d18 <rtems_rfs_fs_close> <== NOT EXECUTED
40012b44: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
40012b48: 40 00 4d d7 call 400262a4 <strerror> <== NOT EXECUTED
40012b4c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40012b50: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40012b54: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
rc, strerror (rc));
return -1;
40012b58: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
40012b5c: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40012b60: 40 00 49 87 call 4002517c <printf> <== NOT EXECUTED
40012b64: 90 12 20 e8 or %o0, 0xe8, %o0 ! 40036ce8 <_CPU_Trap_slot_template+0x800><== NOT EXECUTED
40012b68: 81 c7 e0 08 ret <== NOT EXECUTED
40012b6c: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40012b70: d0 07 bf 28 ld [ %fp + -216 ], %o0
40012b74: 92 10 20 01 mov 1, %o1
40012b78: 94 07 bf 54 add %fp, -172, %o2
40012b7c: 40 00 02 a3 call 40013608 <rtems_rfs_inode_open>
40012b80: 96 10 20 01 mov 1, %o3
if (rc > 0)
40012b84: ba 92 20 00 orcc %o0, 0, %i5
40012b88: 24 80 00 19 ble,a 40012bec <rtems_rfs_format+0xd74> <== ALWAYS TAKEN
40012b8c: 90 07 bf 54 add %fp, -172, %o0
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
40012b90: 40 00 4d c5 call 400262a4 <strerror> <== NOT EXECUTED
40012b94: 01 00 00 00 nop <== NOT EXECUTED
40012b98: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40012b9c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012ba0: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
40012ba4: 40 00 49 76 call 4002517c <printf> <== NOT EXECUTED
40012ba8: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 40036be0 <_CPU_Trap_slot_template+0x6f8><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
40012bac: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
40012bb0: d4 07 bf 2c ld [ %fp + -212 ], %o2 <== NOT EXECUTED
40012bb4: 40 00 01 a7 call 40013250 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
40012bb8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
rtems_rfs_fs_close (fs);
40012bbc: 40 00 38 57 call 40020d18 <rtems_rfs_fs_close> <== NOT EXECUTED
40012bc0: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
40012bc4: 30 bf ff e1 b,a 40012b48 <rtems_rfs_format+0xcd0> <== NOT EXECUTED
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
if (rc > 0)
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
40012bc8: 40 00 4d b7 call 400262a4 <strerror> <== NOT EXECUTED
40012bcc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40012bd0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40012bd4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012bd8: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
40012bdc: 40 00 49 68 call 4002517c <printf> <== NOT EXECUTED
40012be0: 90 12 23 08 or %o0, 0x308, %o0 ! 40036b08 <_CPU_Trap_slot_template+0x620><== NOT EXECUTED
40012be4: 81 c7 e0 08 ret <== NOT EXECUTED
40012be8: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, true, ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
40012bec: 92 10 20 00 clr %o1
40012bf0: 96 10 20 00 clr %o3
40012bf4: 15 00 00 10 sethi %hi(0x4000), %o2
40012bf8: 98 10 20 00 clr %o4
40012bfc: 40 00 03 7f call 400139f8 <rtems_rfs_inode_initialise>
40012c00: 94 12 a1 c9 or %o2, 0x1c9, %o2
(RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
0, 0);
if (rc > 0)
40012c04: ba 92 20 00 orcc %o0, 0, %i5
40012c08: 24 80 00 0a ble,a 40012c30 <rtems_rfs_format+0xdb8> <== ALWAYS TAKEN
40012c0c: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
40012c10: 40 00 4d a5 call 400262a4 <strerror> <== NOT EXECUTED
40012c14: 01 00 00 00 nop <== NOT EXECUTED
40012c18: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40012c1c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012c20: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40012c24: 40 00 49 56 call 4002517c <printf> <== NOT EXECUTED
40012c28: 90 12 20 10 or %o0, 0x10, %o0 ! 40036c10 <_CPU_Trap_slot_template+0x728><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
40012c2c: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
40012c30: d8 07 bf 2c ld [ %fp + -212 ], %o4
40012c34: 92 07 bf 54 add %fp, -172, %o1
40012c38: 96 10 20 01 mov 1, %o3
40012c3c: 15 10 00 d3 sethi %hi(0x40034c00), %o2
40012c40: 40 00 2e 39 call 4001e524 <rtems_rfs_dir_add_entry>
40012c44: 94 12 a2 10 or %o2, 0x210, %o2 ! 40034e10 <flashdisk_ops+0x1c>
if (rc > 0)
40012c48: ba 92 20 00 orcc %o0, 0, %i5
40012c4c: 24 80 00 0a ble,a 40012c74 <rtems_rfs_format+0xdfc> <== ALWAYS TAKEN
40012c50: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
40012c54: 40 00 4d 94 call 400262a4 <strerror> <== NOT EXECUTED
40012c58: 01 00 00 00 nop <== NOT EXECUTED
40012c5c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40012c60: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012c64: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40012c68: 40 00 49 45 call 4002517c <printf> <== NOT EXECUTED
40012c6c: 90 12 20 48 or %o0, 0x48, %o0 ! 40036c48 <_CPU_Trap_slot_template+0x760><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
40012c70: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
40012c74: 40 00 02 dd call 400137e8 <rtems_rfs_inode_close>
40012c78: 92 07 bf 54 add %fp, -172, %o1
if (rc > 0)
40012c7c: ba 92 20 00 orcc %o0, 0, %i5
40012c80: 04 80 00 09 ble 40012ca4 <rtems_rfs_format+0xe2c> <== ALWAYS TAKEN
40012c84: 01 00 00 00 nop
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
40012c88: 40 00 4d 87 call 400262a4 <strerror> <== NOT EXECUTED
40012c8c: 01 00 00 00 nop <== NOT EXECUTED
40012c90: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40012c94: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012c98: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40012c9c: 40 00 49 38 call 4002517c <printf> <== NOT EXECUTED
40012ca0: 90 12 20 80 or %o0, 0x80, %o0 ! 40036c80 <_CPU_Trap_slot_template+0x798><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
40012ca4: 40 00 38 1d call 40020d18 <rtems_rfs_fs_close>
40012ca8: d0 07 bf 28 ld [ %fp + -216 ], %o0
if (rc < 0)
40012cac: ba 92 20 00 orcc %o0, 0, %i5
40012cb0: 06 80 00 12 bl 40012cf8 <rtems_rfs_format+0xe80> <== NEVER TAKEN
40012cb4: 80 a7 60 00 cmp %i5, 0
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
40012cb8: 12 bf ff a4 bne 40012b48 <rtems_rfs_format+0xcd0> <== NEVER TAKEN
40012cbc: b0 10 20 00 clr %i0
rc, strerror (rc));
return -1;
}
return 0;
}
40012cc0: 81 c7 e0 08 ret
40012cc4: 81 e8 00 00 restore
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
40012cc8: 40 00 43 9c call 40023b38 <__errno> <== NOT EXECUTED
40012ccc: b0 10 20 00 clr %i0 <== NOT EXECUTED
40012cd0: 40 00 43 9a call 40023b38 <__errno> <== NOT EXECUTED
40012cd4: 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",
40012cd8: 40 00 4d 73 call 400262a4 <strerror> <== NOT EXECUTED
40012cdc: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40012ce0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40012ce4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012ce8: 11 10 00 da sethi %hi(0x40036800), %o0 <== NOT EXECUTED
40012cec: 40 00 49 24 call 4002517c <printf> <== NOT EXECUTED
40012cf0: 90 12 23 38 or %o0, 0x338, %o0 ! 40036b38 <_CPU_Trap_slot_template+0x650><== NOT EXECUTED
40012cf4: 30 bf ff f3 b,a 40012cc0 <rtems_rfs_format+0xe48> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
40012cf8: 40 00 43 90 call 40023b38 <__errno> <== NOT EXECUTED
40012cfc: b0 10 20 00 clr %i0 <== NOT EXECUTED
40012d00: 40 00 43 8e call 40023b38 <__errno> <== NOT EXECUTED
40012d04: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
40012d08: 40 00 4d 67 call 400262a4 <strerror> <== NOT EXECUTED
40012d0c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
40012d10: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40012d14: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012d18: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40012d1c: 40 00 49 18 call 4002517c <printf> <== NOT EXECUTED
40012d20: 90 12 20 b0 or %o0, 0xb0, %o0 ! 40036cb0 <_CPU_Trap_slot_template+0x7c8><== NOT EXECUTED
40012d24: 30 bf ff e7 b,a 40012cc0 <rtems_rfs_format+0xe48> <== NOT EXECUTED
40012d28: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
40012d2c: 10 bf fc 7e b 40011f24 <rtems_rfs_format+0xac> <== NOT EXECUTED
40012d30: f8 00 60 20 ld [ %g1 + 0x20 ], %i4 <== NOT EXECUTED
40020d18 <rtems_rfs_fs_close>:
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
40020d18: 9d e3 bf a0 save %sp, -96, %sp
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
40020d1c: 90 10 20 00 clr %o0
40020d20: 7f ff d0 e1 call 400150a4 <rtems_rfs_trace>
40020d24: 92 10 20 02 mov 2, %o1
40020d28: 80 8a 20 ff btst 0xff, %o0
40020d2c: 12 80 00 17 bne 40020d88 <rtems_rfs_fs_close+0x70> <== NEVER TAKEN
40020d30: 11 10 00 e4 sethi %hi(0x40039000), %o0
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
40020d34: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40020d38: b8 10 20 00 clr %i4
40020d3c: 80 a0 60 00 cmp %g1, 0
40020d40: 04 80 00 0b ble 40020d6c <rtems_rfs_fs_close+0x54> <== NEVER TAKEN
40020d44: ba 10 20 00 clr %i5
rtems_rfs_group_close (fs, &fs->groups[group]);
40020d48: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
40020d4c: 90 10 00 18 mov %i0, %o0
40020d50: 7f ff c8 86 call 40012f68 <rtems_rfs_group_close>
40020d54: 92 02 40 1c add %o1, %i4, %o1
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
40020d58: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40020d5c: ba 07 60 01 inc %i5
40020d60: 80 a0 40 1d cmp %g1, %i5
40020d64: 14 bf ff f9 bg 40020d48 <rtems_rfs_fs_close+0x30> <== NEVER TAKEN
40020d68: b8 07 20 50 add %i4, 0x50, %i4
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
40020d6c: 7f ff f4 61 call 4001def0 <rtems_rfs_buffer_close>
40020d70: 90 10 00 18 mov %i0, %o0
free (fs);
40020d74: 90 10 00 18 mov %i0, %o0
40020d78: 7f ff a0 ec call 40009128 <free>
40020d7c: b0 10 20 00 clr %i0
return 0;
}
40020d80: 81 c7 e0 08 ret
40020d84: 81 e8 00 00 restore
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
40020d88: 40 00 11 95 call 400253dc <puts> <== NOT EXECUTED
40020d8c: 90 12 21 e0 or %o0, 0x1e0, %o0 <== NOT EXECUTED
for (group = 0; group < fs->group_count; group++)
40020d90: 10 bf ff ea b 40020d38 <rtems_rfs_fs_close+0x20> <== NOT EXECUTED
40020d94: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED
40020468 <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)
{
40020468: 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))
4002046c: 90 10 20 00 clr %o0
40020470: 7f ff d3 0d call 400150a4 <rtems_rfs_trace>
40020474: 92 10 20 01 mov 1, %o1
40020478: 80 8a 20 ff btst 0xff, %o0
4002047c: 12 80 00 82 bne 40020684 <rtems_rfs_fs_open+0x21c> <== NEVER TAKEN
40020480: 92 10 00 18 mov %i0, %o1
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
40020484: 7f ff a4 c6 call 4000979c <malloc>
40020488: 90 10 20 84 mov 0x84, %o0
if (!*fs)
4002048c: 80 a2 20 00 cmp %o0, 0
40020490: 02 80 01 68 be 40020a30 <rtems_rfs_fs_open+0x5c8> <== NEVER TAKEN
40020494: d0 27 00 00 st %o0, [ %i4 ]
printf ("rtems-rfs: open: no memory for file system data\n");
errno = ENOMEM;
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
40020498: 92 10 20 00 clr %o1
4002049c: 40 00 12 ba call 40024f84 <memset>
400204a0: 94 10 20 84 mov 0x84, %o2
(*fs)->user = user;
400204a4: c2 07 00 00 ld [ %i4 ], %g1
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
400204a8: 90 10 00 18 mov %i0, %o0
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
400204ac: f2 20 60 80 st %i1, [ %g1 + 0x80 ]
rtems_chain_initialize_empty (&(*fs)->buffers);
400204b0: 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;
400204b4: 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 );
400204b8: 86 00 60 44 add %g1, 0x44, %g3
400204bc: 84 00 60 48 add %g1, 0x48, %g2
head->next = tail;
head->previous = NULL;
tail->previous = head;
400204c0: c6 20 60 4c st %g3, [ %g1 + 0x4c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
400204c4: c4 20 60 44 st %g2, [ %g1 + 0x44 ]
rtems_chain_initialize_empty (&(*fs)->release);
400204c8: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
400204cc: 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 );
400204d0: 86 00 60 54 add %g1, 0x54, %g3
400204d4: 84 00 60 58 add %g1, 0x58, %g2
head->next = tail;
head->previous = NULL;
tail->previous = head;
400204d8: c6 20 60 5c st %g3, [ %g1 + 0x5c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
400204dc: c4 20 60 54 st %g2, [ %g1 + 0x54 ]
rtems_chain_initialize_empty (&(*fs)->release_modified);
400204e0: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
400204e4: 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 );
400204e8: 86 00 60 64 add %g1, 0x64, %g3
400204ec: 84 00 60 68 add %g1, 0x68, %g2
head->next = tail;
head->previous = NULL;
tail->previous = head;
400204f0: c6 20 60 6c st %g3, [ %g1 + 0x6c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
400204f4: c4 20 60 64 st %g2, [ %g1 + 0x64 ]
rtems_chain_initialize_empty (&(*fs)->file_shares);
400204f8: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
400204fc: 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 );
40020500: 86 00 60 74 add %g1, 0x74, %g3
40020504: 84 00 60 78 add %g1, 0x78, %g2
head->next = tail;
head->previous = NULL;
tail->previous = head;
40020508: c6 20 60 7c st %g3, [ %g1 + 0x7c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4002050c: c4 20 60 74 st %g2, [ %g1 + 0x74 ]
(*fs)->max_held_buffers = max_held_buffers;
40020510: d2 07 00 00 ld [ %i4 ], %o1
40020514: f6 22 60 40 st %i3, [ %o1 + 0x40 ]
(*fs)->buffers_count = 0;
40020518: c0 22 60 50 clr [ %o1 + 0x50 ]
(*fs)->release_count = 0;
4002051c: c0 22 60 60 clr [ %o1 + 0x60 ]
(*fs)->release_modified_count = 0;
40020520: c0 22 60 70 clr [ %o1 + 0x70 ]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
40020524: 7f ff f5 77 call 4001db00 <rtems_rfs_buffer_open>
40020528: f4 22 40 00 st %i2, [ %o1 ]
if (rc > 0)
4002052c: ba 92 20 00 orcc %o0, 0, %i5
40020530: 14 80 00 a9 bg 400207d4 <rtems_rfs_fs_open+0x36c> <== NEVER TAKEN
40020534: 94 10 20 00 clr %o2
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
40020538: f6 07 00 00 ld [ %i4 ], %i3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4002053c: c0 2f bf cc clrb [ %fp + -52 ]
handle->bnum = 0;
40020540: c0 27 bf d0 clr [ %fp + -48 ]
handle->buffer = NULL;
40020544: 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);
40020548: 90 10 00 1b mov %i3, %o0
4002054c: 92 07 bf cc add %fp, -52, %o1
40020550: 7f ff f4 b4 call 4001d820 <rtems_rfs_buffer_handle_request>
40020554: 96 10 20 01 mov 1, %o3
if (rc > 0)
40020558: ba 92 20 00 orcc %o0, 0, %i5
4002055c: 04 80 00 1d ble 400205d0 <rtems_rfs_fs_open+0x168> <== ALWAYS TAKEN
40020560: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40020564: 7f ff d2 d0 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40020568: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4002056c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020570: 02 80 00 09 be 40020594 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
40020574: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
40020578: 40 00 17 4b call 400262a4 <strerror> <== NOT EXECUTED
4002057c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020580: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40020584: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40020588: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
4002058c: 40 00 12 fc call 4002517c <printf> <== NOT EXECUTED
40020590: 90 12 23 18 or %o0, 0x318, %o0 ! 40038f18 <CSWTCH.2+0x1128><== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
40020594: 7f ff f6 57 call 4001def0 <rtems_rfs_buffer_close> <== NOT EXECUTED
40020598: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
4002059c: 7f ff a2 e3 call 40009128 <free> <== NOT EXECUTED
400205a0: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400205a4: 90 10 20 00 clr %o0 <== NOT EXECUTED
400205a8: 7f ff d2 bf call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
400205ac: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
400205b0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400205b4: 12 80 00 2c bne 40020664 <rtems_rfs_fs_open+0x1fc> <== NOT EXECUTED
400205b8: 01 00 00 00 nop <== NOT EXECUTED
{
rtems_rfs_buffer_close (*fs);
free (*fs);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
400205bc: 40 00 0d 5f call 40023b38 <__errno> <== NOT EXECUTED
400205c0: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
400205c4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
400205c8: 81 c7 e0 08 ret <== NOT EXECUTED
400205cc: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
400205d0: c2 07 bf d4 ld [ %fp + -44 ], %g1
400205d4: 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)
400205d8: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
400205dc: c4 0f 40 00 ldub [ %i5 ], %g2
400205e0: c8 0f 60 01 ldub [ %i5 + 1 ], %g4
400205e4: c6 0f 60 03 ldub [ %i5 + 3 ], %g3
400205e8: 83 28 60 08 sll %g1, 8, %g1
400205ec: 85 28 a0 18 sll %g2, 0x18, %g2
400205f0: 89 29 20 10 sll %g4, 0x10, %g4
400205f4: 84 10 80 04 or %g2, %g4, %g2
400205f8: 84 10 80 03 or %g2, %g3, %g2
400205fc: 84 10 80 01 or %g2, %g1, %g2
40020600: 03 0a 02 48 sethi %hi(0x28092000), %g1
40020604: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_SIZE+0x27c92001>
40020608: 80 a0 80 01 cmp %g2, %g1
4002060c: 22 80 00 29 be,a 400206b0 <rtems_rfs_fs_open+0x248> <== ALWAYS TAKEN
40020610: c6 0f 60 0d ldub [ %i5 + 0xd ], %g3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40020614: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020618: 7f ff d2 a3 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4002061c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40020620: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020624: 32 80 00 1c bne,a 40020694 <rtems_rfs_fs_open+0x22c> <== NOT EXECUTED
40020628: 11 10 00 e3 sethi %hi(0x40038c00), %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);
4002062c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40020630: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
40020634: 7f ff f4 01 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40020638: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
4002063c: 7f ff f6 2d call 4001def0 <rtems_rfs_buffer_close> <== NOT EXECUTED
40020640: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
40020644: 7f ff a2 b9 call 40009128 <free> <== NOT EXECUTED
40020648: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4002064c: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020650: 7f ff d2 95 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40020654: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40020658: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4002065c: 02 bf ff d8 be 400205bc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
40020660: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
40020664: 40 00 17 10 call 400262a4 <strerror> <== NOT EXECUTED
40020668: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4002066c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40020670: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40020674: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
40020678: 40 00 12 c1 call 4002517c <printf> <== NOT EXECUTED
4002067c: 90 12 21 20 or %o0, 0x120, %o0 ! 40039120 <CSWTCH.2+0x1330><== NOT EXECUTED
40020680: 30 bf ff cf b,a 400205bc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: %s\n", name);
40020684: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
40020688: 40 00 12 bd call 4002517c <printf> <== NOT EXECUTED
4002068c: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 40038ea0 <CSWTCH.2+0x10b0><== NOT EXECUTED
40020690: 30 bf ff 7d b,a 40020484 <rtems_rfs_fs_open+0x1c> <== NOT EXECUTED
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
40020694: 40 00 13 52 call 400253dc <puts> <== NOT EXECUTED
40020698: 90 12 23 50 or %o0, 0x350, %o0 <== NOT EXECUTED
4002069c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
400206a0: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
400206a4: 7f ff f3 e5 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400206a8: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
400206ac: 30 bf ff e4 b,a 4002063c <rtems_rfs_fs_open+0x1d4> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
400206b0: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
400206b4: c4 0f 60 0f ldub [ %i5 + 0xf ], %g2
400206b8: d6 0f 60 0c ldub [ %i5 + 0xc ], %o3
400206bc: 87 28 e0 10 sll %g3, 0x10, %g3
400206c0: 83 28 60 08 sll %g1, 8, %g1
400206c4: 97 2a e0 18 sll %o3, 0x18, %o3
400206c8: 96 12 c0 03 or %o3, %g3, %o3
400206cc: 96 12 c0 02 or %o3, %g2, %o3
400206d0: 96 12 c0 01 or %o3, %g1, %o3
400206d4: d6 26 e0 04 st %o3, [ %i3 + 4 ]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
400206d8: c6 0f 60 09 ldub [ %i5 + 9 ], %g3
400206dc: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
400206e0: c4 0f 60 0b ldub [ %i5 + 0xb ], %g2
400206e4: f4 0f 60 08 ldub [ %i5 + 8 ], %i2
400206e8: 87 28 e0 10 sll %g3, 0x10, %g3
400206ec: 83 28 60 08 sll %g1, 8, %g1
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
400206f0: f2 06 e0 10 ld [ %i3 + 0x10 ], %i1
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
400206f4: 94 10 20 00 clr %o2
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
400206f8: b5 2e a0 18 sll %i2, 0x18, %i2
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
400206fc: 90 10 20 00 clr %o0
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
40020700: b4 16 80 03 or %i2, %g3, %i2
40020704: b4 16 80 02 or %i2, %g2, %i2
40020708: b4 16 80 01 or %i2, %g1, %i2
4002070c: 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;
40020710: 40 00 44 dd call 40031a84 <__muldi3>
40020714: 92 10 00 1a mov %i2, %o1
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
40020718: d6 06 60 1c ld [ %i1 + 0x1c ], %o3
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
4002071c: a0 10 00 09 mov %o1, %l0
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
40020720: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
40020724: b0 10 00 08 mov %o0, %i0
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
40020728: 94 10 20 00 clr %o2
4002072c: 40 00 44 d6 call 40031a84 <__muldi3>
40020730: 90 10 20 00 clr %o0
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
40020734: 80 a6 00 08 cmp %i0, %o0
40020738: 38 80 00 3a bgu,a 40020820 <rtems_rfs_fs_open+0x3b8> <== NEVER TAKEN
4002073c: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020740: 02 80 00 35 be 40020814 <rtems_rfs_fs_open+0x3ac> <== ALWAYS TAKEN
40020744: 80 a4 00 09 cmp %l0, %o1
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
40020748: c2 0f 60 24 ldub [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
4002074c: c8 0f 60 25 ldub [ %i5 + 0x25 ], %g4
40020750: c6 0f 60 27 ldub [ %i5 + 0x27 ], %g3
40020754: c4 0f 60 26 ldub [ %i5 + 0x26 ], %g2
40020758: 83 28 60 18 sll %g1, 0x18, %g1
4002075c: 89 29 20 10 sll %g4, 0x10, %g4
40020760: 85 28 a0 08 sll %g2, 8, %g2
40020764: 82 10 40 04 or %g1, %g4, %g1
40020768: 82 10 40 03 or %g1, %g3, %g1
4002076c: 82 10 40 02 or %g1, %g2, %g1
40020770: 80 a0 60 38 cmp %g1, 0x38
40020774: 22 80 00 35 be,a 40020848 <rtems_rfs_fs_open+0x3e0> <== ALWAYS TAKEN
40020778: c6 0f 60 13 ldub [ %i5 + 0x13 ], %g3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4002077c: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020780: 7f ff d2 49 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40020784: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40020788: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4002078c: 22 bf ff a9 be,a 40020630 <rtems_rfs_fs_open+0x1c8> <== NOT EXECUTED
40020790: 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);
40020794: c6 0f 60 05 ldub [ %i5 + 5 ], %g3 <== NOT EXECUTED
40020798: c2 0f 60 06 ldub [ %i5 + 6 ], %g1 <== NOT EXECUTED
4002079c: d2 0f 60 04 ldub [ %i5 + 4 ], %o1 <== NOT EXECUTED
400207a0: c4 0f 60 07 ldub [ %i5 + 7 ], %g2 <== NOT EXECUTED
400207a4: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
400207a8: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
400207ac: 93 2a 60 18 sll %o1, 0x18, %o1 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
400207b0: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
400207b4: 92 12 40 03 or %o1, %g3, %o1 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
400207b8: 94 10 20 00 clr %o2 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
400207bc: 92 12 40 02 or %o1, %g2, %o1 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
400207c0: 90 12 23 d0 or %o0, 0x3d0, %o0 <== NOT EXECUTED
400207c4: 40 00 12 6e call 4002517c <printf> <== NOT EXECUTED
400207c8: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
400207cc: 10 bf ff 99 b 40020630 <rtems_rfs_fs_open+0x1c8> <== NOT EXECUTED
400207d0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
if (rc > 0)
{
free (*fs);
400207d4: 7f ff a2 55 call 40009128 <free> <== NOT EXECUTED
400207d8: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400207dc: 90 10 20 00 clr %o0 <== NOT EXECUTED
400207e0: 7f ff d2 31 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
400207e4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
400207e8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400207ec: 02 bf ff 74 be 400205bc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
400207f0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
400207f4: 40 00 16 ac call 400262a4 <strerror> <== NOT EXECUTED
400207f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400207fc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40020800: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40020804: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
40020808: 40 00 12 5d call 4002517c <printf> <== NOT EXECUTED
4002080c: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 40038ee8 <CSWTCH.2+0x10f8><== NOT EXECUTED
40020810: 30 bf ff 6b b,a 400205bc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
40020814: 28 bf ff ce bleu,a 4002074c <rtems_rfs_fs_open+0x2e4> <== ALWAYS TAKEN
40020818: c2 0f 60 24 ldub [ %i5 + 0x24 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
4002081c: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020820: 7f ff d2 21 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40020824: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40020828: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4002082c: 22 bf ff 81 be,a 40020630 <rtems_rfs_fs_open+0x1c8> <== NOT EXECUTED
40020830: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
40020834: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
40020838: 40 00 12 e9 call 400253dc <puts> <== NOT EXECUTED
4002083c: 90 12 23 90 or %o0, 0x390, %o0 ! 40038f90 <CSWTCH.2+0x11a0><== NOT EXECUTED
40020840: 10 bf ff 7c b 40020630 <rtems_rfs_fs_open+0x1c8> <== NOT EXECUTED
40020844: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
40020848: c2 0f 60 10 ldub [ %i5 + 0x10 ], %g1
4002084c: c8 0f 60 11 ldub [ %i5 + 0x11 ], %g4
40020850: c4 0f 60 12 ldub [ %i5 + 0x12 ], %g2
40020854: 89 29 20 10 sll %g4, 0x10, %g4
40020858: 85 28 a0 08 sll %g2, 8, %g2
4002085c: 83 28 60 18 sll %g1, 0x18, %g1
40020860: 82 10 40 04 or %g1, %g4, %g1
40020864: 82 10 40 03 or %g1, %g3, %g1
40020868: 82 10 40 02 or %g1, %g2, %g1
4002086c: c2 26 e0 18 st %g1, [ %i3 + 0x18 ]
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
40020870: c6 0f 60 17 ldub [ %i5 + 0x17 ], %g3
40020874: c2 0f 60 14 ldub [ %i5 + 0x14 ], %g1
40020878: c8 0f 60 15 ldub [ %i5 + 0x15 ], %g4
4002087c: c4 0f 60 16 ldub [ %i5 + 0x16 ], %g2
40020880: 89 29 20 10 sll %g4, 0x10, %g4
40020884: 85 28 a0 08 sll %g2, 8, %g2
40020888: 83 28 60 18 sll %g1, 0x18, %g1
4002088c: 82 10 40 04 or %g1, %g4, %g1
40020890: 82 10 40 03 or %g1, %g3, %g1
40020894: 82 10 40 02 or %g1, %g2, %g1
40020898: c2 26 e0 1c st %g1, [ %i3 + 0x1c ]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
4002089c: c6 0f 60 19 ldub [ %i5 + 0x19 ], %g3
400208a0: c2 0f 60 1a ldub [ %i5 + 0x1a ], %g1
400208a4: c4 0f 60 1b ldub [ %i5 + 0x1b ], %g2
400208a8: f0 0f 60 18 ldub [ %i5 + 0x18 ], %i0
400208ac: 87 28 e0 10 sll %g3, 0x10, %g3
400208b0: 83 28 60 08 sll %g1, 8, %g1
400208b4: b1 2e 20 18 sll %i0, 0x18, %i0
400208b8: b0 16 00 03 or %i0, %g3, %i0
400208bc: b0 16 00 02 or %i0, %g2, %i0
400208c0: b0 16 00 01 or %i0, %g1, %i0
400208c4: f0 26 e0 24 st %i0, [ %i3 + 0x24 ]
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
400208c8: c4 0f 60 1f ldub [ %i5 + 0x1f ], %g2
400208cc: f2 0f 60 1c ldub [ %i5 + 0x1c ], %i1
400208d0: c6 0f 60 1d ldub [ %i5 + 0x1d ], %g3
400208d4: c2 0f 60 1e ldub [ %i5 + 0x1e ], %g1
400208d8: 87 28 e0 10 sll %g3, 0x10, %g3
400208dc: 83 28 60 08 sll %g1, 8, %g1
400208e0: b3 2e 60 18 sll %i1, 0x18, %i1
400208e4: b2 16 40 03 or %i1, %g3, %i1
400208e8: b2 16 40 02 or %i1, %g2, %i1
400208ec: b2 16 40 01 or %i1, %g1, %i1
400208f0: f2 26 e0 28 st %i1, [ %i3 + 0x28 ]
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
400208f4: c4 0f 60 21 ldub [ %i5 + 0x21 ], %g2
400208f8: de 0f 60 20 ldub [ %i5 + 0x20 ], %o7
400208fc: c6 0f 60 22 ldub [ %i5 + 0x22 ], %g3
40020900: c8 0f 60 23 ldub [ %i5 + 0x23 ], %g4
40020904: 85 28 a0 10 sll %g2, 0x10, %g2
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
40020908: 83 36 a0 02 srl %i2, 2, %g1
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
4002090c: bb 2b e0 18 sll %o7, 0x18, %i5
40020910: 87 28 e0 08 sll %g3, 8, %g3
40020914: ba 17 40 02 or %i5, %g2, %i5
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
40020918: 85 28 60 02 sll %g1, 2, %g2
4002091c: 84 00 80 01 add %g2, %g1, %g2
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
40020920: ba 17 40 04 or %i5, %g4, %i5
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
40020924: 92 10 00 01 mov %g1, %o1
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
40020928: ba 17 40 03 or %i5, %g3, %i5
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
4002092c: c4 26 e0 38 st %g2, [ %i3 + 0x38 ]
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
40020930: 90 10 00 01 mov %g1, %o0
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
40020934: c2 26 e0 34 st %g1, [ %i3 + 0x34 ]
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
40020938: 7f ff 87 20 call 400025b8 <.umul>
4002093c: fa 26 e0 2c st %i5, [ %i3 + 0x2c ]
40020940: 83 2a 20 02 sll %o0, 2, %g1
40020944: 82 00 40 08 add %g1, %o0, %g1
fs->inodes = fs->group_count * fs->group_inodes;
40020948: 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 =
4002094c: c2 26 e0 3c st %g1, [ %i3 + 0x3c ]
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
40020950: 7f ff 87 1a call 400025b8 <.umul>
40020954: 90 10 00 1d mov %i5, %o0
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
40020958: 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;
4002095c: d0 26 e0 14 st %o0, [ %i3 + 0x14 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
40020960: 7f ff 87 50 call 400026a0 <.udiv>
40020964: 90 10 00 1a mov %i2, %o0
40020968: d0 26 e0 30 st %o0, [ %i3 + 0x30 ]
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
4002096c: b5 2e a0 03 sll %i2, 3, %i2
40020970: 92 07 bf cc add %fp, -52, %o1
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
40020974: 80 a6 40 1a cmp %i1, %i2
40020978: 08 80 00 10 bleu 400209b8 <rtems_rfs_fs_open+0x550> <== ALWAYS TAKEN
4002097c: 90 10 00 1b mov %i3, %o0
40020980: 7f ff f3 2e call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40020984: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40020988: 90 10 20 00 clr %o0 <== NOT EXECUTED
4002098c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->dirty = false;
40020990: c0 2f bf cc clrb [ %fp + -52 ] <== NOT EXECUTED
handle->bnum = 0;
40020994: c0 27 bf d0 clr [ %fp + -48 ] <== NOT EXECUTED
40020998: 7f ff d1 c3 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4002099c: c0 27 bf d4 clr [ %fp + -44 ] <== NOT EXECUTED
400209a0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400209a4: 02 bf fe fc be 40020594 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
400209a8: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
400209ac: 40 00 12 8c call 400253dc <puts> <== NOT EXECUTED
400209b0: 90 12 20 18 or %o0, 0x18, %o0 ! 40039018 <CSWTCH.2+0x1228><== NOT EXECUTED
400209b4: 30 bf fe f8 b,a 40020594 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
400209b8: 7f ff f3 20 call 4001d638 <rtems_rfs_buffer_handle_release>
400209bc: 01 00 00 00 nop
rtems_rfs_buffer_handle_close (fs, &handle);
/*
* Change the block size to the value in the superblock.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
400209c0: d2 06 e0 08 ld [ %i3 + 8 ], %o1
handle->dirty = false;
400209c4: c0 2f bf cc clrb [ %fp + -52 ]
handle->bnum = 0;
400209c8: c0 27 bf d0 clr [ %fp + -48 ]
handle->buffer = NULL;
400209cc: c0 27 bf d4 clr [ %fp + -44 ]
400209d0: 7f ff f4 ff call 4001ddcc <rtems_rfs_buffer_setblksize>
400209d4: 90 10 00 1b mov %i3, %o0
if (rc > 0)
400209d8: ba 92 20 00 orcc %o0, 0, %i5
400209dc: 04 80 00 23 ble 40020a68 <rtems_rfs_fs_open+0x600> <== ALWAYS TAKEN
400209e0: 92 07 bf cc add %fp, -52, %o1
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
400209e4: 7f ff f3 15 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400209e8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
400209ec: 90 10 20 00 clr %o0 <== NOT EXECUTED
400209f0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->dirty = false;
400209f4: c0 2f bf cc clrb [ %fp + -52 ] <== NOT EXECUTED
handle->bnum = 0;
400209f8: c0 27 bf d0 clr [ %fp + -48 ] <== NOT EXECUTED
400209fc: 7f ff d1 aa call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40020a00: c0 27 bf d4 clr [ %fp + -44 ] <== NOT EXECUTED
40020a04: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020a08: 02 bf fe e3 be 40020594 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
40020a0c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
40020a10: 40 00 16 25 call 400262a4 <strerror> <== NOT EXECUTED
40020a14: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020a18: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40020a1c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40020a20: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
40020a24: 40 00 11 d6 call 4002517c <printf> <== NOT EXECUTED
40020a28: 90 12 20 60 or %o0, 0x60, %o0 ! 40039060 <CSWTCH.2+0x1270><== NOT EXECUTED
40020a2c: 30 bf fe da b,a 40020594 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
if (!*fs)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40020a30: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020a34: 7f ff d1 9c call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40020a38: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40020a3c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020a40: 02 80 00 04 be 40020a50 <rtems_rfs_fs_open+0x5e8> <== NOT EXECUTED
40020a44: 11 10 00 e3 sethi %hi(0x40038c00), %o0 <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
40020a48: 40 00 12 65 call 400253dc <puts> <== NOT EXECUTED
40020a4c: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 40038eb8 <CSWTCH.2+0x10c8><== NOT EXECUTED
errno = ENOMEM;
40020a50: 40 00 0c 3a call 40023b38 <__errno> <== NOT EXECUTED
40020a54: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40020a58: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40020a5c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40020a60: 81 c7 e0 08 ret <== NOT EXECUTED
40020a64: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
40020a68: fa 06 e0 24 ld [ %i3 + 0x24 ], %i5
40020a6c: 92 10 20 50 mov 0x50, %o1
40020a70: 7f ff a1 4b call 40008f9c <calloc>
40020a74: 90 10 00 1d mov %i5, %o0
if (!fs->groups)
40020a78: 80 a2 20 00 cmp %o0, 0
40020a7c: 02 80 00 97 be 40020cd8 <rtems_rfs_fs_open+0x870> <== NEVER TAKEN
40020a80: d0 26 e0 20 st %o0, [ %i3 + 0x20 ]
/*
* Perform each phase of group initialisation at the same time. This way we
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
40020a84: b2 10 20 00 clr %i1
40020a88: 80 a7 60 00 cmp %i5, 0
40020a8c: 14 80 00 08 bg 40020aac <rtems_rfs_fs_open+0x644> <== ALWAYS TAKEN
40020a90: b4 10 20 00 clr %i2
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
40020a94: 10 80 00 35 b 40020b68 <rtems_rfs_fs_open+0x700> <== NOT EXECUTED
40020a98: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
/*
* Perform each phase of group initialisation at the same time. This way we
* know how far the initialisation has gone if an error occurs and we need to
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
40020a9c: b4 06 a0 01 inc %i2
40020aa0: 80 a6 80 01 cmp %i2, %g1
40020aa4: 16 80 00 30 bge 40020b64 <rtems_rfs_fs_open+0x6fc> <== ALWAYS TAKEN
40020aa8: b2 06 60 50 add %i1, 0x50, %i1
{
rc = rtems_rfs_group_open (fs,
rtems_rfs_fs_block (fs, group, 0),
40020aac: fa 06 e0 28 ld [ %i3 + 0x28 ], %i5
40020ab0: 90 10 00 1a mov %i2, %o0
40020ab4: 7f ff 86 c1 call 400025b8 <.umul>
40020ab8: 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,
40020abc: d8 06 e0 20 ld [ %i3 + 0x20 ], %o4
40020ac0: d6 06 e0 2c ld [ %i3 + 0x2c ], %o3
rtems_rfs_fs_block (fs, group, 0),
40020ac4: 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,
40020ac8: 94 10 00 1d mov %i5, %o2
40020acc: 98 03 00 19 add %o4, %i1, %o4
40020ad0: 7f ff c8 99 call 40012d34 <rtems_rfs_group_open>
40020ad4: 90 10 00 1b mov %i3, %o0
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
40020ad8: ba 92 20 00 orcc %o0, 0, %i5
40020adc: 24 bf ff f0 ble,a 40020a9c <rtems_rfs_fs_open+0x634> <== ALWAYS TAKEN
40020ae0: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
{
int g;
for (g = 0; g < group; g++)
40020ae4: b0 10 20 00 clr %i0 <== NOT EXECUTED
40020ae8: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40020aec: 02 80 00 0a be 40020b14 <rtems_rfs_fs_open+0x6ac> <== NOT EXECUTED
40020af0: b2 10 20 00 clr %i1 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
40020af4: d2 06 e0 20 ld [ %i3 + 0x20 ], %o1 <== NOT EXECUTED
40020af8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40020afc: 7f ff c9 1b call 40012f68 <rtems_rfs_group_close> <== NOT EXECUTED
40020b00: 92 02 40 18 add %o1, %i0, %o1 <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
40020b04: b2 06 60 01 inc %i1 <== NOT EXECUTED
40020b08: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
40020b0c: 12 bf ff fa bne 40020af4 <rtems_rfs_fs_open+0x68c> <== NOT EXECUTED
40020b10: b0 06 20 50 add %i0, 0x50, %i0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40020b14: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
40020b18: 7f ff f2 c8 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40020b1c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40020b20: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020b24: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->dirty = false;
40020b28: c0 2f bf cc clrb [ %fp + -52 ] <== NOT EXECUTED
handle->bnum = 0;
40020b2c: c0 27 bf d0 clr [ %fp + -48 ] <== NOT EXECUTED
40020b30: 7f ff d1 5d call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40020b34: c0 27 bf d4 clr [ %fp + -44 ] <== NOT EXECUTED
40020b38: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020b3c: 02 bf fe 96 be 40020594 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
40020b40: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
40020b44: 40 00 15 d8 call 400262a4 <strerror> <== NOT EXECUTED
40020b48: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020b4c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40020b50: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40020b54: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
40020b58: 40 00 11 89 call 4002517c <printf> <== NOT EXECUTED
40020b5c: 90 12 20 e0 or %o0, 0xe0, %o0 ! 400390e0 <CSWTCH.2+0x12f0><== NOT EXECUTED
40020b60: 30 bf fe 8d b,a 40020594 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
40020b64: d0 07 00 00 ld [ %i4 ], %o0
40020b68: 92 10 20 01 mov 1, %o1
40020b6c: 94 07 bf d8 add %fp, -40, %o2
40020b70: 7f ff ca a6 call 40013608 <rtems_rfs_inode_open>
40020b74: 96 10 20 01 mov 1, %o3
if (rc > 0)
40020b78: ba 92 20 00 orcc %o0, 0, %i5
40020b7c: 14 80 00 45 bg 40020c90 <rtems_rfs_fs_open+0x828> <== NEVER TAKEN
40020b80: 01 00 00 00 nop
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
40020b84: d0 07 00 00 ld [ %i4 ], %o0
40020b88: c2 02 00 00 ld [ %o0 ], %g1
40020b8c: 80 88 60 04 btst 4, %g1
40020b90: 12 80 00 10 bne 40020bd0 <rtems_rfs_fs_open+0x768>
40020b94: c2 07 bf e4 ld [ %fp + -28 ], %g1
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
40020b98: c4 08 60 03 ldub [ %g1 + 3 ], %g2
40020b9c: c6 08 60 02 ldub [ %g1 + 2 ], %g3
40020ba0: 83 28 e0 08 sll %g3, 8, %g1
40020ba4: 82 10 40 02 or %g1, %g2, %g1
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
40020ba8: 05 3f ff c0 sethi %hi(0xffff0000), %g2
40020bac: 87 28 60 10 sll %g1, 0x10, %g3
40020bb0: 80 a0 c0 02 cmp %g3, %g2
40020bb4: 02 80 00 23 be 40020c40 <rtems_rfs_fs_open+0x7d8> <== NEVER TAKEN
40020bb8: 05 00 00 3c sethi %hi(0xf000), %g2
40020bbc: 82 08 40 02 and %g1, %g2, %g1
40020bc0: 05 00 00 10 sethi %hi(0x4000), %g2
40020bc4: 80 a0 40 02 cmp %g1, %g2
40020bc8: 12 80 00 1e bne 40020c40 <rtems_rfs_fs_open+0x7d8> <== NEVER TAKEN
40020bcc: 01 00 00 00 nop
errno = EIO;
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
40020bd0: 7f ff cb 06 call 400137e8 <rtems_rfs_inode_close>
40020bd4: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
40020bd8: ba 92 20 00 orcc %o0, 0, %i5
40020bdc: 14 80 00 07 bg 40020bf8 <rtems_rfs_fs_open+0x790> <== NEVER TAKEN
40020be0: 01 00 00 00 nop
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
return -1;
}
errno = 0;
40020be4: 40 00 0b d5 call 40023b38 <__errno>
40020be8: b0 10 20 00 clr %i0 ! 0 <PROM_START>
40020bec: c0 22 00 00 clr [ %o0 ]
40020bf0: 81 c7 e0 08 ret
40020bf4: 81 e8 00 00 restore
}
rc = rtems_rfs_inode_close (*fs, &inode);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
40020bf8: 7f ff f4 be call 4001def0 <rtems_rfs_buffer_close> <== NOT EXECUTED
40020bfc: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
40020c00: 7f ff a1 4a call 40009128 <free> <== NOT EXECUTED
40020c04: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40020c08: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020c0c: 7f ff d1 26 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40020c10: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40020c14: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020c18: 02 bf fe 69 be 400205bc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
40020c1c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
40020c20: 40 00 15 a1 call 400262a4 <strerror> <== NOT EXECUTED
40020c24: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020c28: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40020c2c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40020c30: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
40020c34: 40 00 11 52 call 4002517c <printf> <== NOT EXECUTED
40020c38: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 400391b0 <CSWTCH.2+0x13c0><== NOT EXECUTED
40020c3c: 30 bf fe 60 b,a 400205bc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
{
rtems_rfs_inode_close (*fs, &inode);
40020c40: 7f ff ca ea call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40020c44: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
40020c48: 7f ff f4 aa call 4001def0 <rtems_rfs_buffer_close> <== NOT EXECUTED
40020c4c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
40020c50: 7f ff a1 36 call 40009128 <free> <== NOT EXECUTED
40020c54: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40020c58: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020c5c: 7f ff d1 12 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40020c60: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40020c64: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020c68: 02 80 00 04 be 40020c78 <rtems_rfs_fs_open+0x810> <== NOT EXECUTED
40020c6c: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
40020c70: 40 00 11 db call 400253dc <puts> <== NOT EXECUTED
40020c74: 90 12 21 80 or %o0, 0x180, %o0 ! 40039180 <CSWTCH.2+0x1390><== NOT EXECUTED
errno = EIO;
40020c78: 40 00 0b b0 call 40023b38 <__errno> <== NOT EXECUTED
40020c7c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40020c80: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40020c84: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40020c88: 81 c7 e0 08 ret <== NOT EXECUTED
40020c8c: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
40020c90: 7f ff f4 98 call 4001def0 <rtems_rfs_buffer_close> <== NOT EXECUTED
40020c94: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
40020c98: 7f ff a1 24 call 40009128 <free> <== NOT EXECUTED
40020c9c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40020ca0: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020ca4: 7f ff d1 00 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40020ca8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40020cac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020cb0: 02 bf fe 43 be 400205bc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
40020cb4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
40020cb8: 40 00 15 7b call 400262a4 <strerror> <== NOT EXECUTED
40020cbc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40020cc0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40020cc4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40020cc8: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
40020ccc: 40 00 11 2c call 4002517c <printf> <== NOT EXECUTED
40020cd0: 90 12 21 50 or %o0, 0x150, %o0 ! 40039150 <CSWTCH.2+0x1360><== NOT EXECUTED
40020cd4: 30 bf fe 3a b,a 400205bc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40020cd8: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
40020cdc: 7f ff f2 57 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40020ce0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
if (!fs->groups)
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
40020ce4: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020ce8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
handle->dirty = false;
40020cec: c0 2f bf cc clrb [ %fp + -52 ] <== NOT EXECUTED
handle->bnum = 0;
40020cf0: c0 27 bf d0 clr [ %fp + -48 ] <== NOT EXECUTED
handle->buffer = NULL;
40020cf4: c0 27 bf d4 clr [ %fp + -44 ] <== NOT EXECUTED
40020cf8: 7f ff d0 eb call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40020cfc: ba 10 20 0c mov 0xc, %i5 <== NOT EXECUTED
40020d00: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020d04: 02 bf fe 24 be 40020594 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
40020d08: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
40020d0c: 40 00 11 b4 call 400253dc <puts> <== NOT EXECUTED
40020d10: 90 12 20 a8 or %o0, 0xa8, %o0 ! 400390a8 <CSWTCH.2+0x12b8><== NOT EXECUTED
40020d14: 30 bf fe 20 b,a 40020594 <rtems_rfs_fs_open+0x12c> <== NOT EXECUTED
4002041c <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)
{
4002041c: 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;
40020420: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
40020424: d6 06 20 04 ld [ %i0 + 4 ], %o3 <== NOT EXECUTED
40020428: 94 10 20 00 clr %o2 <== NOT EXECUTED
4002042c: 40 00 45 96 call 40031a84 <__muldi3> <== NOT EXECUTED
40020430: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
40020434: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
40020438: 81 c7 e0 08 ret <== NOT EXECUTED
4002043c: 93 e8 00 09 restore %g0, %o1, %o1 <== NOT EXECUTED
40013014 <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)
{
40013014: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
40013018: 80 a6 a0 00 cmp %i2, 0
4001301c: 22 80 00 04 be,a 4001302c <rtems_rfs_group_bitmap_alloc+0x18>
40013020: e6 06 20 28 ld [ %i0 + 0x28 ], %l3
{
size = fs->group_inodes;
40013024: e6 06 20 2c ld [ %i0 + 0x2c ], %l3
goal -= RTEMS_RFS_ROOT_INO;
40013028: b2 06 7f ff add %i1, -1, %i1
}
else
size = fs->group_blocks;
group_start = goal / size;
4001302c: 90 10 00 19 mov %i1, %o0
40013030: 7f ff bd 9c call 400026a0 <.udiv>
40013034: 92 10 00 13 mov %l3, %o1
bit = (rtems_rfs_bitmap_bit) (goal % size);
40013038: 92 10 00 13 mov %l3, %o1
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
4001303c: a2 10 00 08 mov %o0, %l1
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
direction = 1;
40013040: b8 10 20 01 mov 1, %i4
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
40013044: 90 10 00 19 mov %i1, %o0
40013048: 40 00 79 e3 call 400317d4 <.urem>
4001304c: ba 10 00 11 mov %l1, %i5
offset = 0;
updown = true;
40013050: a0 10 20 01 mov 1, %l0
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
40013054: d0 27 bf fc st %o0, [ %fp + -4 ]
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
40013058: c0 2f bf fb clrb [ %fp + -5 ]
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
4001305c: b2 10 20 00 clr %i1
/*
* If we are still looking up and down and if the group is out of range we
* have reached one end. Stopping looking up and down and just move in the
* one direction one group at a time.
*/
if ((group < 0) || (group >= fs->group_count))
40013060: 80 a7 60 00 cmp %i5, 0
40013064: 06 80 00 32 bl 4001312c <rtems_rfs_group_bitmap_alloc+0x118><== NEVER TAKEN
40013068: 80 8c 20 ff btst 0xff, %l0
4001306c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40013070: 80 a0 40 1d cmp %g1, %i5
40013074: 04 80 00 2e ble 4001312c <rtems_rfs_group_bitmap_alloc+0x118>
40013078: 80 8c 20 ff btst 0xff, %l0
updown = false;
continue;
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
4001307c: e4 06 20 20 ld [ %i0 + 0x20 ], %l2
40013080: ab 2f 60 04 sll %i5, 4, %l5
40013084: a9 2f 60 06 sll %i5, 6, %l4
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
40013088: 80 a6 a0 00 cmp %i2, 0
bitmap = &fs->groups[group].inode_bitmap;
4001308c: 82 05 40 14 add %l5, %l4, %g1
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
40013090: 02 80 00 46 be 400131a8 <rtems_rfs_group_bitmap_alloc+0x194>
40013094: a4 04 80 01 add %l2, %g1, %l2
bitmap = &fs->groups[group].inode_bitmap;
40013098: a4 04 a0 2c add %l2, 0x2c, %l2
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
4001309c: d2 07 bf fc ld [ %fp + -4 ], %o1
400130a0: 90 10 00 12 mov %l2, %o0
400130a4: 94 07 bf fb add %fp, -5, %o2
400130a8: 40 00 24 54 call 4001c1f8 <rtems_rfs_bitmap_map_alloc>
400130ac: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
400130b0: 80 a2 20 00 cmp %o0, 0
400130b4: 14 80 00 3b bg 400131a0 <rtems_rfs_group_bitmap_alloc+0x18c><== NEVER TAKEN
400130b8: 01 00 00 00 nop
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
400130bc: c2 06 00 00 ld [ %i0 ], %g1
400130c0: 80 88 60 01 btst 1, %g1
400130c4: 22 80 00 3b be,a 400131b0 <rtems_rfs_group_bitmap_alloc+0x19c><== ALWAYS TAKEN
400130c8: d2 04 80 00 ld [ %l2 ], %o1
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
400130cc: c2 0f bf fb ldub [ %fp + -5 ], %g1 <== NOT EXECUTED
400130d0: 80 a0 60 00 cmp %g1, 0
400130d4: 12 80 00 3b bne 400131c0 <rtems_rfs_group_bitmap_alloc+0x1ac>
400130d8: 80 8c 20 ff btst 0xff, %l0
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
400130dc: 22 80 00 07 be,a 400130f8 <rtems_rfs_group_bitmap_alloc+0xe4><== NEVER TAKEN
400130e0: b2 06 60 01 inc %i1 <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
400130e4: 80 a7 20 00 cmp %i4, 0
400130e8: 04 80 00 03 ble 400130f4 <rtems_rfs_group_bitmap_alloc+0xe0><== NEVER TAKEN
400130ec: b8 10 20 01 mov 1, %i4
400130f0: b8 10 3f ff mov -1, %i4
offset++;
400130f4: b2 06 60 01 inc %i1
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
400130f8: 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);
400130fc: 90 10 00 1c mov %i4, %o0
40013100: 7f ff bd 2e call 400025b8 <.umul>
40013104: 92 10 00 19 mov %i1, %o1
if (offset)
bit = direction > 0 ? 0 : size - 1;
40013108: 82 10 20 00 clr %g1
4001310c: 80 a7 20 00 cmp %i4, 0
40013110: 04 80 00 17 ble 4001316c <rtems_rfs_group_bitmap_alloc+0x158><== ALWAYS TAKEN
40013114: ba 02 00 11 add %o0, %l1, %i5
40013118: 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))
4001311c: 80 a7 60 00 cmp %i5, 0
40013120: 36 bf ff d4 bge,a 40013070 <rtems_rfs_group_bitmap_alloc+0x5c>
40013124: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
{
if (!updown)
40013128: 80 8c 20 ff btst 0xff, %l0
4001312c: 02 80 00 13 be 40013178 <rtems_rfs_group_bitmap_alloc+0x164>
40013130: 80 a7 20 00 cmp %i4, 0
break;
direction = direction > 0 ? -1 : 1;
40013134: 04 80 00 03 ble 40013140 <rtems_rfs_group_bitmap_alloc+0x12c><== ALWAYS TAKEN
40013138: b8 10 20 01 mov 1, %i4
4001313c: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
40013140: 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);
40013144: 90 10 00 1c mov %i4, %o0
40013148: 7f ff bd 1c call 400025b8 <.umul>
4001314c: 92 10 00 19 mov %i1, %o1
if ((group < 0) || (group >= fs->group_count))
{
if (!updown)
break;
direction = direction > 0 ? -1 : 1;
updown = false;
40013150: a0 10 20 00 clr %l0
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
40013154: 80 a6 60 00 cmp %i1, 0
40013158: 02 bf ff c2 be 40013060 <rtems_rfs_group_bitmap_alloc+0x4c><== NEVER TAKEN
4001315c: ba 02 00 11 add %o0, %l1, %i5
bit = direction > 0 ? 0 : size - 1;
40013160: 80 a7 20 00 cmp %i4, 0
40013164: 14 bf ff ed bg 40013118 <rtems_rfs_group_bitmap_alloc+0x104><== ALWAYS TAKEN
40013168: 82 10 20 00 clr %g1
4001316c: 82 04 ff ff add %l3, -1, %g1
40013170: 10 bf ff eb b 4001311c <rtems_rfs_group_bitmap_alloc+0x108>
40013174: c2 27 bf fc st %g1, [ %fp + -4 ]
direction = direction > 0 ? -1 : 1;
offset++;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40013178: 90 10 20 00 clr %o0
4001317c: 40 00 07 ca call 400150a4 <rtems_rfs_trace>
40013180: 13 00 00 80 sethi %hi(0x20000), %o1
40013184: 80 8a 20 ff btst 0xff, %o0
40013188: 22 80 00 06 be,a 400131a0 <rtems_rfs_group_bitmap_alloc+0x18c><== ALWAYS TAKEN
4001318c: 90 10 20 1c mov 0x1c, %o0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
40013190: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40013194: 40 00 48 92 call 400253dc <puts> <== NOT EXECUTED
40013198: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 40036eb8 <_CPU_Trap_slot_template+0x9d0><== NOT EXECUTED
return ENOSPC;
4001319c: 90 10 20 1c mov 0x1c, %o0 <== NOT EXECUTED
}
400131a0: 81 c7 e0 08 ret
400131a4: 91 e8 00 08 restore %g0, %o0, %o0
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
400131a8: 10 bf ff bd b 4001309c <rtems_rfs_group_bitmap_alloc+0x88>
400131ac: a4 04 a0 08 add %l2, 8, %l2
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
if (rc > 0)
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
rtems_rfs_bitmap_release_buffer (fs, bitmap);
400131b0: 40 00 29 22 call 4001d638 <rtems_rfs_buffer_handle_release>
400131b4: 90 10 00 18 mov %i0, %o0
if (allocated)
400131b8: 10 bf ff c6 b 400130d0 <rtems_rfs_group_bitmap_alloc+0xbc>
400131bc: c2 0f bf fb ldub [ %fp + -5 ], %g1
{
if (inode)
400131c0: 80 a6 a0 00 cmp %i2, 0
400131c4: 32 80 00 15 bne,a 40013218 <rtems_rfs_group_bitmap_alloc+0x204>
400131c8: d2 06 20 2c ld [ %i0 + 0x2c ], %o1
*result = rtems_rfs_group_inode (fs, group, bit);
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
400131cc: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
400131d0: c4 07 bf fc ld [ %fp + -4 ], %g2
400131d4: a8 05 40 14 add %l5, %l4, %l4
400131d8: c2 00 40 14 ld [ %g1 + %l4 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
400131dc: 90 10 20 00 clr %o0
if (allocated)
{
if (inode)
*result = rtems_rfs_group_inode (fs, group, bit);
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
400131e0: 82 00 80 01 add %g2, %g1, %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
400131e4: 13 00 00 80 sethi %hi(0x20000), %o1
400131e8: 40 00 07 af call 400150a4 <rtems_rfs_trace>
400131ec: c2 26 c0 00 st %g1, [ %i3 ]
400131f0: 80 8a 20 ff btst 0xff, %o0
400131f4: 02 80 00 07 be 40013210 <rtems_rfs_group_bitmap_alloc+0x1fc><== ALWAYS TAKEN
400131f8: 13 10 00 db sethi %hi(0x40036c00), %o1
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
400131fc: 92 12 62 78 or %o1, 0x278, %o1 ! 40036e78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
40013200: d4 06 c0 00 ld [ %i3 ], %o2 <== NOT EXECUTED
40013204: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40013208: 40 00 47 dd call 4002517c <printf> <== NOT EXECUTED
4001320c: 90 12 22 80 or %o0, 0x280, %o0 ! 40036e80 <_CPU_Trap_slot_template+0x998><== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
40013210: 10 bf ff e4 b 400131a0 <rtems_rfs_group_bitmap_alloc+0x18c>
40013214: 90 10 20 00 clr %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
{
if (inode)
*result = rtems_rfs_group_inode (fs, group, bit);
40013218: 90 10 00 1d mov %i5, %o0
4001321c: 7f ff bc e7 call 400025b8 <.umul>
40013220: fa 07 bf fc ld [ %fp + -4 ], %i5
40013224: ba 07 60 01 inc %i5
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40013228: 13 00 00 80 sethi %hi(0x20000), %o1
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
{
if (inode)
*result = rtems_rfs_group_inode (fs, group, bit);
4001322c: ba 07 40 08 add %i5, %o0, %i5
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
40013230: 90 10 20 00 clr %o0
40013234: 40 00 07 9c call 400150a4 <rtems_rfs_trace>
40013238: fa 26 c0 00 st %i5, [ %i3 ]
4001323c: 80 8a 20 ff btst 0xff, %o0
40013240: 02 bf ff f4 be 40013210 <rtems_rfs_group_bitmap_alloc+0x1fc><== ALWAYS TAKEN
40013244: 13 10 00 db sethi %hi(0x40036c00), %o1
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40013248: 10 bf ff ee b 40013200 <rtems_rfs_group_bitmap_alloc+0x1ec><== NOT EXECUTED
4001324c: 92 12 62 70 or %o1, 0x270, %o1 ! 40036e70 <_CPU_Trap_slot_template+0x988><== NOT EXECUTED
40013250 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
40013250: 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))
40013254: 90 10 20 00 clr %o0
40013258: 13 00 00 80 sethi %hi(0x20000), %o1
4001325c: 40 00 07 92 call 400150a4 <rtems_rfs_trace>
40013260: ba 10 00 18 mov %i0, %i5
40013264: 80 8a 20 ff btst 0xff, %o0
40013268: 02 80 00 0b be 40013294 <rtems_rfs_group_bitmap_free+0x44><== ALWAYS TAKEN
4001326c: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
40013270: 12 80 00 3a bne 40013358 <rtems_rfs_group_bitmap_free+0x108><== NOT EXECUTED
40013274: 13 10 00 db sethi %hi(0x40036c00), %o1 <== NOT EXECUTED
40013278: 13 10 00 db sethi %hi(0x40036c00), %o1 <== NOT EXECUTED
4001327c: 92 12 62 78 or %o1, 0x278, %o1 ! 40036e78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
40013280: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40013284: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40013288: 40 00 47 bd call 4002517c <printf> <== NOT EXECUTED
4001328c: 90 12 22 f0 or %o0, 0x2f0, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
40013290: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40013294: 22 80 00 1a be,a 400132fc <rtems_rfs_group_bitmap_free+0xac>
40013298: f8 07 60 28 ld [ %i5 + 0x28 ], %i4
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
4001329c: f8 07 60 2c ld [ %i5 + 0x2c ], %i4
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
inode ? "inode" : "block", no);
if (inode)
{
no -= RTEMS_RFS_ROOT_INO;
400132a0: b4 06 bf ff add %i2, -1, %i2
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
400132a4: 92 10 00 1c mov %i4, %o1
400132a8: 40 00 79 4b call 400317d4 <.urem>
400132ac: 90 10 00 1a mov %i2, %o0
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
400132b0: 92 10 00 1c mov %i4, %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
400132b4: b6 10 00 08 mov %o0, %i3
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
400132b8: 7f ff bc fa call 400026a0 <.udiv>
400132bc: 90 10 00 1a mov %i2, %o0
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
400132c0: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
400132c4: 83 2a 20 04 sll %o0, 4, %g1
400132c8: 91 2a 20 06 sll %o0, 6, %o0
400132cc: 90 00 40 08 add %g1, %o0, %o0
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
400132d0: 92 10 00 1b mov %i3, %o1
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
400132d4: b8 07 00 08 add %i4, %o0, %i4
400132d8: b8 07 20 2c add %i4, 0x2c, %i4
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
400132dc: 40 00 23 33 call 4001bfa8 <rtems_rfs_bitmap_map_clear>
400132e0: 90 10 00 1c mov %i4, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
400132e4: 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);
400132e8: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
400132ec: 40 00 28 d3 call 4001d638 <rtems_rfs_buffer_handle_release>
400132f0: 90 10 00 1d mov %i5, %o0
return rc;
}
400132f4: 81 c7 e0 08 ret
400132f8: 81 e8 00 00 restore
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
400132fc: b4 06 bf ff add %i2, -1, %i2
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
40013300: 92 10 00 1c mov %i4, %o1
40013304: 40 00 79 34 call 400317d4 <.urem>
40013308: 90 10 00 1a mov %i2, %o0
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
4001330c: 92 10 00 1c mov %i4, %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
40013310: b6 10 00 08 mov %o0, %i3
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
40013314: 7f ff bc e3 call 400026a0 <.udiv>
40013318: 90 10 00 1a mov %i2, %o0
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
4001331c: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
40013320: 83 2a 20 04 sll %o0, 4, %g1
40013324: 91 2a 20 06 sll %o0, 6, %o0
40013328: 90 00 40 08 add %g1, %o0, %o0
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
4001332c: 92 10 00 1b mov %i3, %o1
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
40013330: b8 07 00 08 add %i4, %o0, %i4
40013334: b8 07 20 08 add %i4, 8, %i4
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
40013338: 40 00 23 1c call 4001bfa8 <rtems_rfs_bitmap_map_clear>
4001333c: 90 10 00 1c mov %i4, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40013340: 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);
40013344: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40013348: 40 00 28 bc call 4001d638 <rtems_rfs_buffer_handle_release>
4001334c: 90 10 00 1d mov %i5, %o0
return rc;
}
40013350: 81 c7 e0 08 ret
40013354: 81 e8 00 00 restore
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
40013358: 10 bf ff ca b 40013280 <rtems_rfs_group_bitmap_free+0x30> <== NOT EXECUTED
4001335c: 92 12 62 70 or %o1, 0x270, %o1 <== NOT EXECUTED
40013360 <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)
{
40013360: 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))
40013364: 90 10 20 00 clr %o0 <== NOT EXECUTED
40013368: 13 00 00 80 sethi %hi(0x20000), %o1 <== NOT EXECUTED
4001336c: 40 00 07 4e call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40013370: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
40013374: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40013378: 02 80 00 0b be 400133a4 <rtems_rfs_group_bitmap_test+0x44><== NOT EXECUTED
4001337c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
40013380: 12 80 00 2f bne 4001343c <rtems_rfs_group_bitmap_test+0xdc><== NOT EXECUTED
40013384: 13 10 00 db sethi %hi(0x40036c00), %o1 <== NOT EXECUTED
40013388: 13 10 00 db sethi %hi(0x40036c00), %o1 <== NOT EXECUTED
4001338c: 92 12 62 78 or %o1, 0x278, %o1 ! 40036e78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
40013390: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40013394: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40013398: 40 00 47 79 call 4002517c <printf> <== NOT EXECUTED
4001339c: 90 12 23 20 or %o0, 0x320, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
400133a0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
400133a4: 22 80 00 0b be,a 400133d0 <rtems_rfs_group_bitmap_test+0x70><== NOT EXECUTED
400133a8: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
400133ac: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
400133b0: 04 80 00 06 ble 400133c8 <rtems_rfs_group_bitmap_test+0x68><== NOT EXECUTED
400133b4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
400133b8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
400133bc: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
400133c0: 28 80 00 21 bleu,a 40013444 <rtems_rfs_group_bitmap_test+0xe4><== NOT EXECUTED
400133c4: f8 07 60 2c ld [ %i5 + 0x2c ], %i4 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
rtems_rfs_bitmap_release_buffer (fs, bitmap);
return rc;
}
400133c8: 81 c7 e0 08 ret <== NOT EXECUTED
400133cc: 81 e8 00 00 restore <== NOT EXECUTED
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
400133d0: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
400133d4: 1a bf ff fd bcc 400133c8 <rtems_rfs_group_bitmap_test+0x68><== NOT EXECUTED
400133d8: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
400133dc: f8 07 60 28 ld [ %i5 + 0x28 ], %i4 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
400133e0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
400133e4: 40 00 78 fc call 400317d4 <.urem> <== NOT EXECUTED
400133e8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
400133ec: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
400133f0: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
400133f4: 7f ff bc ab call 400026a0 <.udiv> <== NOT EXECUTED
400133f8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
400133fc: f8 07 60 20 ld [ %i5 + 0x20 ], %i4 <== NOT EXECUTED
40013400: 83 2a 20 04 sll %o0, 4, %g1 <== NOT EXECUTED
40013404: 91 2a 20 06 sll %o0, 6, %o0 <== NOT EXECUTED
40013408: 90 00 40 08 add %g1, %o0, %o0 <== NOT EXECUTED
4001340c: b8 07 00 08 add %i4, %o0, %i4 <== NOT EXECUTED
40013410: b8 07 20 08 add %i4, 8, %i4 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
40013414: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40013418: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4001341c: 40 00 23 06 call 4001c034 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
40013420: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
40013424: 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);
40013428: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
4001342c: 40 00 28 83 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40013430: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
}
40013434: 81 c7 e0 08 ret <== NOT EXECUTED
40013438: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
4001343c: 10 bf ff d5 b 40013390 <rtems_rfs_group_bitmap_test+0x30> <== NOT EXECUTED
40013440: 92 12 62 70 or %o1, 0x270, %o1 <== NOT EXECUTED
if (inode)
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
40013444: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
40013448: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4001344c: 40 00 78 e2 call 400317d4 <.urem> <== NOT EXECUTED
40013450: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
40013454: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
40013458: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
4001345c: 7f ff bc 91 call 400026a0 <.udiv> <== NOT EXECUTED
40013460: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
40013464: f8 07 60 20 ld [ %i5 + 0x20 ], %i4 <== NOT EXECUTED
40013468: 83 2a 20 04 sll %o0, 4, %g1 <== NOT EXECUTED
4001346c: 91 2a 20 06 sll %o0, 6, %o0 <== NOT EXECUTED
40013470: 90 00 40 08 add %g1, %o0, %o0 <== NOT EXECUTED
40013474: b8 07 00 08 add %i4, %o0, %i4 <== NOT EXECUTED
40013478: 10 bf ff e7 b 40013414 <rtems_rfs_group_bitmap_test+0xb4> <== NOT EXECUTED
4001347c: b8 07 20 2c add %i4, 0x2c, %i4 <== NOT EXECUTED
40012f68 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
40012f68: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
40012f6c: 90 10 20 00 clr %o0
40012f70: 13 00 00 40 sethi %hi(0x10000), %o1
40012f74: 40 00 08 4c call 400150a4 <rtems_rfs_trace>
40012f78: ba 10 00 18 mov %i0, %i5
40012f7c: 80 8a 20 ff btst 0xff, %o0
40012f80: 32 80 00 17 bne,a 40012fdc <rtems_rfs_group_close+0x74> <== NEVER TAKEN
40012f84: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
/*
* We need to close as much as possible and also return any error if one
* occurs but this may result in one even more important error being lost but
* we cannot OR the errors together so this is a reasonable compromise.
*/
rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
40012f88: 40 00 25 24 call 4001c418 <rtems_rfs_bitmap_close>
40012f8c: 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);
40012f90: 92 06 60 44 add %i1, 0x44, %o1
40012f94: b8 10 00 08 mov %o0, %i4
40012f98: 40 00 29 a8 call 4001d638 <rtems_rfs_buffer_handle_release>
40012f9c: 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);
40012fa0: 90 06 60 08 add %i1, 8, %o0
handle->dirty = false;
40012fa4: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
40012fa8: c0 26 60 48 clr [ %i1 + 0x48 ]
40012fac: 40 00 25 1b call 4001c418 <rtems_rfs_bitmap_close>
40012fb0: c0 26 60 4c clr [ %i1 + 0x4c ]
if (rc > 0)
40012fb4: b0 92 20 00 orcc %o0, 0, %i0
40012fb8: 04 80 00 0d ble 40012fec <rtems_rfs_group_close+0x84> <== ALWAYS TAKEN
40012fbc: 90 10 00 1d mov %i5, %o0
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40012fc0: 40 00 29 9e call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012fc4: 92 06 60 20 add %i1, 0x20, %o1 <== NOT EXECUTED
handle->dirty = false;
40012fc8: c0 2e 60 20 clrb [ %i1 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
40012fcc: c0 26 60 24 clr [ %i1 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
40012fd0: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rc > 0)
result = rc;
return result;
}
40012fd4: 81 c7 e0 08 ret <== NOT EXECUTED
40012fd8: 81 e8 00 00 restore <== NOT EXECUTED
{
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
40012fdc: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40012fe0: 40 00 48 67 call 4002517c <printf> <== NOT EXECUTED
40012fe4: 90 12 22 48 or %o0, 0x248, %o0 ! 40036e48 <_CPU_Trap_slot_template+0x960><== NOT EXECUTED
40012fe8: 30 bf ff e8 b,a 40012f88 <rtems_rfs_group_close+0x20> <== NOT EXECUTED
40012fec: b0 38 00 1c xnor %g0, %i4, %i0
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
40012ff0: 92 06 60 20 add %i1, 0x20, %o1
40012ff4: 40 00 29 91 call 4001d638 <rtems_rfs_buffer_handle_release>
40012ff8: b1 3e 20 1f sra %i0, 0x1f, %i0
40012ffc: b0 0f 00 18 and %i4, %i0, %i0
handle->dirty = false;
40013000: c0 2e 60 20 clrb [ %i1 + 0x20 ]
handle->bnum = 0;
40013004: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->buffer = NULL;
40013008: 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;
}
4001300c: 81 c7 e0 08 ret
40013010: 81 e8 00 00 restore
40012d34 <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)
{
40012d34: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
40012d38: c2 06 20 04 ld [ %i0 + 4 ], %g1
40012d3c: 80 a0 40 19 cmp %g1, %i1
40012d40: 08 80 00 44 bleu 40012e50 <rtems_rfs_group_open+0x11c> <== NEVER TAKEN
40012d44: ba 10 00 18 mov %i0, %i5
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
40012d48: 84 06 80 19 add %i2, %i1, %g2
40012d4c: 80 a0 40 02 cmp %g1, %g2
40012d50: 28 80 00 02 bleu,a 40012d58 <rtems_rfs_group_open+0x24> <== ALWAYS TAKEN
40012d54: b4 20 40 19 sub %g1, %i1, %i2
40012d58: 80 a6 80 1b cmp %i2, %i3
40012d5c: 18 80 00 25 bgu 40012df0 <rtems_rfs_group_open+0xbc> <== ALWAYS TAKEN
40012d60: a2 10 00 1a mov %i2, %l1
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40012d64: 90 10 20 00 clr %o0 <== NOT EXECUTED
40012d68: 40 00 08 cf call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40012d6c: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
40012d70: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40012d74: 12 80 00 27 bne 40012e10 <rtems_rfs_group_open+0xdc> <== NOT EXECUTED
40012d78: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
base, size, inodes);
group->base = base;
40012d7c: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
group->size = size;
40012d80: 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;
40012d84: c0 2f 20 20 clrb [ %i4 + 0x20 ]
handle->bnum = 0;
40012d88: c0 27 20 24 clr [ %i4 + 0x24 ]
handle->buffer = NULL;
40012d8c: 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,
40012d90: a0 07 20 08 add %i4, 8, %l0
40012d94: b6 07 20 20 add %i4, 0x20, %i3
40012d98: 90 10 00 10 mov %l0, %o0
40012d9c: 92 10 00 1d mov %i5, %o1
40012da0: 94 10 00 1b mov %i3, %o2
40012da4: 96 10 00 1a mov %i2, %o3
40012da8: 40 00 25 8b call 4001c3d4 <rtems_rfs_bitmap_open>
40012dac: 98 10 00 19 mov %i1, %o4
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
40012db0: b0 92 20 00 orcc %o0, 0, %i0
40012db4: 04 80 00 37 ble 40012e90 <rtems_rfs_group_open+0x15c> <== ALWAYS TAKEN
40012db8: 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);
40012dbc: 40 00 2a 1f call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012dc0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40012dc4: 90 10 20 00 clr %o0 <== NOT EXECUTED
40012dc8: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
handle->dirty = false;
40012dcc: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
40012dd0: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
40012dd4: 40 00 08 b4 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40012dd8: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
40012ddc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40012de0: 12 80 00 13 bne 40012e2c <rtems_rfs_group_open+0xf8> <== NOT EXECUTED
40012de4: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
}
40012de8: 81 c7 e0 08 ret <== NOT EXECUTED
40012dec: 81 e8 00 00 restore <== NOT EXECUTED
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40012df0: 90 10 20 00 clr %o0
40012df4: 13 00 00 20 sethi %hi(0x8000), %o1
40012df8: 40 00 08 ab call 400150a4 <rtems_rfs_trace>
40012dfc: a2 10 00 1b mov %i3, %l1
40012e00: 80 8a 20 ff btst 0xff, %o0
40012e04: 22 bf ff df be,a 40012d80 <rtems_rfs_group_open+0x4c> <== ALWAYS TAKEN
40012e08: f2 27 00 00 st %i1, [ %i4 ]
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
40012e0c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40012e10: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40012e14: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40012e18: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
40012e1c: 40 00 48 d8 call 4002517c <printf> <== NOT EXECUTED
40012e20: 90 12 21 90 or %o0, 0x190, %o0 <== NOT EXECUTED
base, size, inodes);
group->base = base;
40012e24: 10 bf ff d7 b 40012d80 <rtems_rfs_group_open+0x4c> <== NOT EXECUTED
40012e28: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
40012e2c: 40 00 4d 1e call 400262a4 <strerror> <== NOT EXECUTED
40012e30: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40012e34: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40012e38: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012e3c: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40012e40: 40 00 48 cf call 4002517c <printf> <== NOT EXECUTED
40012e44: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 40036dc8 <_CPU_Trap_slot_template+0x8e0><== NOT EXECUTED
40012e48: 81 c7 e0 08 ret <== NOT EXECUTED
40012e4c: 81 e8 00 00 restore <== NOT EXECUTED
{
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40012e50: 90 10 20 00 clr %o0 <== NOT EXECUTED
40012e54: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
40012e58: 40 00 08 93 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40012e5c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
40012e60: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40012e64: 02 80 00 3f be 40012f60 <rtems_rfs_group_open+0x22c> <== NOT EXECUTED
40012e68: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
40012e6c: 40 00 4d 0e call 400262a4 <strerror> <== NOT EXECUTED
40012e70: 90 10 20 05 mov 5, %o0 ! 5 <PROM_START+0x5> <== NOT EXECUTED
40012e74: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
40012e78: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012e7c: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40012e80: 40 00 48 bf call 4002517c <printf> <== NOT EXECUTED
40012e84: 90 12 21 50 or %o0, 0x150, %o0 ! 40036d50 <_CPU_Trap_slot_template+0x868><== NOT EXECUTED
40012e88: 81 c7 e0 08 ret <== NOT EXECUTED
40012e8c: 81 e8 00 00 restore <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
40012e90: 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;
40012e94: c0 2f 20 44 clrb [ %i4 + 0x44 ]
handle->bnum = 0;
40012e98: c0 27 20 48 clr [ %i4 + 0x48 ]
handle->buffer = NULL;
40012e9c: c0 27 20 4c clr [ %i4 + 0x4c ]
40012ea0: b4 07 20 44 add %i4, 0x44, %i2
40012ea4: 90 07 20 2c add %i4, 0x2c, %o0
40012ea8: 92 10 00 1d mov %i5, %o1
40012eac: 94 10 00 1a mov %i2, %o2
40012eb0: 96 10 00 11 mov %l1, %o3
40012eb4: 40 00 25 48 call 4001c3d4 <rtems_rfs_bitmap_open>
40012eb8: 98 03 20 01 inc %o4
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
40012ebc: b0 92 20 00 orcc %o0, 0, %i0
40012ec0: 04 80 00 1e ble 40012f38 <rtems_rfs_group_open+0x204> <== ALWAYS TAKEN
40012ec4: 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);
40012ec8: 40 00 29 dc call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012ecc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
rtems_rfs_bitmap_close (&group->block_bitmap);
40012ed0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
handle->dirty = false;
40012ed4: c0 2f 20 44 clrb [ %i4 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
40012ed8: c0 27 20 48 clr [ %i4 + 0x48 ] <== NOT EXECUTED
40012edc: 40 00 25 4f call 4001c418 <rtems_rfs_bitmap_close> <== NOT EXECUTED
40012ee0: 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);
40012ee4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40012ee8: 40 00 29 d4 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012eec: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
40012ef0: 90 10 20 00 clr %o0 <== NOT EXECUTED
40012ef4: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
handle->dirty = false;
40012ef8: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
40012efc: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
40012f00: 40 00 08 69 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40012f04: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
40012f08: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40012f0c: 02 80 00 15 be 40012f60 <rtems_rfs_group_open+0x22c> <== NOT EXECUTED
40012f10: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
40012f14: 40 00 4c e4 call 400262a4 <strerror> <== NOT EXECUTED
40012f18: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40012f1c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40012f20: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40012f24: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40012f28: 40 00 48 95 call 4002517c <printf> <== NOT EXECUTED
40012f2c: 90 12 22 08 or %o0, 0x208, %o0 ! 40036e08 <_CPU_Trap_slot_template+0x920><== NOT EXECUTED
40012f30: 81 c7 e0 08 ret <== NOT EXECUTED
40012f34: 81 e8 00 00 restore <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
40012f38: c2 07 40 00 ld [ %i5 ], %g1
40012f3c: 80 88 60 01 btst 1, %g1
40012f40: 12 bf ff aa bne 40012de8 <rtems_rfs_group_open+0xb4> <== NEVER TAKEN
40012f44: b0 10 20 00 clr %i0
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
40012f48: d2 07 20 08 ld [ %i4 + 8 ], %o1
40012f4c: 40 00 29 bb call 4001d638 <rtems_rfs_buffer_handle_release>
40012f50: 90 10 00 1d mov %i5, %o0
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
40012f54: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
40012f58: 40 00 29 b8 call 4001d638 <rtems_rfs_buffer_handle_release>
40012f5c: 90 10 00 1d mov %i5, %o0
}
return 0;
}
40012f60: 81 c7 e0 08 ret
40012f64: 81 e8 00 00 restore
40013480 <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
40013480: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED
*inodes = 0;
40013484: c0 22 80 00 clr [ %o2 ] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
40013488: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED
4001348c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40013490: 04 80 00 14 ble 400134e0 <rtems_rfs_group_usage+0x60> <== NOT EXECUTED
40013494: 84 10 20 00 clr %g2 <== NOT EXECUTED
40013498: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
4001349c: da 00 60 14 ld [ %g1 + 0x14 ], %o5 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
400134a0: c8 00 60 18 ld [ %g1 + 0x18 ], %g4 <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
400134a4: c6 02 40 00 ld [ %o1 ], %g3 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
400134a8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
400134ac: 86 03 40 03 add %o5, %g3, %g3 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
400134b0: 86 20 c0 04 sub %g3, %g4, %g3 <== NOT EXECUTED
400134b4: c6 22 40 00 st %g3, [ %o1 ] <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
400134b8: da 00 60 38 ld [ %g1 + 0x38 ], %o5 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
400134bc: c8 00 60 3c ld [ %g1 + 0x3c ], %g4 <== NOT EXECUTED
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
400134c0: c6 02 80 00 ld [ %o2 ], %g3 <== NOT EXECUTED
400134c4: 86 03 40 03 add %o5, %g3, %g3 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
400134c8: 86 20 c0 04 sub %g3, %g4, %g3 <== NOT EXECUTED
400134cc: c6 22 80 00 st %g3, [ %o2 ] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
400134d0: c6 02 20 24 ld [ %o0 + 0x24 ], %g3 <== NOT EXECUTED
400134d4: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
400134d8: 14 bf ff f1 bg 4001349c <rtems_rfs_group_usage+0x1c> <== NOT EXECUTED
400134dc: 82 00 60 50 add %g1, 0x50, %g1 <== NOT EXECUTED
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
rtems_rfs_bitmap_map_free (&group->inode_bitmap);
}
if (*blocks > rtems_rfs_fs_blocks (fs))
400134e0: c4 02 20 04 ld [ %o0 + 4 ], %g2 <== NOT EXECUTED
400134e4: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED
400134e8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
400134ec: 38 80 00 02 bgu,a 400134f4 <rtems_rfs_group_usage+0x74> <== NOT EXECUTED
400134f0: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
400134f4: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
400134f8: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 <== NOT EXECUTED
400134fc: c2 02 80 00 ld [ %o2 ], %g1 <== NOT EXECUTED
40013500: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40013504: 38 80 00 02 bgu,a 4001350c <rtems_rfs_group_usage+0x8c> <== NOT EXECUTED
40013508: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
4001350c: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
40013510: 81 c3 e0 08 retl <== NOT EXECUTED
40013514: 90 10 20 00 clr %o0 <== NOT EXECUTED
400137e8 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
400137e8: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
400137ec: 90 10 20 00 clr %o0
400137f0: 40 00 06 2d call 400150a4 <rtems_rfs_trace>
400137f4: 13 00 02 00 sethi %hi(0x80000), %o1
400137f8: 80 8a 20 ff btst 0xff, %o0
400137fc: 32 80 00 16 bne,a 40013854 <rtems_rfs_inode_close+0x6c> <== NEVER TAKEN
40013800: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
rc = rtems_rfs_inode_unload (fs, handle, true);
40013804: 90 10 00 18 mov %i0, %o0
40013808: 92 10 00 19 mov %i1, %o1
4001380c: 7f ff ff b6 call 400136e4 <rtems_rfs_inode_unload>
40013810: 94 10 20 01 mov 1, %o2
if ((rc == 0) && (handle->loads > 0))
40013814: b0 92 20 00 orcc %o0, 0, %i0
40013818: 32 80 00 0d bne,a 4001384c <rtems_rfs_inode_close+0x64> <== NEVER TAKEN
4001381c: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
40013820: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40013824: 80 a0 60 00 cmp %g1, 0
40013828: 04 80 00 08 ble 40013848 <rtems_rfs_inode_close+0x60> <== ALWAYS TAKEN
4001382c: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
40013830: 13 00 02 00 sethi %hi(0x80000), %o1 <== NOT EXECUTED
40013834: 40 00 06 1c call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40013838: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4001383c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40013840: 32 80 00 0a bne,a 40013868 <rtems_rfs_inode_close+0x80> <== NOT EXECUTED
40013844: d2 06 60 24 ld [ %i1 + 0x24 ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
handle->loads);
rc = EIO;
}
handle->ino = 0;
40013848: c0 26 60 08 clr [ %i1 + 8 ]
return rc;
}
4001384c: 81 c7 e0 08 ret
40013850: 81 e8 00 00 restore
rtems_rfs_inode_handle* handle)
{
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
40013854: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
40013858: 40 00 46 49 call 4002517c <printf> <== NOT EXECUTED
4001385c: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 40036ff0 <_CPU_Trap_slot_template+0xb08><== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
40013860: 10 bf ff ea b 40013808 <rtems_rfs_inode_close+0x20> <== NOT EXECUTED
40013864: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ((rc == 0) && (handle->loads > 0))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
40013868: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001386c: 40 00 46 44 call 4002517c <printf> <== NOT EXECUTED
40013870: 90 12 20 18 or %o0, 0x18, %o0 ! 40037018 <_CPU_Trap_slot_template+0xb30><== NOT EXECUTED
handle->loads);
rc = EIO;
}
handle->ino = 0;
40013874: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
return rc;
}
40013878: 81 c7 e0 08 ret <== NOT EXECUTED
4001387c: 81 e8 00 00 restore <== NOT EXECUTED
40013b50 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
40013b50: 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))
40013b54: 90 10 20 00 clr %o0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
40013b58: e4 17 a0 5e lduh [ %fp + 0x5e ], %l2
40013b5c: e2 17 a0 62 lduh [ %fp + 0x62 ], %l1
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
40013b60: 13 00 10 00 sethi %hi(0x400000), %o1
40013b64: 40 00 05 50 call 400150a4 <rtems_rfs_trace>
40013b68: a6 0f 30 00 and %i4, -4096, %l3
40013b6c: 80 8a 20 ff btst 0xff, %o0
40013b70: 22 80 00 28 be,a 40013c10 <rtems_rfs_inode_create+0xc0> <== ALWAYS TAKEN
40013b74: a7 2c e0 10 sll %l3, 0x10, %l3
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
40013b78: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
40013b7c: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
40013b80: 02 80 00 4f be 40013cbc <rtems_rfs_inode_create+0x16c> <== NOT EXECUTED
40013b84: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
40013b88: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
40013b8c: 02 80 00 52 be 40013cd4 <rtems_rfs_inode_create+0x184> <== NOT EXECUTED
40013b90: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
40013b94: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
40013b98: 02 80 00 4c be 40013cc8 <rtems_rfs_inode_create+0x178> <== NOT EXECUTED
40013b9c: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
40013ba0: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
40013ba4: 02 80 00 4f be 40013ce0 <rtems_rfs_inode_create+0x190> <== NOT EXECUTED
40013ba8: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
40013bac: 29 10 00 dc sethi %hi(0x40037000), %l4 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
40013bb0: 80 a4 c0 02 cmp %l3, %g2 <== NOT EXECUTED
40013bb4: 02 80 00 4e be 40013cec <rtems_rfs_inode_create+0x19c> <== NOT EXECUTED
40013bb8: a8 15 20 90 or %l4, 0x90, %l4 <== NOT EXECUTED
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
40013bbc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40013bc0: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40013bc4: 40 00 45 6e call 4002517c <printf> <== NOT EXECUTED
40013bc8: 90 12 20 a0 or %o0, 0xa0, %o0 ! 400370a0 <_CPU_Trap_slot_template+0xbb8><== NOT EXECUTED
for (c = 0; c < length; c++)
40013bcc: a0 10 20 00 clr %l0 <== NOT EXECUTED
40013bd0: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
40013bd4: 02 80 00 08 be 40013bf4 <rtems_rfs_inode_create+0xa4> <== NOT EXECUTED
40013bd8: 82 10 20 00 clr %g1 <== NOT EXECUTED
printf ("%c", name[c]);
40013bdc: d0 4e 80 01 ldsb [ %i2 + %g1 ], %o0 <== NOT EXECUTED
40013be0: 40 00 45 d1 call 40025324 <putchar> <== NOT EXECUTED
40013be4: a0 04 20 01 inc %l0 <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
40013be8: 80 a4 00 1b cmp %l0, %i3 <== NOT EXECUTED
40013bec: 12 bf ff fc bne 40013bdc <rtems_rfs_inode_create+0x8c> <== NOT EXECUTED
40013bf0: 82 10 00 10 mov %l0, %g1 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
40013bf4: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40013bf8: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
40013bfc: 90 12 20 d0 or %o0, 0xd0, %o0 <== NOT EXECUTED
40013c00: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40013c04: 40 00 45 5e call 4002517c <printf> <== NOT EXECUTED
40013c08: 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)
40013c0c: a7 2c e0 10 sll %l3, 0x10, %l3 <== NOT EXECUTED
40013c10: 05 00 00 18 sethi %hi(0x6000), %g2
40013c14: 83 34 e0 10 srl %l3, 0x10, %g1
40013c18: 80 a0 40 02 cmp %g1, %g2
40013c1c: 02 80 00 15 be 40013c70 <rtems_rfs_inode_create+0x120> <== NEVER TAKEN
40013c20: d4 07 a0 64 ld [ %fp + 0x64 ], %o2
40013c24: 08 80 00 0c bleu 40013c54 <rtems_rfs_inode_create+0x104>
40013c28: 05 00 00 08 sethi %hi(0x2000), %g2
40013c2c: 05 00 00 20 sethi %hi(0x8000), %g2
40013c30: 80 a0 40 02 cmp %g1, %g2
40013c34: 02 80 00 0f be 40013c70 <rtems_rfs_inode_create+0x120>
40013c38: 05 00 00 28 sethi %hi(0xa000), %g2
40013c3c: 80 a0 40 02 cmp %g1, %g2
40013c40: 02 80 00 0d be 40013c74 <rtems_rfs_inode_create+0x124> <== ALWAYS TAKEN
40013c44: 90 10 00 18 mov %i0, %o0
case RTEMS_RFS_S_IFBLK:
case RTEMS_RFS_S_IFREG:
case RTEMS_RFS_S_IFLNK:
break;
default:
return EINVAL;
40013c48: a0 10 20 16 mov 0x16, %l0 <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
}
40013c4c: 81 c7 e0 08 ret
40013c50: 91 e8 00 10 restore %g0, %l0, %o0
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
40013c54: 80 a0 40 02 cmp %g1, %g2
40013c58: 02 80 00 05 be 40013c6c <rtems_rfs_inode_create+0x11c> <== NEVER TAKEN
40013c5c: 05 00 00 10 sethi %hi(0x4000), %g2
40013c60: 80 a0 40 02 cmp %g1, %g2
40013c64: 12 bf ff fa bne 40013c4c <rtems_rfs_inode_create+0xfc> <== NEVER TAKEN
40013c68: a0 10 20 16 mov 0x16, %l0
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
40013c6c: d4 07 a0 64 ld [ %fp + 0x64 ], %o2
40013c70: 90 10 00 18 mov %i0, %o0
40013c74: 7f ff fe 29 call 40013518 <rtems_rfs_inode_alloc>
40013c78: 92 10 00 19 mov %i1, %o1
if (rc > 0)
40013c7c: a0 92 20 00 orcc %o0, 0, %l0
40013c80: 14 bf ff f3 bg 40013c4c <rtems_rfs_inode_create+0xfc>
40013c84: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
40013c88: 90 10 00 18 mov %i0, %o0
40013c8c: d2 00 40 00 ld [ %g1 ], %o1
40013c90: 94 07 bf d8 add %fp, -40, %o2
40013c94: 7f ff fe 5d call 40013608 <rtems_rfs_inode_open>
40013c98: 96 10 20 01 mov 1, %o3
if (rc > 0)
40013c9c: a0 92 20 00 orcc %o0, 0, %l0
40013ca0: 04 80 00 16 ble 40013cf8 <rtems_rfs_inode_create+0x1a8> <== ALWAYS TAKEN
40013ca4: 90 07 bf d8 add %fp, -40, %o0
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
40013ca8: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 <== NOT EXECUTED
40013cac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40013cb0: 7f ff fe 24 call 40013540 <rtems_rfs_inode_free> <== NOT EXECUTED
40013cb4: d2 00 40 00 ld [ %g1 ], %o1 <== NOT EXECUTED
40013cb8: 30 bf ff e5 b,a 40013c4c <rtems_rfs_inode_create+0xfc> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
40013cbc: 29 10 00 dc sethi %hi(0x40037000), %l4 <== NOT EXECUTED
40013cc0: 10 bf ff bf b 40013bbc <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
40013cc4: a8 15 20 78 or %l4, 0x78, %l4 ! 40037078 <_CPU_Trap_slot_template+0xb90><== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
40013cc8: 29 10 00 db sethi %hi(0x40036c00), %l4 <== NOT EXECUTED
40013ccc: 10 bf ff bc b 40013bbc <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
40013cd0: a8 15 22 78 or %l4, 0x278, %l4 ! 40036e78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
40013cd4: 29 10 00 dc sethi %hi(0x40037000), %l4 <== NOT EXECUTED
40013cd8: 10 bf ff b9 b 40013bbc <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
40013cdc: a8 15 20 80 or %l4, 0x80, %l4 ! 40037080 <_CPU_Trap_slot_template+0xb98><== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
40013ce0: 29 10 00 dc sethi %hi(0x40037000), %l4 <== NOT EXECUTED
40013ce4: 10 bf ff b6 b 40013bbc <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
40013ce8: a8 15 20 88 or %l4, 0x88, %l4 ! 40037088 <_CPU_Trap_slot_template+0xba0><== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
40013cec: 29 10 00 dc sethi %hi(0x40037000), %l4 <== NOT EXECUTED
40013cf0: 10 bf ff b3 b 40013bbc <rtems_rfs_inode_create+0x6c> <== NOT EXECUTED
40013cf4: a8 15 20 98 or %l4, 0x98, %l4 ! 40037098 <_CPU_Trap_slot_template+0xbb0><== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
40013cf8: 92 10 00 1d mov %i5, %o1
40013cfc: 94 10 00 1c mov %i4, %o2
40013d00: 96 10 00 12 mov %l2, %o3
40013d04: 7f ff ff 3d call 400139f8 <rtems_rfs_inode_initialise>
40013d08: 98 10 00 11 mov %l1, %o4
if (rc > 0)
40013d0c: a0 92 20 00 orcc %o0, 0, %l0
40013d10: 14 80 00 13 bg 40013d5c <rtems_rfs_inode_create+0x20c> <== NEVER TAKEN
40013d14: 03 10 00 00 sethi %hi(0x40000000), %g1
/*
* Only handle the specifics of a directory. Let caller handle the others.
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
40013d18: 80 a4 c0 01 cmp %l3, %g1
40013d1c: 02 80 00 45 be 40013e30 <rtems_rfs_inode_create+0x2e0>
40013d20: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
40013d24: 90 10 00 18 mov %i0, %o0
40013d28: 92 10 00 19 mov %i1, %o1
40013d2c: 94 07 bf b0 add %fp, -80, %o2
40013d30: 7f ff fe 36 call 40013608 <rtems_rfs_inode_open>
40013d34: 96 10 20 01 mov 1, %o3
if (rc > 0)
40013d38: a0 92 20 00 orcc %o0, 0, %l0
40013d3c: 04 80 00 10 ble 40013d7c <rtems_rfs_inode_create+0x22c> <== ALWAYS TAKEN
40013d40: 92 07 bf d8 add %fp, -40, %o1
{
rtems_rfs_inode_delete (fs, &inode);
40013d44: 7f ff fe cf call 40013880 <rtems_rfs_inode_delete> <== NOT EXECUTED
40013d48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40013d4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40013d50: 7f ff fe a6 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40013d54: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40013d58: 30 bf ff bd b,a 40013c4c <rtems_rfs_inode_create+0xfc> <== NOT EXECUTED
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
40013d5c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40013d60: 7f ff fe a2 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40013d64: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
40013d68: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 <== NOT EXECUTED
40013d6c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40013d70: 7f ff fd f4 call 40013540 <rtems_rfs_inode_free> <== NOT EXECUTED
40013d74: d2 00 40 00 ld [ %g1 ], %o1 <== NOT EXECUTED
40013d78: 30 bf ff b5 b,a 40013c4c <rtems_rfs_inode_create+0xfc> <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
40013d7c: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
40013d80: 90 10 00 18 mov %i0, %o0
40013d84: d8 00 40 00 ld [ %g1 ], %o4
40013d88: 92 07 bf b0 add %fp, -80, %o1
40013d8c: 94 10 00 1a mov %i2, %o2
40013d90: 40 00 29 e5 call 4001e524 <rtems_rfs_dir_add_entry>
40013d94: 96 10 00 1b mov %i3, %o3
if (rc > 0)
40013d98: a0 92 20 00 orcc %o0, 0, %l0
40013d9c: 14 80 00 3c bg 40013e8c <rtems_rfs_inode_create+0x33c> <== NEVER TAKEN
40013da0: 03 10 00 00 sethi %hi(0x40000000), %g1
/*
* If the node is a directory update the parent link count as the
* new directory has the '..' link that points to the parent.
*/
if (RTEMS_RFS_S_ISDIR (mode))
40013da4: 80 a4 c0 01 cmp %l3, %g1
40013da8: 12 80 00 15 bne 40013dfc <rtems_rfs_inode_create+0x2ac>
40013dac: 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);
40013db0: c2 07 bf bc ld [ %fp + -68 ], %g1
if (links == 0xffff)
links = 0;
40013db4: 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);
40013db8: c6 08 40 00 ldub [ %g1 ], %g3
40013dbc: c4 08 60 01 ldub [ %g1 + 1 ], %g2
40013dc0: 87 28 e0 08 sll %g3, 8, %g3
40013dc4: 84 10 c0 02 or %g3, %g2, %g2
if (links == 0xffff)
40013dc8: 87 28 a0 10 sll %g2, 0x10, %g3
40013dcc: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
40013dd0: 86 39 00 03 xnor %g4, %g3, %g3
40013dd4: 80 a0 00 03 cmp %g0, %g3
40013dd8: 86 60 20 00 subx %g0, 0, %g3
40013ddc: 84 08 80 03 and %g2, %g3, %g2
rtems_rfs_inode_set_links (&parent_inode,
40013de0: 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);
40013de4: 87 30 a0 08 srl %g2, 8, %g3
40013de8: c6 28 40 00 stb %g3, [ %g1 ]
40013dec: c2 07 bf bc ld [ %fp + -68 ], %g1
40013df0: c4 28 60 01 stb %g2, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40013df4: 82 10 20 01 mov 1, %g1
40013df8: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
40013dfc: 7f ff fe 7b call 400137e8 <rtems_rfs_inode_close>
40013e00: 90 10 00 18 mov %i0, %o0
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
40013e04: 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);
40013e08: a0 10 00 08 mov %o0, %l0
if (rc > 0)
40013e0c: 80 a4 20 00 cmp %l0, 0
40013e10: 04 80 00 29 ble 40013eb4 <rtems_rfs_inode_create+0x364> <== ALWAYS TAKEN
40013e14: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
40013e18: 7f ff fe 9a call 40013880 <rtems_rfs_inode_delete> <== NOT EXECUTED
40013e1c: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40013e20: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40013e24: 7f ff fe 71 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40013e28: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40013e2c: 30 bf ff 88 b,a 40013c4c <rtems_rfs_inode_create+0xfc> <== NOT EXECUTED
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
40013e30: 90 10 00 18 mov %i0, %o0
40013e34: d8 00 40 00 ld [ %g1 ], %o4
40013e38: 92 07 bf d8 add %fp, -40, %o1
40013e3c: 96 10 20 01 mov 1, %o3
40013e40: 15 10 00 d3 sethi %hi(0x40034c00), %o2
40013e44: 40 00 29 b8 call 4001e524 <rtems_rfs_dir_add_entry>
40013e48: 94 12 a2 10 or %o2, 0x210, %o2 ! 40034e10 <flashdisk_ops+0x1c>
if (rc == 0)
40013e4c: a0 92 20 00 orcc %o0, 0, %l0
40013e50: 12 80 00 0b bne 40013e7c <rtems_rfs_inode_create+0x32c> <== NEVER TAKEN
40013e54: 80 a4 20 00 cmp %l0, 0
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
40013e58: 90 10 00 18 mov %i0, %o0
40013e5c: 92 07 bf d8 add %fp, -40, %o1
40013e60: 96 10 20 02 mov 2, %o3
40013e64: 15 10 00 d3 sethi %hi(0x40034c00), %o2
40013e68: 98 10 00 19 mov %i1, %o4
40013e6c: 40 00 29 ae call 4001e524 <rtems_rfs_dir_add_entry>
40013e70: 94 12 a2 18 or %o2, 0x218, %o2
40013e74: a0 10 00 08 mov %o0, %l0
if (rc > 0)
40013e78: 80 a4 20 00 cmp %l0, 0
40013e7c: 04 bf ff ab ble 40013d28 <rtems_rfs_inode_create+0x1d8> <== ALWAYS TAKEN
40013e80: 90 10 00 18 mov %i0, %o0
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
40013e84: 10 bf ff b0 b 40013d44 <rtems_rfs_inode_create+0x1f4> <== NOT EXECUTED
40013e88: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
40013e8c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40013e90: 7f ff fe 7c call 40013880 <rtems_rfs_inode_delete> <== NOT EXECUTED
40013e94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40013e98: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40013e9c: 7f ff fe 53 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40013ea0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
40013ea4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40013ea8: 7f ff fe 50 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40013eac: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40013eb0: 30 bf ff 67 b,a 40013c4c <rtems_rfs_inode_create+0xfc> <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
40013eb4: 7f ff fe 4d call 400137e8 <rtems_rfs_inode_close>
40013eb8: 01 00 00 00 nop
if (rc > 0)
40013ebc: a0 92 20 00 orcc %o0, 0, %l0
40013ec0: 14 bf ff 7b bg 40013cac <rtems_rfs_inode_create+0x15c> <== NEVER TAKEN
40013ec4: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
40013ec8: 10 bf ff 61 b 40013c4c <rtems_rfs_inode_create+0xfc>
40013ecc: a0 10 20 00 clr %l0
40013880 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
40013880: 9d e3 bf 50 save %sp, -176, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
40013884: 90 10 20 00 clr %o0
40013888: 40 00 06 07 call 400150a4 <rtems_rfs_trace>
4001388c: 13 00 20 00 sethi %hi(0x800000), %o1
40013890: 80 8a 20 ff btst 0xff, %o0
40013894: 02 80 00 0b be 400138c0 <rtems_rfs_inode_delete+0x40> <== ALWAYS TAKEN
40013898: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
4001389c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400138a0: 02 80 00 13 be 400138ec <rtems_rfs_inode_delete+0x6c> <== NOT EXECUTED
400138a4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
400138a8: 15 10 00 db sethi %hi(0x40036c00), %o2 <== NOT EXECUTED
400138ac: 94 12 a3 50 or %o2, 0x350, %o2 ! 40036f50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
400138b0: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
400138b4: 40 00 46 32 call 4002517c <printf> <== NOT EXECUTED
400138b8: 90 12 20 48 or %o0, 0x48, %o0 ! 40037048 <_CPU_Trap_slot_template+0xb60><== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
400138bc: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
400138c0: 80 a0 60 00 cmp %g1, 0
400138c4: 02 80 00 08 be 400138e4 <rtems_rfs_inode_delete+0x64> <== NEVER TAKEN
400138c8: 90 10 20 00 clr %o0
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
400138cc: d2 06 60 08 ld [ %i1 + 8 ], %o1
400138d0: 7f ff ff 1c call 40013540 <rtems_rfs_inode_free>
400138d4: 90 10 00 18 mov %i0, %o0
if (rc > 0)
400138d8: 80 a2 20 00 cmp %o0, 0
400138dc: 24 80 00 07 ble,a 400138f8 <rtems_rfs_inode_delete+0x78> <== ALWAYS TAKEN
400138e0: 90 10 00 18 mov %i0, %o0
handle->loads = 0;
handle->node = NULL;
}
}
return rc;
}
400138e4: 81 c7 e0 08 ret
400138e8: 91 e8 00 08 restore %g0, %o0, %o0
rtems_rfs_inode_handle* handle)
{
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
400138ec: 15 10 00 d5 sethi %hi(0x40035400), %o2 <== NOT EXECUTED
400138f0: 10 bf ff f0 b 400138b0 <rtems_rfs_inode_delete+0x30> <== NOT EXECUTED
400138f4: 94 12 a0 60 or %o2, 0x60, %o2 ! 40035460 <Callbacks.6428+0x218><== NOT EXECUTED
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
400138f8: 92 10 00 19 mov %i1, %o1
400138fc: 40 00 23 c5 call 4001c810 <rtems_rfs_block_map_open>
40013900: 94 07 bf b0 add %fp, -80, %o2
if (rc == 0)
40013904: 80 a2 20 00 cmp %o0, 0
40013908: 12 bf ff f7 bne 400138e4 <rtems_rfs_inode_delete+0x64> <== NEVER TAKEN
4001390c: 92 07 bf b0 add %fp, -80, %o1
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
40013910: 40 00 26 d7 call 4001d46c <rtems_rfs_block_map_free_all>
40013914: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_block_map_close (fs, &map);
40013918: 92 07 bf b0 add %fp, -80, %o1
4001391c: 40 00 24 1e call 4001c994 <rtems_rfs_block_map_close>
40013920: 90 10 00 18 mov %i0, %o0
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
40013924: d0 06 60 0c ld [ %i1 + 0xc ], %o0
40013928: 92 10 20 ff mov 0xff, %o1
4001392c: 40 00 45 96 call 40024f84 <memset>
40013930: 94 10 20 38 mov 0x38, %o2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40013934: 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);
40013938: 90 10 00 18 mov %i0, %o0
4001393c: 92 06 60 10 add %i1, 0x10, %o1
40013940: 40 00 27 3e call 4001d638 <rtems_rfs_buffer_handle_release>
40013944: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
handle->loads = 0;
40013948: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->node = NULL;
4001394c: 10 bf ff e6 b 400138e4 <rtems_rfs_inode_delete+0x64>
40013950: c0 26 60 0c clr [ %i1 + 0xc ]
40013554 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
40013554: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
40013558: 90 10 20 00 clr %o0
4001355c: 40 00 06 d2 call 400150a4 <rtems_rfs_trace>
40013560: 13 00 04 00 sethi %hi(0x100000), %o1
40013564: 80 8a 20 ff btst 0xff, %o0
40013568: 02 80 00 0c be 40013598 <rtems_rfs_inode_load+0x44> <== ALWAYS TAKEN
4001356c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
40013570: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
40013574: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40013578: 02 80 00 11 be 400135bc <rtems_rfs_inode_load+0x68> <== NOT EXECUTED
4001357c: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
40013580: 17 10 00 db sethi %hi(0x40036c00), %o3 <== NOT EXECUTED
40013584: 96 12 e3 50 or %o3, 0x350, %o3 ! 40036f50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
40013588: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001358c: 40 00 46 fc call 4002517c <printf> <== NOT EXECUTED
40013590: 90 12 23 58 or %o0, 0x358, %o0 ! 40036f58 <_CPU_Trap_slot_template+0xa70><== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
40013594: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
40013598: 80 a0 60 00 cmp %g1, 0
4001359c: 22 80 00 0b be,a 400135c8 <rtems_rfs_inode_load+0x74>
400135a0: d4 06 60 1c ld [ %i1 + 0x1c ], %o2
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
400135a4: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
return 0;
400135a8: b0 10 20 00 clr %i0
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
400135ac: 82 00 60 01 inc %g1
400135b0: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
return 0;
}
400135b4: 81 c7 e0 08 ret
400135b8: 81 e8 00 00 restore
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
400135bc: 17 10 00 d5 sethi %hi(0x40035400), %o3 <== NOT EXECUTED
400135c0: 10 bf ff f2 b 40013588 <rtems_rfs_inode_load+0x34> <== NOT EXECUTED
400135c4: 96 12 e0 60 or %o3, 0x60, %o3 ! 40035460 <Callbacks.6428+0x218><== NOT EXECUTED
if (!rtems_rfs_inode_is_loaded (handle))
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
400135c8: 90 10 00 18 mov %i0, %o0
400135cc: 92 06 60 10 add %i1, 0x10, %o1
400135d0: 40 00 28 94 call 4001d820 <rtems_rfs_buffer_handle_request>
400135d4: 96 10 20 01 mov 1, %o3
handle->block, true);
if (rc > 0)
400135d8: b0 92 20 00 orcc %o0, 0, %i0
400135dc: 14 bf ff f6 bg 400135b4 <rtems_rfs_inode_load+0x60> <== NEVER TAKEN
400135e0: 01 00 00 00 nop
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
400135e4: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
handle->node += handle->offset;
400135e8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
400135ec: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
400135f0: 87 28 60 03 sll %g1, 3, %g3
400135f4: 83 28 60 06 sll %g1, 6, %g1
400135f8: 82 20 40 03 sub %g1, %g3, %g1
400135fc: 82 00 80 01 add %g2, %g1, %g1
40013600: 10 bf ff e9 b 400135a4 <rtems_rfs_inode_load+0x50>
40013604: c2 26 60 0c st %g1, [ %i1 + 0xc ]
40013608 <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)
{
40013608: 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))
4001360c: 90 10 20 00 clr %o0
40013610: 40 00 06 a5 call 400150a4 <rtems_rfs_trace>
40013614: 13 00 01 00 sethi %hi(0x40000), %o1
40013618: 80 8a 20 ff btst 0xff, %o0
4001361c: 32 80 00 2d bne,a 400136d0 <rtems_rfs_inode_open+0xc8> <== NEVER TAKEN
40013620: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
if (ino == RTEMS_RFS_EMPTY_INO)
40013624: 80 a6 60 00 cmp %i1, 0
40013628: 12 80 00 04 bne 40013638 <rtems_rfs_inode_open+0x30> <== ALWAYS TAKEN
4001362c: 82 10 20 16 mov 0x16, %g1
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
rc = rtems_rfs_inode_load (fs, handle);
return rc;
}
40013630: 81 c7 e0 08 ret <== NOT EXECUTED
40013634: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
if (ino == RTEMS_RFS_EMPTY_INO)
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
40013638: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
4001363c: ba 06 7f ff add %i1, -1, %i5
40013640: 80 a7 40 02 cmp %i5, %g2
40013644: 18 bf ff fb bgu 40013630 <rtems_rfs_inode_open+0x28> <== NEVER TAKEN
40013648: 90 10 00 1d mov %i5, %o0
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
4001364c: e0 06 20 2c ld [ %i0 + 0x2c ], %l0
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
40013650: f2 26 a0 08 st %i1, [ %i2 + 8 ]
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
40013654: 92 10 00 10 mov %l0, %o1
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
40013658: 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;
4001365c: 40 00 78 5e call 400317d4 <.urem>
40013660: c0 26 a0 24 clr [ %i2 + 0x24 ]
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
40013664: 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;
40013668: b2 10 00 08 mov %o0, %i1
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
4001366c: 40 00 78 5a call 400317d4 <.urem>
40013670: 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;
40013674: 92 10 00 10 mov %l0, %o1
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
40013678: 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;
4001367c: 7f ff bc 09 call 400026a0 <.udiv>
40013680: 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);
40013684: c4 06 20 20 ld [ %i0 + 0x20 ], %g2
40013688: 87 2a 20 04 sll %o0, 4, %g3
4001368c: 83 2a 20 06 sll %o0, 6, %g1
40013690: 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;
40013694: fa 00 80 01 ld [ %g2 + %g1 ], %i5
40013698: 90 10 00 19 mov %i1, %o0
4001369c: ba 07 60 02 add %i5, 2, %i5
400136a0: 7f ff bc 00 call 400026a0 <.udiv>
400136a4: 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;
400136a8: c0 2e a0 10 clrb [ %i2 + 0x10 ]
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
400136ac: 90 07 40 08 add %i5, %o0, %o0
handle->bnum = 0;
400136b0: c0 26 a0 14 clr [ %i2 + 0x14 ]
400136b4: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
handle->buffer = NULL;
400136b8: c0 26 a0 18 clr [ %i2 + 0x18 ]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
400136bc: 80 a6 e0 00 cmp %i3, 0
400136c0: 02 bf ff dc be 40013630 <rtems_rfs_inode_open+0x28> <== NEVER TAKEN
400136c4: 82 10 20 00 clr %g1
rc = rtems_rfs_inode_load (fs, handle);
400136c8: 7f ff ff a3 call 40013554 <rtems_rfs_inode_load>
400136cc: 93 e8 00 1a restore %g0, %i2, %o1
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
400136d0: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
400136d4: 40 00 46 aa call 4002517c <printf> <== NOT EXECUTED
400136d8: 90 12 23 90 or %o0, 0x390, %o0 ! 40036f90 <_CPU_Trap_slot_template+0xaa8><== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
400136dc: 10 bf ff d3 b 40013628 <rtems_rfs_inode_open+0x20> <== NOT EXECUTED
400136e0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40013954 <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
40013954: 9d e3 bf a0 save %sp, -96, %sp
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
40013958: c2 06 20 0c ld [ %i0 + 0xc ], %g1
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
4001395c: ba 10 00 18 mov %i0, %i5
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
40013960: 80 a0 60 00 cmp %g1, 0
40013964: 02 80 00 23 be 400139f0 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
40013968: b0 10 20 06 mov 6, %i0
return ENXIO;
now = time (NULL);
4001396c: 40 00 56 48 call 4002928c <time>
40013970: 90 10 20 00 clr %o0
if (atime)
40013974: 80 a6 60 00 cmp %i1, 0
40013978: 02 80 00 0f be 400139b4 <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
4001397c: 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);
40013980: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40013984: 85 32 20 18 srl %o0, 0x18, %g2
40013988: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
4001398c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40013990: 85 32 20 10 srl %o0, 0x10, %g2
40013994: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
40013998: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4001399c: 85 32 20 08 srl %o0, 8, %g2
400139a0: c4 28 60 12 stb %g2, [ %g1 + 0x12 ]
400139a4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400139a8: d0 28 60 13 stb %o0, [ %g1 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400139ac: 82 10 20 01 mov 1, %g1
400139b0: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
400139b4: 02 80 00 0f be 400139f0 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
400139b8: 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);
400139bc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400139c0: 85 32 20 18 srl %o0, 0x18, %g2
400139c4: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
400139c8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400139cc: 85 32 20 10 srl %o0, 0x10, %g2
400139d0: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
400139d4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400139d8: 85 32 20 08 srl %o0, 8, %g2
400139dc: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
400139e0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400139e4: d0 28 60 17 stb %o0, [ %g1 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400139e8: 82 10 20 01 mov 1, %g1
400139ec: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
400139f0: 81 c7 e0 08 ret
400139f4: 81 e8 00 00 restore
400136e4 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
400136e4: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
400136e8: 90 10 20 00 clr %o0
400136ec: 40 00 06 6e call 400150a4 <rtems_rfs_trace>
400136f0: 13 00 08 00 sethi %hi(0x200000), %o1
400136f4: 80 8a 20 ff btst 0xff, %o0
400136f8: 02 80 00 0c be 40013728 <rtems_rfs_inode_unload+0x44> <== ALWAYS TAKEN
400136fc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
40013700: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
40013704: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40013708: 02 80 00 25 be 4001379c <rtems_rfs_inode_unload+0xb8> <== NOT EXECUTED
4001370c: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
40013710: 17 10 00 db sethi %hi(0x40036c00), %o3 <== NOT EXECUTED
40013714: 96 12 e3 50 or %o3, 0x350, %o3 ! 40036f50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
40013718: 11 10 00 db sethi %hi(0x40036c00), %o0 <== NOT EXECUTED
4001371c: 40 00 46 98 call 4002517c <printf> <== NOT EXECUTED
40013720: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 40036fb8 <_CPU_Trap_slot_template+0xad0><== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
40013724: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
40013728: 80 a0 60 00 cmp %g1, 0
4001372c: 22 80 00 0d be,a 40013760 <rtems_rfs_inode_unload+0x7c>
40013730: 90 10 20 00 clr %o0
{
if (handle->loads == 0)
40013734: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
40013738: 80 a0 a0 00 cmp %g2, 0
4001373c: 12 80 00 04 bne 4001374c <rtems_rfs_inode_unload+0x68> <== ALWAYS TAKEN
40013740: 90 10 20 05 mov 5, %o0
handle->node = NULL;
}
}
return rc;
}
40013744: 81 c7 e0 08 ret <== NOT EXECUTED
40013748: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
return EIO;
handle->loads--;
4001374c: 84 00 bf ff add %g2, -1, %g2
if (handle->loads == 0)
40013750: 80 a0 a0 00 cmp %g2, 0
40013754: 02 80 00 05 be 40013768 <rtems_rfs_inode_unload+0x84>
40013758: c4 26 60 24 st %g2, [ %i1 + 0x24 ]
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
int rc = 0;
4001375c: 90 10 20 00 clr %o0
handle->node = NULL;
}
}
return rc;
}
40013760: 81 c7 e0 08 ret
40013764: 91 e8 00 08 restore %g0, %o0, %o0
if (handle->loads == 0)
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
40013768: c2 0e 60 10 ldub [ %i1 + 0x10 ], %g1
4001376c: 80 a0 60 00 cmp %g1, 0
40013770: 02 80 00 06 be 40013788 <rtems_rfs_inode_unload+0xa4>
40013774: 90 10 00 18 mov %i0, %o0
40013778: 80 a6 a0 00 cmp %i2, 0
4001377c: 12 80 00 0b bne 400137a8 <rtems_rfs_inode_unload+0xc4> <== ALWAYS TAKEN
40013780: 01 00 00 00 nop
rtems_rfs_inode_set_ctime (handle, time (NULL));
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
40013784: 90 10 00 18 mov %i0, %o0
40013788: 40 00 27 ac call 4001d638 <rtems_rfs_buffer_handle_release>
4001378c: 92 06 60 10 add %i1, 0x10, %o1
handle->node = NULL;
40013790: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
40013794: 81 c7 e0 08 ret
40013798: 91 e8 00 08 restore %g0, %o0, %o0
bool update_ctime)
{
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
4001379c: 17 10 00 d5 sethi %hi(0x40035400), %o3 <== NOT EXECUTED
400137a0: 10 bf ff de b 40013718 <rtems_rfs_inode_unload+0x34> <== NOT EXECUTED
400137a4: 96 12 e0 60 or %o3, 0x60, %o3 ! 40035460 <Callbacks.6428+0x218><== NOT EXECUTED
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
rtems_rfs_inode_set_ctime (handle, time (NULL));
400137a8: 40 00 56 b9 call 4002928c <time>
400137ac: 90 10 20 00 clr %o0
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
400137b0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400137b4: 85 32 20 18 srl %o0, 0x18, %g2
400137b8: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
400137bc: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400137c0: 85 32 20 10 srl %o0, 0x10, %g2
400137c4: c4 28 60 19 stb %g2, [ %g1 + 0x19 ]
400137c8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400137cc: 85 32 20 08 srl %o0, 8, %g2
400137d0: c4 28 60 1a stb %g2, [ %g1 + 0x1a ]
400137d4: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400137d8: d0 28 60 1b stb %o0, [ %g1 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400137dc: 82 10 20 01 mov 1, %g1
400137e0: 10 bf ff e9 b 40013784 <rtems_rfs_inode_unload+0xa0>
400137e4: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
40020d98 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
40020d98: 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))
40020d9c: 90 10 20 00 clr %o0
40020da0: 13 00 40 00 sethi %hi(0x1000000), %o1
40020da4: 7f ff d0 c0 call 400150a4 <rtems_rfs_trace>
40020da8: a2 10 00 18 mov %i0, %l1
40020dac: 80 8a 20 ff btst 0xff, %o0
40020db0: 12 80 00 52 bne 40020ef8 <rtems_rfs_link+0x160> <== NEVER TAKEN
40020db4: 92 10 00 1b mov %i3, %o1
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
40020db8: 90 10 00 11 mov %l1, %o0
40020dbc: 92 10 00 1c mov %i4, %o1
40020dc0: 94 07 bf d8 add %fp, -40, %o2
40020dc4: 7f ff ca 11 call 40013608 <rtems_rfs_inode_open>
40020dc8: 96 10 20 01 mov 1, %o3
if (rc)
40020dcc: b0 92 20 00 orcc %o0, 0, %i0
40020dd0: 12 80 00 3d bne 40020ec4 <rtems_rfs_link+0x12c> <== NEVER TAKEN
40020dd4: 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)))
40020dd8: 12 80 00 0b bne 40020e04 <rtems_rfs_link+0x6c> <== NEVER TAKEN
40020ddc: 90 10 00 11 mov %l1, %o0
40020de0: c2 07 bf e4 ld [ %fp + -28 ], %g1
40020de4: c4 08 60 02 ldub [ %g1 + 2 ], %g2
40020de8: 03 00 00 3c sethi %hi(0xf000), %g1
40020dec: 85 28 a0 08 sll %g2, 8, %g2
40020df0: 84 08 80 01 and %g2, %g1, %g2
40020df4: 03 00 00 10 sethi %hi(0x4000), %g1
40020df8: 80 a0 80 01 cmp %g2, %g1
40020dfc: 02 80 00 55 be 40020f50 <rtems_rfs_link+0x1b8> <== NEVER TAKEN
40020e00: b0 10 20 86 mov 0x86, %i0
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
40020e04: 92 10 00 1b mov %i3, %o1
40020e08: 94 07 bf b0 add %fp, -80, %o2
40020e0c: 7f ff c9 ff call 40013608 <rtems_rfs_inode_open>
40020e10: 96 10 20 01 mov 1, %o3
40020e14: b0 10 00 08 mov %o0, %i0
if (rc)
40020e18: 80 a6 20 00 cmp %i0, 0
40020e1c: 12 80 00 27 bne 40020eb8 <rtems_rfs_link+0x120> <== NEVER TAKEN
40020e20: 90 10 00 11 mov %l1, %o0
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
40020e24: 92 07 bf b0 add %fp, -80, %o1
40020e28: 94 10 00 19 mov %i1, %o2
40020e2c: 96 10 00 1a mov %i2, %o3
40020e30: 7f ff f5 bd call 4001e524 <rtems_rfs_dir_add_entry>
40020e34: 98 10 00 1c mov %i4, %o4
if (rc > 0)
40020e38: b0 92 20 00 orcc %o0, 0, %i0
40020e3c: 14 80 00 42 bg 40020f44 <rtems_rfs_link+0x1ac> <== NEVER TAKEN
40020e40: c2 07 bf e4 ld [ %fp + -28 ], %g1
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
40020e44: c6 08 60 01 ldub [ %g1 + 1 ], %g3
40020e48: c4 08 40 00 ldub [ %g1 ], %g2
40020e4c: 85 28 a0 08 sll %g2, 8, %g2
40020e50: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
40020e54: 07 3f ff c0 sethi %hi(0xffff0000), %g3
40020e58: 89 28 a0 10 sll %g2, 0x10, %g4
40020e5c: 80 a1 00 03 cmp %g4, %g3
40020e60: 22 80 00 40 be,a 40020f60 <rtems_rfs_link+0x1c8> <== NEVER TAKEN
40020e64: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
40020e68: 84 00 a0 01 inc %g2
40020e6c: 87 28 a0 10 sll %g2, 0x10, %g3
40020e70: 87 30 e0 18 srl %g3, 0x18, %g3
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
40020e74: c6 28 40 00 stb %g3, [ %g1 ]
40020e78: c2 07 bf e4 ld [ %fp + -28 ], %g1
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
40020e7c: 92 10 20 01 mov 1, %o1
40020e80: c4 28 60 01 stb %g2, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40020e84: 82 10 20 01 mov 1, %g1
40020e88: 90 07 bf b0 add %fp, -80, %o0
40020e8c: c2 2f bf e8 stb %g1, [ %fp + -24 ]
40020e90: 7f ff ca b1 call 40013954 <rtems_rfs_inode_time_stamp_now>
40020e94: 94 10 20 01 mov 1, %o2
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
40020e98: 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);
40020e9c: b0 10 00 08 mov %o0, %i0
if (rc > 0)
40020ea0: 80 a6 20 00 cmp %i0, 0
40020ea4: 04 80 00 0a ble 40020ecc <rtems_rfs_link+0x134> <== ALWAYS TAKEN
40020ea8: 90 10 00 11 mov %l1, %o0
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
40020eac: 7f ff ca 4f call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40020eb0: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40020eb4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
40020eb8: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40020ebc: 7f ff ca 4b call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40020ec0: 01 00 00 00 nop <== NOT EXECUTED
40020ec4: 81 c7 e0 08 ret <== NOT EXECUTED
40020ec8: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
40020ecc: 7f ff ca 47 call 400137e8 <rtems_rfs_inode_close>
40020ed0: 01 00 00 00 nop
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
40020ed4: 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);
40020ed8: b0 10 00 08 mov %o0, %i0
if (rc > 0)
40020edc: 80 a6 20 00 cmp %i0, 0
40020ee0: 14 bf ff f7 bg 40020ebc <rtems_rfs_link+0x124> <== NEVER TAKEN
40020ee4: 90 10 00 11 mov %l1, %o0
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
40020ee8: 7f ff ca 40 call 400137e8 <rtems_rfs_inode_close>
40020eec: 01 00 00 00 nop
return rc;
}
40020ef0: 81 c7 e0 08 ret
40020ef4: 91 e8 00 08 restore %g0, %o0, %o0
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
40020ef8: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
40020efc: 40 00 10 a0 call 4002517c <printf> <== NOT EXECUTED
40020f00: 90 12 21 f8 or %o0, 0x1f8, %o0 ! 400391f8 <CSWTCH.2+0x1408><== NOT EXECUTED
40020f04: a0 10 00 19 mov %i1, %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
40020f08: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40020f0c: 04 80 00 08 ble 40020f2c <rtems_rfs_link+0x194> <== NOT EXECUTED
40020f10: b0 06 40 1a add %i1, %i2, %i0 <== NOT EXECUTED
printf ("%c", name[c]);
40020f14: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
40020f18: 40 00 11 03 call 40025324 <putchar> <== NOT EXECUTED
40020f1c: 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++)
40020f20: 80 a4 00 18 cmp %l0, %i0 <== NOT EXECUTED
40020f24: 32 bf ff fd bne,a 40020f18 <rtems_rfs_link+0x180> <== NOT EXECUTED
40020f28: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
40020f2c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40020f30: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
40020f34: 40 00 10 92 call 4002517c <printf> <== NOT EXECUTED
40020f38: 90 12 22 20 or %o0, 0x220, %o0 ! 40039220 <CSWTCH.2+0x1430><== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
40020f3c: 10 bf ff a0 b 40020dbc <rtems_rfs_link+0x24> <== NOT EXECUTED
40020f40: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
40020f44: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
40020f48: 10 bf ff d9 b 40020eac <rtems_rfs_link+0x114> <== NOT EXECUTED
40020f4c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
{
rtems_rfs_inode_close (fs, &target_inode);
40020f50: 7f ff ca 26 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40020f54: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40020f58: 81 c7 e0 08 ret <== NOT EXECUTED
40020f5c: 81 e8 00 00 restore <== NOT EXECUTED
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
40020f60: 10 bf ff c5 b 40020e74 <rtems_rfs_link+0xdc> <== NOT EXECUTED
40020f64: 86 10 20 00 clr %g3 <== NOT EXECUTED
400217cc <rtems_rfs_mutex_create>:
RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
400217cc: 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'),
400217d0: 92 10 20 01 mov 1, %o1
400217d4: 98 10 00 18 mov %i0, %o4
400217d8: 11 14 91 94 sethi %hi(0x52465000), %o0
400217dc: 94 10 20 54 mov 0x54, %o2
400217e0: 90 12 23 6d or %o0, 0x36d, %o0
400217e4: 96 10 20 00 clr %o3
400217e8: 7f ff b1 18 call 4000dc48 <rtems_semaphore_create>
400217ec: b0 10 20 00 clr %i0
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
400217f0: 80 a2 20 00 cmp %o0, 0
400217f4: 02 80 00 0f be 40021830 <rtems_rfs_mutex_create+0x64> <== ALWAYS TAKEN
400217f8: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
400217fc: 90 10 20 00 clr %o0 <== NOT EXECUTED
40021800: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021804: 7f ff ce 28 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40021808: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
4002180c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021810: 02 80 00 08 be 40021830 <rtems_rfs_mutex_create+0x64> <== NOT EXECUTED
40021814: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
40021818: 7f ff dc 7e call 40018a10 <rtems_status_text> <== NOT EXECUTED
4002181c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021820: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021824: 11 10 00 e5 sethi %hi(0x40039400), %o0 <== NOT EXECUTED
40021828: 40 00 0e 55 call 4002517c <printf> <== NOT EXECUTED
4002182c: 90 12 20 50 or %o0, 0x50, %o0 ! 40039450 <CSWTCH.2+0x1660><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
40021830: 81 c7 e0 08 ret
40021834: 81 e8 00 00 restore
40021838 <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
40021838: 9d e3 bf a0 save %sp, -96, %sp
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
4002183c: d0 06 00 00 ld [ %i0 ], %o0
40021840: 7f ff b1 73 call 4000de0c <rtems_semaphore_delete>
40021844: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
40021848: ba 92 20 00 orcc %o0, 0, %i5
4002184c: 02 80 00 0e be 40021884 <rtems_rfs_mutex_destroy+0x4c> <== ALWAYS TAKEN
40021850: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021854: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021858: 7f ff ce 13 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4002185c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
40021860: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021864: 02 80 00 08 be 40021884 <rtems_rfs_mutex_destroy+0x4c> <== NOT EXECUTED
40021868: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
4002186c: 7f ff dc 69 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40021870: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021874: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021878: 11 10 00 e5 sethi %hi(0x40039400), %o0 <== NOT EXECUTED
4002187c: 40 00 0e 40 call 4002517c <printf> <== NOT EXECUTED
40021880: 90 12 20 78 or %o0, 0x78, %o0 ! 40039478 <CSWTCH.2+0x1688><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
40021884: 81 c7 e0 08 ret
40021888: 81 e8 00 00 restore
4001d47c <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
4001d47c: 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))
4001d480: 90 10 20 00 clr %o0
4001d484: 92 10 20 80 mov 0x80, %o1
4001d488: 7f ff df 07 call 400150a4 <rtems_rfs_trace>
4001d48c: ba 10 00 18 mov %i0, %i5
4001d490: 80 8a 20 ff btst 0xff, %o0
4001d494: 32 80 00 1c bne,a 4001d504 <rtems_rfs_release_chain+0x88><== NEVER TAKEN
4001d498: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
4001d49c: b0 10 20 00 clr %i0
4001d4a0: b8 07 60 04 add %i5, 4, %i4
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
4001d4a4: c2 07 40 00 ld [ %i5 ], %g1
4001d4a8: 80 a0 40 1c cmp %g1, %i4
4001d4ac: 02 80 00 14 be 4001d4fc <rtems_rfs_release_chain+0x80>
4001d4b0: 90 10 00 1d mov %i5, %o0
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4001d4b4: 7f ff c5 69 call 4000ea58 <_Chain_Get>
4001d4b8: 01 00 00 00 nop
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
4001d4bc: c2 06 40 00 ld [ %i1 ], %g1
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
4001d4c0: 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)--;
4001d4c4: 82 00 7f ff add %g1, -1, %g1
4001d4c8: c2 26 40 00 st %g1, [ %i1 ]
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
4001d4cc: 40 00 18 7b call 400236b8 <rtems_rfs_buffer_bdbuf_release>
4001d4d0: c0 22 20 34 clr [ %o0 + 0x34 ]
if ((rc > 0) && (rrc == 0))
4001d4d4: 80 a2 20 00 cmp %o0, 0
4001d4d8: 04 bf ff f4 ble 4001d4a8 <rtems_rfs_release_chain+0x2c> <== ALWAYS TAKEN
4001d4dc: c2 07 40 00 ld [ %i5 ], %g1
4001d4e0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4001d4e4: 12 bf ff f1 bne 4001d4a8 <rtems_rfs_release_chain+0x2c> <== NOT EXECUTED
4001d4e8: 01 00 00 00 nop <== NOT EXECUTED
4001d4ec: 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))
4001d4f0: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED
4001d4f4: 12 bf ff f0 bne 4001d4b4 <rtems_rfs_release_chain+0x38> <== NOT EXECUTED
4001d4f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
4001d4fc: 81 c7 e0 08 ret
4001d500: 81 e8 00 00 restore
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
4001d504: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001d508: 40 00 1f 1d call 4002517c <printf> <== NOT EXECUTED
4001d50c: 90 12 23 00 or %o0, 0x300, %o0 ! 40037f00 <CSWTCH.2+0x110><== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
4001d510: 10 bf ff e4 b 4001d4a0 <rtems_rfs_release_chain+0x24> <== NOT EXECUTED
4001d514: b0 10 20 00 clr %i0 <== NOT EXECUTED
400142d0 <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
400142d0: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
400142d4: 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);
400142d8: 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);
400142dc: f8 00 60 08 ld [ %g1 + 8 ], %i4
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
400142e0: 94 07 bf d8 add %fp, -40, %o2
400142e4: 90 10 00 1c mov %i4, %o0
400142e8: 7f ff fc c8 call 40013608 <rtems_rfs_inode_open>
400142ec: 96 10 20 01 mov 1, %o3
if (rc > 0)
400142f0: ba 92 20 00 orcc %o0, 0, %i5
400142f4: 04 80 00 07 ble 40014310 <rtems_rfs_rtems_chown+0x40> <== ALWAYS TAKEN
400142f8: 01 00 00 00 nop
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc)
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
400142fc: 40 00 3e 0f call 40023b38 <__errno> <== NOT EXECUTED
40014300: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40014304: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40014308: 81 c7 e0 08 ret <== NOT EXECUTED
4001430c: 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();
40014310: 40 00 12 95 call 40018d64 <geteuid>
40014314: 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;
40014318: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
4001431c: 91 2a 20 10 sll %o0, 0x10, %o0
40014320: c4 08 60 06 ldub [ %g1 + 6 ], %g2
40014324: c6 08 60 07 ldub [ %g1 + 7 ], %g3
40014328: 85 28 a0 08 sll %g2, 8, %g2
4001432c: 84 10 80 03 or %g2, %g3, %g2
40014330: 85 28 a0 10 sll %g2, 0x10, %g2
40014334: 80 a0 80 08 cmp %g2, %o0
40014338: 02 80 00 05 be 4001434c <rtems_rfs_rtems_chown+0x7c> <== ALWAYS TAKEN
4001433c: 89 32 20 10 srl %o0, 0x10, %g4
40014340: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
40014344: 12 80 00 19 bne 400143a8 <rtems_rfs_rtems_chown+0xd8> <== NOT EXECUTED
40014348: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,
uint16_t uid, uint16_t gid)
{
rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
4001434c: b5 2e a0 10 sll %i2, 0x10, %i2
40014350: b4 16 80 19 or %i2, %i1, %i2
40014354: 85 36 a0 18 srl %i2, 0x18, %g2
40014358: c4 28 60 04 stb %g2, [ %g1 + 4 ]
4001435c: c2 07 bf e4 ld [ %fp + -28 ], %g1
40014360: 85 36 a0 10 srl %i2, 0x10, %g2
40014364: c4 28 60 05 stb %g2, [ %g1 + 5 ]
40014368: c2 07 bf e4 ld [ %fp + -28 ], %g1
4001436c: b5 36 a0 08 srl %i2, 8, %i2
40014370: f4 28 60 06 stb %i2, [ %g1 + 6 ]
40014374: 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);
40014378: 90 10 00 1c mov %i4, %o0
4001437c: f2 28 60 07 stb %i1, [ %g1 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40014380: 82 10 20 01 mov 1, %g1
40014384: 92 07 bf d8 add %fp, -40, %o1
40014388: c2 2f bf e8 stb %g1, [ %fp + -24 ]
4001438c: 7f ff fd 17 call 400137e8 <rtems_rfs_inode_close>
40014390: b0 10 20 00 clr %i0
if (rc)
40014394: 80 a2 20 00 cmp %o0, 0
40014398: 12 bf ff d9 bne 400142fc <rtems_rfs_rtems_chown+0x2c> <== NEVER TAKEN
4001439c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
}
return 0;
}
400143a0: 81 c7 e0 08 ret
400143a4: 81 e8 00 00 restore
#if defined (RTEMS_POSIX_API)
uid = geteuid();
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
{
rtems_rfs_inode_close (fs, &inode);
400143a8: 7f ff fd 10 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
400143ac: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: not able", EPERM);
400143b0: 40 00 3d e2 call 40023b38 <__errno> <== NOT EXECUTED
400143b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400143b8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
400143bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400143c0: 81 c7 e0 08 ret <== NOT EXECUTED
400143c4: 81 e8 00 00 restore <== NOT EXECUTED
400218d0 <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);
400218d0: d2 02 20 2c ld [ %o0 + 0x2c ], %o1 <== NOT EXECUTED
400218d4: d4 02 20 30 ld [ %o0 + 0x30 ], %o2 <== NOT EXECUTED
400218d8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400218dc: 40 00 05 24 call 40022d6c <rtems_deviceio_close> <== NOT EXECUTED
400218e0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4002188c <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, off_t length)
{
return 0;
}
4002188c: 81 c3 e0 08 retl <== NOT EXECUTED
40021890: 90 10 20 00 clr %o0 <== NOT EXECUTED
40021894 <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);
40021894: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
40021898: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
4002189c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400218a0: 40 00 05 75 call 40022e74 <rtems_deviceio_control> <== NOT EXECUTED
400218a4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400218e4 <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
400218e4: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
400218e8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
400218ec: 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);
400218f0: 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);
400218f4: 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
};
400218f8: c2 07 60 80 ld [ %i5 + 0x80 ], %g1 <== NOT EXECUTED
400218fc: 94 10 20 00 clr %o2 <== NOT EXECUTED
40021900: 7f ff b1 7a call 4000dee8 <rtems_semaphore_obtain> <== NOT EXECUTED
40021904: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40021908: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4002190c: 12 80 00 17 bne 40021968 <rtems_rfs_rtems_device_open+0x84><== NOT EXECUTED
40021910: 90 10 20 00 clr %o0 <== NOT EXECUTED
rtems_device_minor_number minor;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40021914: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021918: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4002191c: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
40021920: 7f ff c7 3a call 40013608 <rtems_rfs_inode_open> <== NOT EXECUTED
40021924: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
40021928: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
4002192c: 04 80 00 23 ble 400219b8 <rtems_rfs_rtems_device_open+0xd4><== NOT EXECUTED
40021930: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40021934: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
40021938: 7f ff f1 04 call 4001dd48 <rtems_rfs_buffers_release> <== NOT EXECUTED
4002193c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40021940: 7f ff b1 b9 call 4000e024 <rtems_semaphore_release> <== NOT EXECUTED
40021944: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40021948: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4002194c: 12 80 00 4c bne 40021a7c <rtems_rfs_rtems_device_open+0x198><== NOT EXECUTED
40021950: 90 10 20 00 clr %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
40021954: 40 00 08 79 call 40023b38 <__errno> <== NOT EXECUTED
40021958: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4002195c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40021960: 81 c7 e0 08 ret <== NOT EXECUTED
40021964: 81 e8 00 00 restore <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021968: 7f ff cd cf call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4002196c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021970: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021974: 22 bf ff e9 be,a 40021918 <rtems_rfs_rtems_device_open+0x34><== NOT EXECUTED
40021978: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
4002197c: 7f ff dc 25 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40021980: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40021984: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021988: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4002198c: 40 00 0d fc call 4002517c <printf> <== NOT EXECUTED
40021990: 90 12 21 58 or %o0, 0x158, %o0 ! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
rtems_device_minor_number minor;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40021994: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021998: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4002199c: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
400219a0: 7f ff c7 1a call 40013608 <rtems_rfs_inode_open> <== NOT EXECUTED
400219a4: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
400219a8: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
400219ac: 34 bf ff e3 bg,a 40021938 <rtems_rfs_rtems_device_open+0x54><== NOT EXECUTED
400219b0: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
400219b4: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
minor = rtems_rfs_inode_get_block (&inode, 1);
rc = rtems_rfs_inode_close (fs, &inode);
400219b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400219bc: ec 08 60 1c ldub [ %g1 + 0x1c ], %l6 <== NOT EXECUTED
400219c0: ea 08 60 1d ldub [ %g1 + 0x1d ], %l5 <== NOT EXECUTED
400219c4: e6 08 60 1e ldub [ %g1 + 0x1e ], %l3 <== NOT EXECUTED
400219c8: e8 08 60 1f ldub [ %g1 + 0x1f ], %l4 <== NOT EXECUTED
400219cc: e4 08 60 20 ldub [ %g1 + 0x20 ], %l2 <== NOT EXECUTED
400219d0: e2 08 60 21 ldub [ %g1 + 0x21 ], %l1 <== NOT EXECUTED
400219d4: e0 08 60 22 ldub [ %g1 + 0x22 ], %l0 <== NOT EXECUTED
400219d8: ee 08 60 23 ldub [ %g1 + 0x23 ], %l7 <== NOT EXECUTED
400219dc: 7f ff c7 83 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
400219e0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
if (rc > 0)
400219e4: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
400219e8: 34 bf ff d4 bg,a 40021938 <rtems_rfs_rtems_device_open+0x54><== NOT EXECUTED
400219ec: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
400219f0: f8 07 60 80 ld [ %i5 + 0x80 ], %i4 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
400219f4: 7f ff f0 d5 call 4001dd48 <rtems_rfs_buffers_release> <== NOT EXECUTED
400219f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
400219fc: 7f ff b1 8a call 4000e024 <rtems_semaphore_release> <== NOT EXECUTED
40021a00: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40021a04: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40021a08: 12 80 00 2d bne 40021abc <rtems_rfs_rtems_device_open+0x1d8><== NOT EXECUTED
40021a0c: 90 10 20 00 clr %o0 <== NOT EXECUTED
40021a10: ad 2d a0 18 sll %l6, 0x18, %l6 <== NOT EXECUTED
40021a14: a8 0d 20 ff and %l4, 0xff, %l4 <== NOT EXECUTED
40021a18: a5 2c a0 18 sll %l2, 0x18, %l2 <== NOT EXECUTED
40021a1c: ae 0d e0 ff and %l7, 0xff, %l7 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
iop->data1 = (void *) minor;
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
40021a20: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021a24: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40021a28: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40021a2c: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
40021a30: aa 0d 60 ff and %l5, 0xff, %l5 <== NOT EXECUTED
40021a34: a6 0c e0 ff and %l3, 0xff, %l3 <== NOT EXECUTED
40021a38: ab 2d 60 10 sll %l5, 0x10, %l5 <== NOT EXECUTED
40021a3c: a7 2c e0 08 sll %l3, 8, %l3 <== NOT EXECUTED
40021a40: 9a 15 80 15 or %l6, %l5, %o5 <== NOT EXECUTED
40021a44: a2 0c 60 ff and %l1, 0xff, %l1 <== NOT EXECUTED
40021a48: 9a 13 40 14 or %o5, %l4, %o5 <== NOT EXECUTED
40021a4c: a3 2c 60 10 sll %l1, 0x10, %l1 <== NOT EXECUTED
40021a50: 9a 13 40 13 or %o5, %l3, %o5 <== NOT EXECUTED
40021a54: 98 14 80 11 or %l2, %l1, %o4 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
40021a58: da 26 20 2c st %o5, [ %i0 + 0x2c ] <== NOT EXECUTED
40021a5c: 98 13 00 17 or %o4, %l7, %o4 <== NOT EXECUTED
40021a60: a0 0c 20 ff and %l0, 0xff, %l0 <== NOT EXECUTED
40021a64: a1 2c 20 08 sll %l0, 8, %l0 <== NOT EXECUTED
40021a68: 98 13 00 10 or %o4, %l0, %o4 <== NOT EXECUTED
iop->data1 = (void *) minor;
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
40021a6c: 40 00 04 b3 call 40022d38 <rtems_deviceio_open> <== NOT EXECUTED
40021a70: d8 26 20 30 st %o4, [ %i0 + 0x30 ] <== NOT EXECUTED
}
40021a74: 81 c7 e0 08 ret <== NOT EXECUTED
40021a78: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021a7c: 7f ff cd 8a call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40021a80: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021a84: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021a88: 02 bf ff b3 be 40021954 <rtems_rfs_rtems_device_open+0x70><== NOT EXECUTED
40021a8c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40021a90: 7f ff db e0 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40021a94: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021a98: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021a9c: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40021aa0: 40 00 0d b7 call 4002517c <printf> <== NOT EXECUTED
40021aa4: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
40021aa8: 40 00 08 24 call 40023b38 <__errno> <== NOT EXECUTED
40021aac: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40021ab0: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40021ab4: 81 c7 e0 08 ret <== NOT EXECUTED
40021ab8: 81 e8 00 00 restore <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021abc: 7f ff cd 7a call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40021ac0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021ac4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021ac8: 22 bf ff d3 be,a 40021a14 <rtems_rfs_rtems_device_open+0x130><== NOT EXECUTED
40021acc: ad 2d a0 18 sll %l6, 0x18, %l6 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40021ad0: 7f ff db d0 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40021ad4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021ad8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021adc: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40021ae0: 40 00 0d a7 call 4002517c <printf> <== NOT EXECUTED
40021ae4: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021ae8: 10 bf ff cb b 40021a14 <rtems_rfs_rtems_device_open+0x130><== NOT EXECUTED
40021aec: ad 2d a0 18 sll %l6, 0x18, %l6 <== NOT EXECUTED
400218bc <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);
400218bc: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
400218c0: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
400218c4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400218c8: 40 00 05 35 call 40022d9c <rtems_deviceio_read> <== NOT EXECUTED
400218cc: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400218a8 <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);
400218a8: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
400218ac: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
400218b0: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400218b4: 40 00 05 55 call 40022e08 <rtems_deviceio_write> <== NOT EXECUTED
400218b8: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40021af8 <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
40021af8: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
40021afc: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
40021b00: f6 06 20 1c ld [ %i0 + 0x1c ], %i3
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
40021b04: fa 00 60 08 ld [ %g1 + 8 ], %i5
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40021b08: 92 10 20 00 clr %o1
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_filesystem_default_ftruncate_directory,
.fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
40021b0c: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
40021b10: 94 10 20 00 clr %o2
40021b14: 7f ff b0 f5 call 4000dee8 <rtems_semaphore_obtain>
40021b18: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40021b1c: b8 92 20 00 orcc %o0, 0, %i4
40021b20: 12 80 00 2d bne 40021bd4 <rtems_rfs_rtems_dir_open+0xdc> <== NEVER TAKEN
40021b24: 90 10 20 00 clr %o0
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40021b28: 90 10 00 1d mov %i5, %o0
40021b2c: 92 10 00 1b mov %i3, %o1
40021b30: 94 07 bf d8 add %fp, -40, %o2
40021b34: 7f ff c6 b5 call 40013608 <rtems_rfs_inode_open>
40021b38: 96 10 20 01 mov 1, %o3
if (rc)
40021b3c: b8 92 20 00 orcc %o0, 0, %i4
40021b40: 32 80 00 39 bne,a 40021c24 <rtems_rfs_rtems_dir_open+0x12c><== NEVER TAKEN
40021b44: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
40021b48: c2 07 bf e4 ld [ %fp + -28 ], %g1
40021b4c: c4 08 60 02 ldub [ %g1 + 2 ], %g2
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
40021b50: 03 00 00 3c sethi %hi(0xf000), %g1
40021b54: 85 28 a0 08 sll %g2, 8, %g2
40021b58: 84 08 80 01 and %g2, %g1, %g2
40021b5c: 03 00 00 10 sethi %hi(0x4000), %g1
40021b60: 80 a0 80 01 cmp %g2, %g1
40021b64: 12 80 00 48 bne 40021c84 <rtems_rfs_rtems_dir_open+0x18c> <== NEVER TAKEN
40021b68: 92 07 bf d8 add %fp, -40, %o1
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
}
iop->offset = 0;
rtems_rfs_inode_close (fs, &inode);
40021b6c: 90 10 00 1d mov %i5, %o0
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
}
iop->offset = 0;
40021b70: c0 26 20 08 clr [ %i0 + 8 ]
rtems_rfs_inode_close (fs, &inode);
40021b74: 7f ff c7 1d call 400137e8 <rtems_rfs_inode_close>
40021b78: c0 26 20 0c clr [ %i0 + 0xc ]
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40021b7c: f8 07 60 80 ld [ %i5 + 0x80 ], %i4
rtems_rfs_buffers_release (fs);
40021b80: 7f ff f0 72 call 4001dd48 <rtems_rfs_buffers_release>
40021b84: 90 10 00 1d mov %i5, %o0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40021b88: 7f ff b1 27 call 4000e024 <rtems_semaphore_release>
40021b8c: d0 07 00 00 ld [ %i4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40021b90: ba 92 20 00 orcc %o0, 0, %i5
40021b94: 12 80 00 04 bne 40021ba4 <rtems_rfs_rtems_dir_open+0xac> <== NEVER TAKEN
40021b98: 90 10 20 00 clr %o0
rtems_rfs_rtems_unlock (fs);
return 0;
}
40021b9c: 81 c7 e0 08 ret
40021ba0: 91 e8 20 00 restore %g0, 0, %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021ba4: 7f ff cd 40 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40021ba8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021bac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021bb0: 02 bf ff fb be 40021b9c <rtems_rfs_rtems_dir_open+0xa4> <== NOT EXECUTED
40021bb4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40021bb8: 7f ff db 96 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40021bbc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021bc0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021bc4: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40021bc8: 40 00 0d 6d call 4002517c <printf> <== NOT EXECUTED
40021bcc: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021bd0: 30 bf ff f3 b,a 40021b9c <rtems_rfs_rtems_dir_open+0xa4> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021bd4: 7f ff cd 34 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40021bd8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021bdc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021be0: 22 bf ff d3 be,a 40021b2c <rtems_rfs_rtems_dir_open+0x34><== NOT EXECUTED
40021be4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40021be8: 7f ff db 8a call 40018a10 <rtems_status_text> <== NOT EXECUTED
40021bec: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40021bf0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021bf4: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40021bf8: 40 00 0d 61 call 4002517c <printf> <== NOT EXECUTED
40021bfc: 90 12 21 58 or %o0, 0x158, %o0 ! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40021c00: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021c04: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40021c08: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
40021c0c: 7f ff c6 7f call 40013608 <rtems_rfs_inode_open> <== NOT EXECUTED
40021c10: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
40021c14: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40021c18: 02 bf ff cd be 40021b4c <rtems_rfs_rtems_dir_open+0x54> <== NOT EXECUTED
40021c1c: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40021c20: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
40021c24: 7f ff f0 49 call 4001dd48 <rtems_rfs_buffers_release> <== NOT EXECUTED
40021c28: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40021c2c: 7f ff b0 fe call 4000e024 <rtems_semaphore_release> <== NOT EXECUTED
40021c30: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40021c34: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40021c38: 12 80 00 07 bne 40021c54 <rtems_rfs_rtems_dir_open+0x15c> <== NOT EXECUTED
40021c3c: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
40021c40: 40 00 07 be call 40023b38 <__errno> <== NOT EXECUTED
40021c44: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40021c48: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40021c4c: 81 c7 e0 08 ret <== NOT EXECUTED
40021c50: 81 e8 00 00 restore <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021c54: 7f ff cd 14 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40021c58: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021c5c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021c60: 02 bf ff f8 be 40021c40 <rtems_rfs_rtems_dir_open+0x148> <== NOT EXECUTED
40021c64: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40021c68: 7f ff db 6a call 40018a10 <rtems_status_text> <== NOT EXECUTED
40021c6c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021c70: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021c74: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40021c78: 40 00 0d 41 call 4002517c <printf> <== NOT EXECUTED
40021c7c: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021c80: 30 bf ff f0 b,a 40021c40 <rtems_rfs_rtems_dir_open+0x148><== NOT EXECUTED
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
40021c84: 7f ff c6 d9 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40021c88: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40021c8c: f8 07 60 80 ld [ %i5 + 0x80 ], %i4 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
40021c90: 7f ff f0 2e call 4001dd48 <rtems_rfs_buffers_release> <== NOT EXECUTED
40021c94: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40021c98: 7f ff b0 e3 call 4000e024 <rtems_semaphore_release> <== NOT EXECUTED
40021c9c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40021ca0: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40021ca4: 12 80 00 08 bne 40021cc4 <rtems_rfs_rtems_dir_open+0x1cc> <== NOT EXECUTED
40021ca8: 90 10 20 00 clr %o0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
40021cac: 40 00 07 a3 call 40023b38 <__errno> <== NOT EXECUTED
40021cb0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40021cb4: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
40021cb8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40021cbc: 81 c7 e0 08 ret <== NOT EXECUTED
40021cc0: 81 e8 00 00 restore <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021cc4: 7f ff cc f8 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40021cc8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021ccc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021cd0: 02 bf ff f7 be 40021cac <rtems_rfs_rtems_dir_open+0x1b4> <== NOT EXECUTED
40021cd4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40021cd8: 7f ff db 4e call 40018a10 <rtems_status_text> <== NOT EXECUTED
40021cdc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021ce0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021ce4: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40021ce8: 40 00 0d 25 call 4002517c <printf> <== NOT EXECUTED
40021cec: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021cf0: 30 bf ff ef b,a 40021cac <rtems_rfs_rtems_dir_open+0x1b4><== NOT EXECUTED
40021cf4 <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
40021cf4: 9d e3 bf 70 save %sp, -144, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
40021cf8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
40021cfc: 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);
40021d00: e0 00 60 08 ld [ %g1 + 8 ], %l0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40021d04: 92 10 20 00 clr %o1
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_filesystem_default_ftruncate_directory,
.fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
40021d08: c2 04 20 80 ld [ %l0 + 0x80 ], %g1
40021d0c: 94 10 20 00 clr %o2
40021d10: 7f ff b0 76 call 4000dee8 <rtems_semaphore_obtain>
40021d14: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40021d18: ba 92 20 00 orcc %o0, 0, %i5
40021d1c: 12 80 00 41 bne 40021e20 <rtems_rfs_rtems_dir_read+0x12c> <== NEVER TAKEN
40021d20: 90 10 20 00 clr %o0
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40021d24: 92 10 00 1c mov %i4, %o1
40021d28: 90 10 00 10 mov %l0, %o0
40021d2c: 94 07 bf d8 add %fp, -40, %o2
40021d30: 7f ff c6 36 call 40013608 <rtems_rfs_inode_open>
40021d34: 96 10 20 01 mov 1, %o3
if (rc)
40021d38: b8 92 20 00 orcc %o0, 0, %i4
40021d3c: 32 80 00 4d bne,a 40021e70 <rtems_rfs_rtems_dir_read+0x17c><== NEVER TAKEN
40021d40: fa 04 20 80 ld [ %l0 + 0x80 ], %i5 <== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
40021d44: 90 10 00 1a mov %i2, %o0
40021d48: 92 10 21 18 mov 0x118, %o1
40021d4c: 7f ff 82 55 call 400026a0 <.udiv>
40021d50: ba 10 20 00 clr %i5
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
40021d54: b4 92 20 00 orcc %o0, 0, %i2
40021d58: 02 80 00 1a be 40021dc0 <rtems_rfs_rtems_dir_read+0xcc> <== NEVER TAKEN
40021d5c: 92 07 bf d8 add %fp, -40, %o1
40021d60: d4 1e 20 08 ldd [ %i0 + 8 ], %o2
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
40021d64: b6 10 20 00 clr %i3
40021d68: 10 80 00 0d b 40021d9c <rtems_rfs_rtems_dir_read+0xa8>
40021d6c: ba 10 20 00 clr %i5
if (rc == ENOENT)
{
rc = 0;
break;
}
if (rc > 0)
40021d70: 80 a2 20 00 cmp %o0, 0
40021d74: 14 80 00 4b bg 40021ea0 <rtems_rfs_rtems_dir_read+0x1ac> <== NEVER TAKEN
40021d78: d4 07 bf d4 ld [ %fp + -44 ], %o2
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
40021d7c: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
40021d80: b6 06 e0 01 inc %i3
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
40021d84: 96 80 c0 0a addcc %g3, %o2, %o3
40021d88: 94 40 a0 00 addx %g2, 0, %o2
40021d8c: d4 3e 20 08 std %o2, [ %i0 + 8 ]
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
40021d90: 80 a6 c0 1a cmp %i3, %i2
40021d94: 02 80 00 0a be 40021dbc <rtems_rfs_rtems_dir_read+0xc8> <== ALWAYS TAKEN
40021d98: ba 07 61 18 add %i5, 0x118, %i5
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
40021d9c: 98 06 40 1d add %i1, %i5, %o4
40021da0: 90 10 00 10 mov %l0, %o0
40021da4: 92 07 bf d8 add %fp, -40, %o1
40021da8: 7f ff f3 fe call 4001eda0 <rtems_rfs_dir_read>
40021dac: 9a 07 bf d4 add %fp, -44, %o5
if (rc == ENOENT)
40021db0: 80 a2 20 02 cmp %o0, 2
40021db4: 12 bf ff ef bne 40021d70 <rtems_rfs_rtems_dir_read+0x7c>
40021db8: b8 10 00 08 mov %o0, %i4
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
40021dbc: 92 07 bf d8 add %fp, -40, %o1
40021dc0: 7f ff c6 8a call 400137e8 <rtems_rfs_inode_close>
40021dc4: 90 10 00 10 mov %l0, %o0
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40021dc8: f8 04 20 80 ld [ %l0 + 0x80 ], %i4
rtems_rfs_buffers_release (fs);
40021dcc: 7f ff ef df call 4001dd48 <rtems_rfs_buffers_release>
40021dd0: 90 10 00 10 mov %l0, %o0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40021dd4: 7f ff b0 94 call 4000e024 <rtems_semaphore_release>
40021dd8: d0 07 00 00 ld [ %i4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40021ddc: b8 92 20 00 orcc %o0, 0, %i4
40021de0: 12 80 00 04 bne 40021df0 <rtems_rfs_rtems_dir_read+0xfc> <== NEVER TAKEN
40021de4: 90 10 20 00 clr %o0
rtems_rfs_rtems_unlock (fs);
return bytes_transferred;
}
40021de8: 81 c7 e0 08 ret
40021dec: 91 e8 00 1d restore %g0, %i5, %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021df0: 7f ff cc ad call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40021df4: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021df8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021dfc: 02 bf ff fb be 40021de8 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
40021e00: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40021e04: 7f ff db 03 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40021e08: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40021e0c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021e10: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40021e14: 40 00 0c da call 4002517c <printf> <== NOT EXECUTED
40021e18: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021e1c: 30 bf ff f3 b,a 40021de8 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021e20: 7f ff cc a1 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40021e24: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021e28: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021e2c: 02 bf ff bf be 40021d28 <rtems_rfs_rtems_dir_read+0x34> <== NOT EXECUTED
40021e30: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40021e34: 7f ff da f7 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40021e38: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021e3c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021e40: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40021e44: 40 00 0c ce call 4002517c <printf> <== NOT EXECUTED
40021e48: 90 12 21 58 or %o0, 0x158, %o0 ! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
40021e4c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40021e50: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40021e54: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
40021e58: 7f ff c5 ec call 40013608 <rtems_rfs_inode_open> <== NOT EXECUTED
40021e5c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
40021e60: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40021e64: 02 bf ff b9 be 40021d48 <rtems_rfs_rtems_dir_read+0x54> <== NOT EXECUTED
40021e68: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40021e6c: fa 04 20 80 ld [ %l0 + 0x80 ], %i5 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
40021e70: 7f ff ef b6 call 4001dd48 <rtems_rfs_buffers_release> <== NOT EXECUTED
40021e74: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40021e78: 7f ff b0 6b call 4000e024 <rtems_semaphore_release> <== NOT EXECUTED
40021e7c: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40021e80: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40021e84: 12 80 00 16 bne 40021edc <rtems_rfs_rtems_dir_read+0x1e8> <== NOT EXECUTED
40021e88: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
40021e8c: 40 00 07 2b call 40023b38 <__errno> <== NOT EXECUTED
40021e90: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
40021e94: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return bytes_transferred;
}
40021e98: 81 c7 e0 08 ret <== NOT EXECUTED
40021e9c: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
rc = 0;
break;
}
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
40021ea0: 40 00 07 26 call 40023b38 <__errno> <== NOT EXECUTED
40021ea4: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
40021ea8: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rc = 0;
break;
}
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
40021eac: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
40021eb0: 7f ff c6 4e call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40021eb4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40021eb8: f8 04 20 80 ld [ %l0 + 0x80 ], %i4 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
40021ebc: 7f ff ef a3 call 4001dd48 <rtems_rfs_buffers_release> <== NOT EXECUTED
40021ec0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40021ec4: 7f ff b0 58 call 4000e024 <rtems_semaphore_release> <== NOT EXECUTED
40021ec8: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40021ecc: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40021ed0: 02 bf ff c6 be 40021de8 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
40021ed4: 90 10 20 00 clr %o0 <== NOT EXECUTED
40021ed8: 30 bf ff c6 b,a 40021df0 <rtems_rfs_rtems_dir_read+0xfc> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40021edc: 7f ff cc 72 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40021ee0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40021ee4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021ee8: 02 bf ff e9 be 40021e8c <rtems_rfs_rtems_dir_read+0x198> <== NOT EXECUTED
40021eec: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40021ef0: 7f ff da c8 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40021ef4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021ef8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40021efc: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40021f00: 40 00 0c 9f call 4002517c <printf> <== NOT EXECUTED
40021f04: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021f08: 30 bf ff e1 b,a 40021e8c <rtems_rfs_rtems_dir_read+0x198><== NOT EXECUTED
40014688 <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)
{
40014688: 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);
4001468c: 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);
40014690: 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);
40014694: 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);
40014698: 94 07 bf d8 add %fp, -40, %o2
4001469c: 90 10 00 1d mov %i5, %o0
400146a0: 7f ff fb da call 40013608 <rtems_rfs_inode_open>
400146a4: 96 10 20 01 mov 1, %o3
if (rc == 0) {
400146a8: b8 92 20 00 orcc %o0, 0, %i4
400146ac: 12 80 00 0e bne 400146e4 <rtems_rfs_rtems_eval_path+0x5c> <== NEVER TAKEN
400146b0: 92 07 bf d8 add %fp, -40, %o1
rtems_filesystem_eval_path_generic (
400146b4: 90 10 00 18 mov %i0, %o0
400146b8: 15 10 00 dc sethi %hi(0x40037000), %o2
400146bc: 40 00 12 d9 call 40019220 <rtems_filesystem_eval_path_generic>
400146c0: 94 12 a2 00 or %o2, 0x200, %o2 ! 40037200 <rtems_rfs_rtems_eval_config>
ctx,
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
400146c4: 90 10 00 1d mov %i5, %o0
400146c8: 7f ff fc 48 call 400137e8 <rtems_rfs_inode_close>
400146cc: 92 07 bf d8 add %fp, -40, %o1
if (rc != 0) {
400146d0: ba 92 20 00 orcc %o0, 0, %i5
400146d4: 12 80 00 0c bne 40014704 <rtems_rfs_rtems_eval_path+0x7c> <== NEVER TAKEN
400146d8: 01 00 00 00 nop
400146dc: 81 c7 e0 08 ret
400146e0: 81 e8 00 00 restore
);
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
400146e4: 40 00 3d 15 call 40023b38 <__errno> <== NOT EXECUTED
400146e8: 01 00 00 00 nop <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
);
}
} else {
rtems_filesystem_eval_path_error (
400146ec: 92 10 3f ff mov -1, %o1 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
400146f0: 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 (
400146f4: 7f ff d8 45 call 4000a808 <rtems_filesystem_eval_path_error><== NOT EXECUTED
400146f8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400146fc: 81 c7 e0 08 ret <== NOT EXECUTED
40014700: 81 e8 00 00 restore <== NOT EXECUTED
);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc != 0) {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
40014704: 40 00 3d 0d call 40023b38 <__errno> <== NOT EXECUTED
40014708: 01 00 00 00 nop <== NOT EXECUTED
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc != 0) {
rtems_filesystem_eval_path_error (
4001470c: 92 10 3f ff mov -1, %o1 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
40014710: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc != 0) {
rtems_filesystem_eval_path_error (
40014714: 7f ff d8 3d call 4000a808 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40014718: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4001471c: 81 c7 e0 08 ret <== NOT EXECUTED
40014720: 81 e8 00 00 restore <== NOT EXECUTED
40014a30 <rtems_rfs_rtems_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
40014a30: 9d e3 bf 90 save %sp, -112, %sp
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
40014a34: c2 06 60 0c ld [ %i1 + 0xc ], %g1
static bool
rtems_rfs_rtems_eval_perms (rtems_filesystem_eval_path_context_t *ctx,
int eval_flags,
rtems_rfs_inode_handle* inode)
{
return rtems_filesystem_eval_path_check_access(
40014a38: 90 10 00 18 mov %i0, %o0
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
40014a3c: c6 08 60 06 ldub [ %g1 + 6 ], %g3
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
40014a40: c4 08 60 05 ldub [ %g1 + 5 ], %g2
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
40014a44: c8 08 60 02 ldub [ %g1 + 2 ], %g4
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
40014a48: d6 08 60 07 ldub [ %g1 + 7 ], %o3
40014a4c: d4 08 60 03 ldub [ %g1 + 3 ], %o2
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
40014a50: d8 08 60 04 ldub [ %g1 + 4 ], %o4
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
40014a54: 87 28 e0 08 sll %g3, 8, %g3
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
40014a58: 83 29 20 08 sll %g4, 8, %g1
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
40014a5c: 85 28 a0 10 sll %g2, 0x10, %g2
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
40014a60: 96 10 c0 0b or %g3, %o3, %o3
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
40014a64: ba 10 00 18 mov %i0, %i5
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
40014a68: 99 2b 20 18 sll %o4, 0x18, %o4
static bool
rtems_rfs_rtems_eval_perms (rtems_filesystem_eval_path_context_t *ctx,
int eval_flags,
rtems_rfs_inode_handle* inode)
{
return rtems_filesystem_eval_path_check_access(
40014a6c: 97 2a e0 10 sll %o3, 0x10, %o3
40014a70: 98 13 00 02 or %o4, %g2, %o4
40014a74: 92 10 20 01 mov 1, %o1
40014a78: 94 12 80 01 or %o2, %g1, %o2
40014a7c: 97 32 e0 10 srl %o3, 0x10, %o3
40014a80: 99 33 20 10 srl %o4, 0x10, %o4
40014a84: 40 00 11 da call 400191ec <rtems_filesystem_eval_path_check_access>
40014a88: 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) {
40014a8c: 80 8a 20 ff btst 0xff, %o0
40014a90: 02 80 00 39 be 40014b74 <rtems_rfs_rtems_eval_token+0x144>
40014a94: 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] == '.';
40014a98: 22 80 00 39 be,a 40014b7c <rtems_rfs_rtems_eval_token+0x14c>
40014a9c: c2 4e 80 00 ldsb [ %i2 ], %g1
if (rtems_filesystem_is_current_directory (token, tokenlen)) {
rtems_filesystem_eval_path_clear_token (ctx);
} else {
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc( ctx );
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
40014aa0: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
40014aa4: 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);
40014aa8: f8 00 60 08 ld [ %g1 + 8 ], %i4
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
40014aac: 94 10 00 1a mov %i2, %o2
40014ab0: 90 10 00 1c mov %i4, %o0
40014ab4: 96 10 00 1b mov %i3, %o3
40014ab8: 98 07 bf f4 add %fp, -12, %o4
40014abc: 40 00 25 4b call 4001dfe8 <rtems_rfs_dir_lookup_ino>
40014ac0: 9a 07 bf f8 add %fp, -8, %o5
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
40014ac4: 80 a2 20 00 cmp %o0, 0
40014ac8: 12 80 00 2b bne 40014b74 <rtems_rfs_rtems_eval_token+0x144>
40014acc: b0 10 20 02 mov 2, %i0
rc = rtems_rfs_inode_close (fs, inode);
40014ad0: 90 10 00 1c mov %i4, %o0
40014ad4: 7f ff fb 45 call 400137e8 <rtems_rfs_inode_close>
40014ad8: 92 10 00 19 mov %i1, %o1
if (rc == 0) {
40014adc: 80 a2 20 00 cmp %o0, 0
40014ae0: 12 80 00 2d bne 40014b94 <rtems_rfs_rtems_eval_token+0x164><== NEVER TAKEN
40014ae4: 90 10 00 19 mov %i1, %o0
rc = rtems_rfs_inode_open (fs, entry_ino, inode, true);
40014ae8: d2 07 bf f4 ld [ %fp + -12 ], %o1
40014aec: 90 10 00 1c mov %i4, %o0
40014af0: 94 10 00 19 mov %i1, %o2
40014af4: 7f ff fa c5 call 40013608 <rtems_rfs_inode_open>
40014af8: 96 10 20 01 mov 1, %o3
}
if (rc != 0) {
40014afc: 80 a2 20 00 cmp %o0, 0
40014b00: 12 80 00 25 bne 40014b94 <rtems_rfs_rtems_eval_token+0x164><== NEVER TAKEN
40014b04: 90 10 00 19 mov %i1, %o0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
rc = -1;
}
if (rc == 0) {
bool is_sym_link = rtems_rfs_rtems_node_type_by_inode (inode)
40014b08: 7f ff fd 0a call 40013f30 <rtems_rfs_rtems_node_type_by_inode>
40014b0c: 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);
40014b10: 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;
40014b14: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
40014b18: 80 a0 00 01 cmp %g0, %g1
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
40014b1c: c0 27 60 0c clr [ %i5 + 0xc ]
40014b20: 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;
40014b24: 85 30 a0 04 srl %g2, 4, %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
40014b28: b0 10 00 01 mov %g1, %i0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
40014b2c: 80 a2 20 03 cmp %o0, 3
40014b30: 12 80 00 07 bne 40014b4c <rtems_rfs_rtems_eval_token+0x11c>
40014b34: 84 08 a0 01 and %g2, 1, %g2
40014b38: 80 a0 60 00 cmp %g1, 0
40014b3c: 02 80 00 25 be 40014bd0 <rtems_rfs_rtems_eval_token+0x1a0>
40014b40: 80 88 a0 ff btst 0xff, %g2
40014b44: 12 80 00 24 bne 40014bd4 <rtems_rfs_rtems_eval_token+0x1a4>
40014b48: 82 10 24 00 mov 0x400, %g1
rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);
} else {
rc = rtems_rfs_rtems_set_handlers (currentloc, inode) ? 0 : EIO;
40014b4c: 90 07 60 18 add %i5, 0x18, %o0
40014b50: 40 00 01 16 call 40014fa8 <rtems_rfs_rtems_set_handlers>
40014b54: 92 10 00 19 mov %i1, %o1
40014b58: 80 8a 20 ff btst 0xff, %o0
40014b5c: 02 80 00 14 be 40014bac <rtems_rfs_rtems_eval_token+0x17c><== NEVER TAKEN
40014b60: c2 07 bf f4 ld [ %fp + -12 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
40014b64: 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);
40014b68: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
40014b6c: c2 07 bf f8 ld [ %fp + -8 ], %g1
40014b70: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
}
}
}
return status;
}
40014b74: 81 c7 e0 08 ret
40014b78: 81 e8 00 00 restore
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
40014b7c: 80 a0 60 2e cmp %g1, 0x2e
40014b80: 32 bf ff c9 bne,a 40014aa4 <rtems_rfs_rtems_eval_token+0x74>
40014b84: 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;
40014b88: c0 27 60 0c clr [ %i5 + 0xc ]
40014b8c: 81 c7 e0 08 ret
40014b90: 81 e8 00 00 restore
if (rc != 0) {
/*
* This prevents the rtems_rfs_inode_close() from doing something in
* rtems_rfs_rtems_eval_path().
*/
memset (inode, 0, sizeof(*inode));
40014b94: 92 10 20 00 clr %o1 <== NOT EXECUTED
40014b98: 94 10 20 28 mov 0x28, %o2 <== NOT EXECUTED
40014b9c: 40 00 40 fa call 40024f84 <memset> <== NOT EXECUTED
40014ba0: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
40014ba4: 81 c7 e0 08 ret <== NOT EXECUTED
40014ba8: 81 e8 00 00 restore <== NOT EXECUTED
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
40014bac: 40 00 3b e3 call 40023b38 <__errno> <== NOT EXECUTED
40014bb0: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
40014bb4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
40014bb8: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
40014bbc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
40014bc0: 7f ff d7 12 call 4000a808 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40014bc4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40014bc8: 81 c7 e0 08 ret <== NOT EXECUTED
40014bcc: 81 e8 00 00 restore <== NOT EXECUTED
rtems_filesystem_eval_path_context_t* ctx,
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
40014bd0: 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);
40014bd4: f4 07 bf f4 ld [ %fp + -12 ], %i2
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
char *link = malloc(len + 1);
40014bd8: 90 10 24 01 mov 0x401, %o0
40014bdc: 7f ff d2 f0 call 4000979c <malloc>
40014be0: c2 27 bf fc st %g1, [ %fp + -4 ]
if (link != NULL) {
40014be4: b6 92 20 00 orcc %o0, 0, %i3
40014be8: 02 80 00 14 be 40014c38 <rtems_rfs_rtems_eval_token+0x208><== NEVER TAKEN
40014bec: 90 10 00 1c mov %i4, %o0
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
40014bf0: 92 10 00 1a mov %i2, %o1
40014bf4: 94 10 00 1b mov %i3, %o2
40014bf8: 96 10 24 00 mov 0x400, %o3
40014bfc: 40 00 32 82 call 40021604 <rtems_rfs_symlink_read>
40014c00: 98 07 bf fc add %fp, -4, %o4
if (rc == 0) {
40014c04: 80 a2 20 00 cmp %o0, 0
40014c08: 12 80 00 09 bne 40014c2c <rtems_rfs_rtems_eval_token+0x1fc><== NEVER TAKEN
40014c0c: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_recursive (ctx, link, len);
40014c10: d4 07 bf fc ld [ %fp + -4 ], %o2
40014c14: 7f ff d8 25 call 4000aca8 <rtems_filesystem_eval_path_recursive>
40014c18: 92 10 00 1b mov %i3, %o1
} else {
rtems_filesystem_eval_path_error (ctx, 0);
}
free(link);
40014c1c: 7f ff d1 43 call 40009128 <free>
40014c20: 90 10 00 1b mov %i3, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
40014c24: 81 c7 e0 08 ret
40014c28: 91 e8 20 01 restore %g0, 1, %o0
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
if (rc == 0) {
rtems_filesystem_eval_path_recursive (ctx, link, len);
} else {
rtems_filesystem_eval_path_error (ctx, 0);
40014c2c: 7f ff d6 f7 call 4000a808 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40014c30: 92 10 20 00 clr %o1 <== NOT EXECUTED
40014c34: 30 bf ff fa b,a 40014c1c <rtems_rfs_rtems_eval_token+0x1ec><== NOT EXECUTED
}
free(link);
} else {
rtems_filesystem_eval_path_error (ctx, ENOMEM);
40014c38: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40014c3c: 7f ff d6 f3 call 4000a808 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40014c40: 92 10 20 0c mov 0xc, %o1 <== NOT EXECUTED
40014c44: 30 bf ff f8 b,a 40014c24 <rtems_rfs_rtems_eval_token+0x1f4><== NOT EXECUTED
400143c8 <rtems_rfs_rtems_fchmod>:
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
400143c8: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
400143cc: 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);
400143d0: 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);
400143d4: f8 00 60 08 ld [ %g1 + 8 ], %i4
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
400143d8: 94 07 bf d8 add %fp, -40, %o2
400143dc: 90 10 00 1c mov %i4, %o0
400143e0: 7f ff fc 8a call 40013608 <rtems_rfs_inode_open>
400143e4: 96 10 20 01 mov 1, %o3
if (rc)
400143e8: ba 92 20 00 orcc %o0, 0, %i5
400143ec: 12 80 00 24 bne 4001447c <rtems_rfs_rtems_fchmod+0xb4> <== NEVER TAKEN
400143f0: c2 07 bf e4 ld [ %fp + -28 ], %g1
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
400143f4: c4 08 60 02 ldub [ %g1 + 2 ], %g2
400143f8: c2 08 60 03 ldub [ %g1 + 3 ], %g1
400143fc: 85 28 a0 08 sll %g2, 8, %g2
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
40014400: 40 00 12 59 call 40018d64 <geteuid>
40014404: ba 10 80 01 or %g2, %g1, %i5
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
40014408: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
4001440c: 91 2a 20 10 sll %o0, 0x10, %o0
40014410: c4 08 60 06 ldub [ %g1 + 6 ], %g2
40014414: c6 08 60 07 ldub [ %g1 + 7 ], %g3
40014418: 85 28 a0 08 sll %g2, 8, %g2
4001441c: 84 10 80 03 or %g2, %g3, %g2
40014420: 85 28 a0 10 sll %g2, 0x10, %g2
40014424: 80 a0 80 08 cmp %g2, %o0
40014428: 02 80 00 05 be 4001443c <rtems_rfs_rtems_fchmod+0x74> <== ALWAYS TAKEN
4001442c: 89 32 20 10 srl %o0, 0x10, %g4
40014430: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
40014434: 12 80 00 17 bne 40014490 <rtems_rfs_rtems_fchmod+0xc8> <== NOT EXECUTED
40014438: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
4001443c: ba 0f 70 00 and %i5, -4096, %i5
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
40014440: b2 0e 6f ff and %i1, 0xfff, %i1
40014444: b2 17 40 19 or %i5, %i1, %i1
* @prarm mode The mode.
*/
static inline void
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{
rtems_rfs_write_u16 (&handle->node->mode, mode);
40014448: 85 36 60 08 srl %i1, 8, %g2
4001444c: c4 28 60 02 stb %g2, [ %g1 + 2 ]
40014450: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
40014454: 90 10 00 1c mov %i4, %o0
40014458: f2 28 60 03 stb %i1, [ %g1 + 3 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
4001445c: 82 10 20 01 mov 1, %g1
40014460: 92 07 bf d8 add %fp, -40, %o1
40014464: c2 2f bf e8 stb %g1, [ %fp + -24 ]
40014468: 7f ff fc e0 call 400137e8 <rtems_rfs_inode_close>
4001446c: b0 10 20 00 clr %i0
if (rc > 0)
40014470: 80 a2 20 00 cmp %o0, 0
40014474: 04 80 00 05 ble 40014488 <rtems_rfs_rtems_fchmod+0xc0> <== ALWAYS TAKEN
40014478: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
4001447c: 40 00 3d af call 40023b38 <__errno> <== NOT EXECUTED
40014480: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014484: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40014488: 81 c7 e0 08 ret
4001448c: 81 e8 00 00 restore
#if defined (RTEMS_POSIX_API)
uid = geteuid();
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
{
rtems_rfs_inode_close (fs, &inode);
40014490: 7f ff fc d6 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40014494: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
40014498: 40 00 3d a8 call 40023b38 <__errno> <== NOT EXECUTED
4001449c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400144a0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
400144a4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400144a8: 81 c7 e0 08 ret <== NOT EXECUTED
400144ac: 81 e8 00 00 restore <== NOT EXECUTED
40014f74 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
40014f74: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
40014f78: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
if (rc)
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
return 0;
40014f7c: 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));
40014f80: 40 00 23 4c call 4001dcb0 <rtems_rfs_buffer_sync> <== NOT EXECUTED
40014f84: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
if (rc)
40014f88: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40014f8c: 02 80 00 05 be 40014fa0 <rtems_rfs_rtems_fdatasync+0x2c> <== NOT EXECUTED
40014f90: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
40014f94: 40 00 3a e9 call 40023b38 <__errno> <== NOT EXECUTED
40014f98: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014f9c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return 0;
}
40014fa0: 81 c7 e0 08 ret <== NOT EXECUTED
40014fa4: 81 e8 00 00 restore <== NOT EXECUTED
400220f8 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
400220f8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
400220fc: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40022100: 92 10 20 00 clr %o1
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
40022104: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
40022108: 94 10 20 00 clr %o2
4002210c: fa 00 60 98 ld [ %g1 + 0x98 ], %i5
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
40022110: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
40022114: 7f ff af 75 call 4000dee8 <rtems_semaphore_obtain>
40022118: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4002211c: b6 92 20 00 orcc %o0, 0, %i3
40022120: 12 80 00 21 bne 400221a4 <rtems_rfs_rtems_file_close+0xac><== NEVER TAKEN
40022124: 90 10 20 00 clr %o0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_file_close (fs, file);
40022128: 90 10 00 1d mov %i5, %o0
4002212c: 7f ff f5 7e call 4001f724 <rtems_rfs_file_close>
40022130: 92 10 00 1c mov %i4, %o1
if (rc > 0)
40022134: b0 92 20 00 orcc %o0, 0, %i0
40022138: 24 80 00 07 ble,a 40022154 <rtems_rfs_rtems_file_close+0x5c><== ALWAYS TAKEN
4002213c: f8 07 60 80 ld [ %i5 + 0x80 ], %i4
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
40022140: 40 00 06 7e call 40023b38 <__errno> <== NOT EXECUTED
40022144: 01 00 00 00 nop <== NOT EXECUTED
40022148: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
4002214c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40022150: f8 07 60 80 ld [ %i5 + 0x80 ], %i4 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
40022154: 7f ff ee fd call 4001dd48 <rtems_rfs_buffers_release>
40022158: 90 10 00 1d mov %i5, %o0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
4002215c: 7f ff af b2 call 4000e024 <rtems_semaphore_release>
40022160: d0 07 00 00 ld [ %i4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40022164: ba 92 20 00 orcc %o0, 0, %i5
40022168: 02 80 00 0d be 4002219c <rtems_rfs_rtems_file_close+0xa4> <== ALWAYS TAKEN
4002216c: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40022170: 7f ff cb cd call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40022174: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40022178: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4002217c: 02 80 00 08 be 4002219c <rtems_rfs_rtems_file_close+0xa4> <== NOT EXECUTED
40022180: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40022184: 7f ff da 23 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40022188: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4002218c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40022190: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40022194: 40 00 0b fa call 4002517c <printf> <== NOT EXECUTED
40022198: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rc;
}
4002219c: 81 c7 e0 08 ret
400221a0: 81 e8 00 00 restore
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
400221a4: 7f ff cb c0 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
400221a8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400221ac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400221b0: 22 bf ff df be,a 4002212c <rtems_rfs_rtems_file_close+0x34><== NOT EXECUTED
400221b4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
400221b8: 7f ff da 16 call 40018a10 <rtems_status_text> <== NOT EXECUTED
400221bc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
400221c0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400221c4: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
400221c8: 40 00 0b ed call 4002517c <printf> <== NOT EXECUTED
400221cc: 90 12 21 58 or %o0, 0x158, %o0 ! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_file_close (fs, file);
400221d0: 10 bf ff d7 b 4002212c <rtems_rfs_rtems_file_close+0x34> <== NOT EXECUTED
400221d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400221d8 <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
400221d8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
400221dc: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
400221e0: 92 10 20 00 clr %o1
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
400221e4: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
400221e8: 94 10 20 00 clr %o2
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
400221ec: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
400221f0: ba 10 00 1a mov %i2, %i5
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
400221f4: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
400221f8: b8 10 00 19 mov %i1, %i4
400221fc: 7f ff af 3b call 4000dee8 <rtems_semaphore_obtain>
40022200: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40022204: b4 92 20 00 orcc %o0, 0, %i2
40022208: 12 80 00 23 bne 40022294 <rtems_rfs_rtems_file_ftruncate+0xbc><== NEVER TAKEN
4002220c: 90 10 20 00 clr %o0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
rc = rtems_rfs_file_set_size (file, length);
40022210: 90 10 00 1b mov %i3, %o0
40022214: 92 10 00 1c mov %i4, %o1
40022218: 7f ff f7 93 call 40020064 <rtems_rfs_file_set_size>
4002221c: 94 10 00 1d mov %i5, %o2
if (rc)
40022220: b0 92 20 00 orcc %o0, 0, %i0
40022224: 22 80 00 07 be,a 40022240 <rtems_rfs_rtems_file_ftruncate+0x68><== ALWAYS TAKEN
40022228: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
4002222c: 40 00 06 43 call 40023b38 <__errno> <== NOT EXECUTED
40022230: 01 00 00 00 nop <== NOT EXECUTED
40022234: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
40022238: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4002223c: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
40022240: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_buffers_release (fs);
40022244: 7f ff ee c1 call 4001dd48 <rtems_rfs_buffers_release>
40022248: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
4002224c: 7f ff af 76 call 4000e024 <rtems_semaphore_release>
40022250: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40022254: ba 92 20 00 orcc %o0, 0, %i5
40022258: 02 80 00 0d be 4002228c <rtems_rfs_rtems_file_ftruncate+0xb4><== ALWAYS TAKEN
4002225c: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40022260: 7f ff cb 91 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40022264: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40022268: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4002226c: 02 80 00 08 be 4002228c <rtems_rfs_rtems_file_ftruncate+0xb4><== NOT EXECUTED
40022270: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40022274: 7f ff d9 e7 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40022278: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4002227c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40022280: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40022284: 40 00 0b be call 4002517c <printf> <== NOT EXECUTED
40022288: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
return rc;
}
4002228c: 81 c7 e0 08 ret
40022290: 81 e8 00 00 restore
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40022294: 7f ff cb 84 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40022298: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4002229c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400222a0: 22 bf ff dd be,a 40022214 <rtems_rfs_rtems_file_ftruncate+0x3c><== NOT EXECUTED
400222a4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
400222a8: 7f ff d9 da call 40018a10 <rtems_status_text> <== NOT EXECUTED
400222ac: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
400222b0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400222b4: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
400222b8: 40 00 0b b1 call 4002517c <printf> <== NOT EXECUTED
400222bc: 90 12 21 58 or %o0, 0x158, %o0 ! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
rc = rtems_rfs_file_set_size (file, length);
400222c0: 10 bf ff d5 b 40022214 <rtems_rfs_rtems_file_ftruncate+0x3c><== NOT EXECUTED
400222c4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
400222c8 <rtems_rfs_rtems_file_lseek>:
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
400222c8: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
400222cc: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
400222d0: 92 10 20 00 clr %o1
off_t new_offset;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
400222d4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
400222d8: 94 10 20 00 clr %o2
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
400222dc: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
400222e0: b8 10 00 19 mov %i1, %i4
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
400222e4: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
400222e8: ba 10 00 1a mov %i2, %i5
400222ec: d0 00 40 00 ld [ %g1 ], %o0
400222f0: 7f ff ae fe call 4000dee8 <rtems_semaphore_obtain>
400222f4: b2 10 00 1b mov %i3, %i1
if (sc != RTEMS_SUCCESSFUL)
400222f8: b4 92 20 00 orcc %o0, 0, %i2
400222fc: 12 80 00 22 bne 40022384 <rtems_rfs_rtems_file_lseek+0xbc><== NEVER TAKEN
40022300: 90 10 20 00 clr %o0
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
40022304: 92 10 00 1c mov %i4, %o1
40022308: 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;
4002230c: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
40022310: 90 10 00 18 mov %i0, %o0
40022314: 40 00 01 99 call 40022978 <rtems_filesystem_default_lseek_file>
40022318: 96 10 00 19 mov %i1, %o3
4002231c: b8 10 00 08 mov %o0, %i4
if (new_offset != -1)
40022320: 80 a7 3f ff cmp %i4, -1
40022324: 02 80 00 2d be 400223d8 <rtems_rfs_rtems_file_lseek+0x110>
40022328: ba 10 00 09 mov %o1, %i5
{
rtems_rfs_pos pos = iop->offset;
4002232c: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
int rc = rtems_rfs_file_seek (file, pos, &pos);
40022330: 90 10 00 10 mov %l0, %o0
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
if (new_offset != -1)
{
rtems_rfs_pos pos = iop->offset;
40022334: c4 3f bf f8 std %g2, [ %fp + -8 ]
int rc = rtems_rfs_file_seek (file, pos, &pos);
40022338: 92 10 00 02 mov %g2, %o1
4002233c: 94 10 00 03 mov %g3, %o2
40022340: 7f ff f7 06 call 4001ff58 <rtems_rfs_file_seek>
40022344: 96 07 bf f8 add %fp, -8, %o3
if (rc)
40022348: b2 92 20 00 orcc %o0, 0, %i1
4002234c: 12 80 00 30 bne 4002240c <rtems_rfs_rtems_file_lseek+0x144><== NEVER TAKEN
40022350: 01 00 00 00 nop
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
40022354: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40022358: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_buffers_release (fs);
4002235c: 7f ff ee 7b call 4001dd48 <rtems_rfs_buffers_release>
40022360: f6 02 20 80 ld [ %o0 + 0x80 ], %i3
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40022364: 7f ff af 30 call 4000e024 <rtems_semaphore_release>
40022368: d0 06 c0 00 ld [ %i3 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4002236c: b6 92 20 00 orcc %o0, 0, %i3
40022370: 12 80 00 36 bne 40022448 <rtems_rfs_rtems_file_lseek+0x180><== NEVER TAKEN
40022374: 90 10 20 00 clr %o0
return new_offset;
}
40022378: b0 10 00 1c mov %i4, %i0
4002237c: 81 c7 e0 08 ret
40022380: 93 e8 00 1d restore %g0, %i5, %o1
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40022384: 7f ff cb 48 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40022388: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4002238c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40022390: 02 bf ff de be 40022308 <rtems_rfs_rtems_file_lseek+0x40> <== NOT EXECUTED
40022394: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40022398: 7f ff d9 9e call 40018a10 <rtems_status_text> <== NOT EXECUTED
4002239c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
400223a0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400223a4: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
400223a8: 40 00 0b 75 call 4002517c <printf> <== NOT EXECUTED
400223ac: 90 12 21 58 or %o0, 0x158, %o0 ! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
400223b0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
400223b4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
old_offset = iop->offset;
400223b8: f4 1e 20 08 ldd [ %i0 + 8 ], %i2 <== NOT EXECUTED
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
400223bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400223c0: 40 00 01 6e call 40022978 <rtems_filesystem_default_lseek_file><== NOT EXECUTED
400223c4: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
400223c8: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
if (new_offset != -1)
400223cc: 80 a7 3f ff cmp %i4, -1 <== NOT EXECUTED
400223d0: 12 bf ff d7 bne 4002232c <rtems_rfs_rtems_file_lseek+0x64><== NOT EXECUTED
400223d4: ba 10 00 09 mov %o1, %i5 <== NOT EXECUTED
400223d8: 80 a2 7f ff cmp %o1, -1
400223dc: 22 bf ff df be,a 40022358 <rtems_rfs_rtems_file_lseek+0x90><== ALWAYS TAKEN
400223e0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
{
rtems_rfs_pos pos = iop->offset;
400223e4: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 <== NOT EXECUTED
int rc = rtems_rfs_file_seek (file, pos, &pos);
400223e8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
if (new_offset != -1)
{
rtems_rfs_pos pos = iop->offset;
400223ec: c4 3f bf f8 std %g2, [ %fp + -8 ] <== NOT EXECUTED
int rc = rtems_rfs_file_seek (file, pos, &pos);
400223f0: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
400223f4: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
400223f8: 7f ff f6 d8 call 4001ff58 <rtems_rfs_file_seek> <== NOT EXECUTED
400223fc: 96 07 bf f8 add %fp, -8, %o3 <== NOT EXECUTED
if (rc)
40022400: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
40022404: 22 bf ff d5 be,a 40022358 <rtems_rfs_rtems_file_lseek+0x90><== NOT EXECUTED
40022408: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
4002240c: 40 00 05 cb call 40023b38 <__errno> <== NOT EXECUTED
40022410: 39 3f ff ff sethi %hi(0xfffffc00), %i4 <== NOT EXECUTED
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
40022414: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
rtems_rfs_pos pos = iop->offset;
int rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
40022418: f2 22 00 00 st %i1, [ %o0 ] <== NOT EXECUTED
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4002241c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
int rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
iop->offset = old_offset;
40022420: f4 3e 20 08 std %i2, [ %i0 + 8 ] <== NOT EXECUTED
40022424: 7f ff ee 49 call 4001dd48 <rtems_rfs_buffers_release> <== NOT EXECUTED
40022428: f6 02 20 80 ld [ %o0 + 0x80 ], %i3 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
4002242c: 7f ff ae fe call 4000e024 <rtems_semaphore_release> <== NOT EXECUTED
40022430: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
new_offset = -1;
40022434: b8 17 23 ff or %i4, 0x3ff, %i4 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40022438: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED
4002243c: 02 bf ff cf be 40022378 <rtems_rfs_rtems_file_lseek+0xb0> <== NOT EXECUTED
40022440: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40022444: 90 10 20 00 clr %o0 <== NOT EXECUTED
40022448: 7f ff cb 17 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4002244c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40022450: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40022454: 22 bf ff ca be,a 4002237c <rtems_rfs_rtems_file_lseek+0xb4><== NOT EXECUTED
40022458: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
4002245c: 7f ff d9 6d call 40018a10 <rtems_status_text> <== NOT EXECUTED
40022460: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return new_offset;
}
40022464: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
40022468: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4002246c: b2 10 00 1d mov %i5, %i1 <== NOT EXECUTED
40022470: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40022474: 40 00 0b 42 call 4002517c <printf> <== NOT EXECUTED
40022478: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
4002247c: 81 c7 e0 08 ret <== NOT EXECUTED
40022480: 81 e8 00 00 restore <== NOT EXECUTED
40022484 <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
40022484: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
40022488: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
4002248c: 92 10 20 00 clr %o1
40022490: fa 00 60 08 ld [ %g1 + 8 ], %i5
40022494: 94 10 20 00 clr %o2
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
40022498: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
4002249c: 7f ff ae 93 call 4000dee8 <rtems_semaphore_obtain>
400224a0: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
400224a4: b8 92 20 00 orcc %o0, 0, %i4
400224a8: 12 80 00 23 bne 40022534 <rtems_rfs_rtems_file_open+0xb0> <== NEVER TAKEN
400224ac: 90 10 20 00 clr %o0
rtems_rfs_rtems_lock (fs);
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
400224b0: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
400224b4: 90 10 00 1d mov %i5, %o0
400224b8: 94 10 20 00 clr %o2
400224bc: 7f ff f3 c9 call 4001f3e0 <rtems_rfs_file_open>
400224c0: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
400224c4: b8 92 20 00 orcc %o0, 0, %i4
400224c8: 04 80 00 2f ble 40022584 <rtems_rfs_rtems_file_open+0x100><== ALWAYS TAKEN
400224cc: c2 07 bf fc ld [ %fp + -4 ], %g1
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
400224d0: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
400224d4: 7f ff ee 1d call 4001dd48 <rtems_rfs_buffers_release> <== NOT EXECUTED
400224d8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
400224dc: 7f ff ae d2 call 4000e024 <rtems_semaphore_release> <== NOT EXECUTED
400224e0: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
400224e4: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
400224e8: 12 80 00 07 bne 40022504 <rtems_rfs_rtems_file_open+0x80> <== NOT EXECUTED
400224ec: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("file-open: open", rc);
400224f0: 40 00 05 92 call 40023b38 <__errno> <== NOT EXECUTED
400224f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400224f8: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
400224fc: 81 c7 e0 08 ret <== NOT EXECUTED
40022500: 81 e8 00 00 restore <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40022504: 7f ff ca e8 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40022508: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4002250c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40022510: 02 bf ff f8 be 400224f0 <rtems_rfs_rtems_file_open+0x6c> <== NOT EXECUTED
40022514: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40022518: 7f ff d9 3e call 40018a10 <rtems_status_text> <== NOT EXECUTED
4002251c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40022520: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40022524: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40022528: 40 00 0b 15 call 4002517c <printf> <== NOT EXECUTED
4002252c: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40022530: 30 bf ff f0 b,a 400224f0 <rtems_rfs_rtems_file_open+0x6c><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40022534: 7f ff ca dc call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40022538: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
4002253c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40022540: 22 bf ff dd be,a 400224b4 <rtems_rfs_rtems_file_open+0x30><== NOT EXECUTED
40022544: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40022548: 7f ff d9 32 call 40018a10 <rtems_status_text> <== NOT EXECUTED
4002254c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40022550: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40022554: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40022558: 40 00 0b 09 call 4002517c <printf> <== NOT EXECUTED
4002255c: 90 12 21 58 or %o0, 0x158, %o0 ! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
40022560: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
40022564: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40022568: 94 10 20 00 clr %o2 <== NOT EXECUTED
4002256c: 7f ff f3 9d call 4001f3e0 <rtems_rfs_file_open> <== NOT EXECUTED
40022570: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
if (rc > 0)
40022574: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40022578: 34 bf ff d7 bg,a 400224d4 <rtems_rfs_rtems_file_open+0x50><== NOT EXECUTED
4002257c: f6 07 60 80 ld [ %i5 + 0x80 ], %i3 <== NOT EXECUTED
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
rtems_rfs_rtems_set_iop_file_handle (iop, file);
40022580: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40022584: f8 07 60 80 ld [ %i5 + 0x80 ], %i4
rtems_rfs_buffers_release (fs);
40022588: 90 10 00 1d mov %i5, %o0
4002258c: 7f ff ed ef call 4001dd48 <rtems_rfs_buffers_release>
40022590: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40022594: 7f ff ae a4 call 4000e024 <rtems_semaphore_release>
40022598: d0 07 00 00 ld [ %i4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4002259c: ba 92 20 00 orcc %o0, 0, %i5
400225a0: 12 80 00 04 bne 400225b0 <rtems_rfs_rtems_file_open+0x12c><== NEVER TAKEN
400225a4: 90 10 20 00 clr %o0
rtems_rfs_rtems_unlock (fs);
return 0;
}
400225a8: 81 c7 e0 08 ret
400225ac: 91 e8 20 00 restore %g0, 0, %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
400225b0: 7f ff ca bd call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
400225b4: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400225b8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400225bc: 02 bf ff fb be 400225a8 <rtems_rfs_rtems_file_open+0x124> <== NOT EXECUTED
400225c0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
400225c4: 7f ff d9 13 call 40018a10 <rtems_status_text> <== NOT EXECUTED
400225c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400225cc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400225d0: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
400225d4: 40 00 0a ea call 4002517c <printf> <== NOT EXECUTED
400225d8: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400225dc: 30 bf ff f3 b,a 400225a8 <rtems_rfs_rtems_file_open+0x124><== NOT EXECUTED
40021f0c <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
40021f0c: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
40021f10: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40021f14: 92 10 20 00 clr %o1
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
40021f18: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40021f1c: 94 10 20 00 clr %o2
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40021f20: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
40021f24: a2 10 00 18 mov %i0, %l1
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
40021f28: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
40021f2c: 7f ff af ef call 4000dee8 <rtems_semaphore_obtain>
40021f30: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40021f34: ba 92 20 00 orcc %o0, 0, %i5
40021f38: 12 80 00 5b bne 400220a4 <rtems_rfs_rtems_file_read+0x198><== NEVER TAKEN
40021f3c: 90 10 20 00 clr %o0
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
40021f40: 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;
40021f44: f8 1c 60 08 ldd [ %l1 + 8 ], %i4
40021f48: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
40021f4c: 7f ff ea 1b call 4001c7b8 <rtems_rfs_block_get_size>
40021f50: 92 02 60 84 add %o1, 0x84, %o1
if (pos < rtems_rfs_file_size (file))
40021f54: 80 a2 00 1c cmp %o0, %i4
40021f58: 18 80 00 19 bgu 40021fbc <rtems_rfs_rtems_file_read+0xb0> <== NEVER TAKEN
40021f5c: 80 a6 a0 00 cmp %i2, 0
40021f60: 80 a2 00 1c cmp %o0, %i4
40021f64: 02 80 00 13 be 40021fb0 <rtems_rfs_rtems_file_read+0xa4> <== ALWAYS TAKEN
40021f68: 80 a2 40 1d cmp %o1, %i5
{
while (count)
40021f6c: 84 10 20 00 clr %g2 <== NOT EXECUTED
40021f70: 86 10 20 00 clr %g3
size_t count)
{
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_pos pos;
uint8_t* data = buffer;
ssize_t read = 0;
40021f74: b0 10 20 00 clr %i0
}
}
}
if (read >= 0)
iop->offset = pos + read;
40021f78: b6 80 c0 1d addcc %g3, %i5, %i3
40021f7c: b4 40 80 1c addx %g2, %i4, %i2
40021f80: f4 3c 60 08 std %i2, [ %l1 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
40021f84: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40021f88: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_buffers_release (fs);
40021f8c: 7f ff ef 6f call 4001dd48 <rtems_rfs_buffers_release>
40021f90: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40021f94: 7f ff b0 24 call 4000e024 <rtems_semaphore_release>
40021f98: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40021f9c: ba 92 20 00 orcc %o0, 0, %i5
40021fa0: 12 80 00 2f bne 4002205c <rtems_rfs_rtems_file_read+0x150><== NEVER TAKEN
40021fa4: 90 10 20 00 clr %o0
return read;
}
40021fa8: 81 c7 e0 08 ret
40021fac: 81 e8 00 00 restore
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
40021fb0: 08 bf ff f0 bleu 40021f70 <rtems_rfs_rtems_file_read+0x64>
40021fb4: 84 10 20 00 clr %g2
{
while (count)
40021fb8: 80 a6 a0 00 cmp %i2, 0
40021fbc: 02 bf ff ec be 40021f6c <rtems_rfs_rtems_file_read+0x60> <== NEVER TAKEN
40021fc0: b0 10 20 00 clr %i0
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
40021fc4: 10 80 00 16 b 4002201c <rtems_rfs_rtems_file_read+0x110>
40021fc8: 92 07 bf fc add %fp, -4, %o1
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
40021fcc: c4 04 20 0c ld [ %l0 + 0xc ], %g2
40021fd0: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
40021fd4: d2 00 a0 1c ld [ %g2 + 0x1c ], %o1
40021fd8: 90 10 00 19 mov %i1, %o0
40021fdc: 92 02 40 01 add %o1, %g1, %o1
40021fe0: 40 00 0b 5a call 40024d48 <memcpy>
40021fe4: 94 10 00 1b mov %i3, %o2
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
40021fe8: 90 10 00 10 mov %l0, %o0
40021fec: 92 10 00 1b mov %i3, %o1
40021ff0: 94 10 20 01 mov 1, %o2
40021ff4: 7f ff f7 1f call 4001fc70 <rtems_rfs_file_io_end>
40021ff8: b2 06 40 1b add %i1, %i3, %i1
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
count -= size;
read += size;
40021ffc: b0 06 c0 18 add %i3, %i0, %i0
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
40022000: 80 a2 20 00 cmp %o0, 0
40022004: 14 80 00 39 bg 400220e8 <rtems_rfs_rtems_file_read+0x1dc> <== NEVER TAKEN
40022008: a4 10 00 08 mov %o0, %l2
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
4002200c: 80 a6 a0 00 cmp %i2, 0
40022010: 02 80 00 21 be 40022094 <rtems_rfs_rtems_file_read+0x188>
40022014: 80 a6 20 00 cmp %i0, 0
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
40022018: 92 07 bf fc add %fp, -4, %o1
4002201c: 94 10 20 01 mov 1, %o2
40022020: 7f ff f6 83 call 4001fa2c <rtems_rfs_file_io_start>
40022024: 90 10 00 10 mov %l0, %o0
if (rc > 0)
40022028: b6 92 20 00 orcc %o0, 0, %i3
4002202c: 14 80 00 2b bg 400220d8 <rtems_rfs_rtems_file_read+0x1cc> <== NEVER TAKEN
40022030: 01 00 00 00 nop
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
40022034: f6 07 bf fc ld [ %fp + -4 ], %i3
40022038: 80 a6 e0 00 cmp %i3, 0
4002203c: 02 80 00 15 be 40022090 <rtems_rfs_rtems_file_read+0x184>
40022040: 80 a6 c0 1a cmp %i3, %i2
break;
if (size > count)
40022044: 28 bf ff e2 bleu,a 40021fcc <rtems_rfs_rtems_file_read+0xc0>
40022048: b4 26 80 1b sub %i2, %i3, %i2
size = count;
4002204c: b6 10 00 1a mov %i2, %i3
40022050: f4 27 bf fc st %i2, [ %fp + -4 ]
40022054: 10 bf ff de b 40021fcc <rtems_rfs_rtems_file_read+0xc0>
40022058: b4 10 20 00 clr %i2
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
4002205c: 7f ff cc 12 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40022060: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40022064: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40022068: 02 80 00 08 be 40022088 <rtems_rfs_rtems_file_read+0x17c> <== NOT EXECUTED
4002206c: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40022070: 7f ff da 68 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40022074: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40022078: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4002207c: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40022080: 40 00 0c 3f call 4002517c <printf> <== NOT EXECUTED
40022084: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
iop->offset = pos + read;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return read;
}
40022088: 81 c7 e0 08 ret <== NOT EXECUTED
4002208c: 81 e8 00 00 restore <== NOT EXECUTED
break;
}
}
}
if (read >= 0)
40022090: 80 a6 20 00 cmp %i0, 0
40022094: 06 bf ff bc bl 40021f84 <rtems_rfs_rtems_file_read+0x78> <== NEVER TAKEN
40022098: 86 10 00 18 mov %i0, %g3
4002209c: 10 bf ff b7 b 40021f78 <rtems_rfs_rtems_file_read+0x6c>
400220a0: 85 3e 20 1f sra %i0, 0x1f, %g2
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
400220a4: 7f ff cc 00 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
400220a8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400220ac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400220b0: 22 bf ff a5 be,a 40021f44 <rtems_rfs_rtems_file_read+0x38><== NOT EXECUTED
400220b4: d2 04 20 1c ld [ %l0 + 0x1c ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
400220b8: 7f ff da 56 call 40018a10 <rtems_status_text> <== NOT EXECUTED
400220bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400220c0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400220c4: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
400220c8: 40 00 0c 2d call 4002517c <printf> <== NOT EXECUTED
400220cc: 90 12 21 58 or %o0, 0x158, %o0 ! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
400220d0: 10 bf ff 9d b 40021f44 <rtems_rfs_rtems_file_read+0x38> <== NOT EXECUTED
400220d4: d2 04 20 1c ld [ %l0 + 0x1c ], %o1 <== NOT EXECUTED
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
if (rc > 0)
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
400220d8: 40 00 06 98 call 40023b38 <__errno> <== NOT EXECUTED
400220dc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400220e0: 10 bf ff a9 b 40021f84 <rtems_rfs_rtems_file_read+0x78> <== NOT EXECUTED
400220e4: f6 22 00 00 st %i3, [ %o0 ] <== NOT EXECUTED
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
400220e8: 40 00 06 94 call 40023b38 <__errno> <== NOT EXECUTED
400220ec: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400220f0: 10 bf ff a5 b 40021f84 <rtems_rfs_rtems_file_read+0x78> <== NOT EXECUTED
400220f4: e4 22 00 00 st %l2, [ %o0 ] <== NOT EXECUTED
400225e0 <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
400225e0: 9d e3 bf 90 save %sp, -112, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
400225e4: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
400225e8: 92 10 20 00 clr %o1
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
400225ec: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
400225f0: 94 10 20 00 clr %o2
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
400225f4: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
400225f8: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
400225fc: 7f ff ae 3b call 4000dee8 <rtems_semaphore_obtain>
40022600: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40022604: ba 92 20 00 orcc %o0, 0, %i5
40022608: 12 80 00 70 bne 400227c8 <rtems_rfs_rtems_file_write+0x1e8><== NEVER TAKEN
4002260c: 90 10 20 00 clr %o0
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
40022610: 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;
40022614: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
40022618: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
4002261c: c4 3f bf f8 std %g2, [ %fp + -8 ]
40022620: 7f ff e8 66 call 4001c7b8 <rtems_rfs_block_get_size>
40022624: 92 02 60 84 add %o1, 0x84, %o1
40022628: 86 10 00 09 mov %o1, %g3
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
4002262c: d2 07 bf f8 ld [ %fp + -8 ], %o1
40022630: 84 10 00 08 mov %o0, %g2
40022634: 80 a2 40 02 cmp %o1, %g2
40022638: 18 80 00 7b bgu 40022824 <rtems_rfs_rtems_file_write+0x244><== NEVER TAKEN
4002263c: d4 07 bf fc ld [ %fp + -4 ], %o2
40022640: 80 a2 40 02 cmp %o1, %g2
40022644: 02 80 00 8b be 40022870 <rtems_rfs_rtems_file_write+0x290><== ALWAYS TAKEN
40022648: 80 a2 80 03 cmp %o2, %g3
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
}
else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
4002264c: 80 a0 80 09 cmp %g2, %o1 <== NOT EXECUTED
40022650: 08 80 00 3b bleu 4002273c <rtems_rfs_rtems_file_write+0x15c><== ALWAYS TAKEN
40022654: 01 00 00 00 nop
40022658: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
4002265c: 80 88 62 00 btst 0x200, %g1
40022660: 32 80 00 8d bne,a 40022894 <rtems_rfs_rtems_file_write+0x2b4>
40022664: c4 3f bf f8 std %g2, [ %fp + -8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
40022668: a2 10 20 00 clr %l1
4002266c: 84 10 20 00 clr %g2
40022670: 80 a6 a0 00 cmp %i2, 0
40022674: 12 80 00 1b bne 400226e0 <rtems_rfs_rtems_file_write+0x100><== ALWAYS TAKEN
40022678: 86 10 20 00 clr %g3
}
if (write >= 0)
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4002267c: 10 80 00 3b b 40022768 <rtems_rfs_rtems_file_write+0x188> <== NOT EXECUTED
40022680: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
40022684: d4 07 bf f4 ld [ %fp + -12 ], %o2
40022688: 80 a2 80 1a cmp %o2, %i2
4002268c: 28 80 00 05 bleu,a 400226a0 <rtems_rfs_rtems_file_write+0xc0>
40022690: c4 04 20 0c ld [ %l0 + 0xc ], %g2
size = count;
40022694: f4 27 bf f4 st %i2, [ %fp + -12 ]
40022698: 94 10 00 1a mov %i2, %o2
memcpy (rtems_rfs_file_data (file), data, size);
4002269c: c4 04 20 0c ld [ %l0 + 0xc ], %g2
400226a0: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
400226a4: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
400226a8: 40 00 09 a8 call 40024d48 <memcpy>
400226ac: 90 02 00 01 add %o0, %g1, %o0
data += size;
400226b0: d2 07 bf f4 ld [ %fp + -12 ], %o1
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
400226b4: 90 10 00 10 mov %l0, %o0
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
count -= size;
400226b8: b4 26 80 09 sub %i2, %o1, %i2
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
400226bc: b2 06 40 09 add %i1, %o1, %i1
count -= size;
write += size;
400226c0: a2 04 40 09 add %l1, %o1, %l1
rc = rtems_rfs_file_io_end (file, size, false);
400226c4: 7f ff f5 6b call 4001fc70 <rtems_rfs_file_io_end>
400226c8: 94 10 20 00 clr %o2
if (rc)
400226cc: ba 92 20 00 orcc %o0, 0, %i5
400226d0: 12 80 00 0d bne 40022704 <rtems_rfs_rtems_file_write+0x124><== NEVER TAKEN
400226d4: 80 a6 a0 00 cmp %i2, 0
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
400226d8: 02 80 00 20 be 40022758 <rtems_rfs_rtems_file_write+0x178>
400226dc: 86 10 00 11 mov %l1, %g3
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
400226e0: 92 07 bf f4 add %fp, -12, %o1
}
}
while (count)
{
size_t size = count;
400226e4: f4 27 bf f4 st %i2, [ %fp + -12 ]
rc = rtems_rfs_file_io_start (file, &size, false);
400226e8: 94 10 20 00 clr %o2
400226ec: 7f ff f4 d0 call 4001fa2c <rtems_rfs_file_io_start>
400226f0: 90 10 00 10 mov %l0, %o0
}
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
400226f4: 92 10 00 19 mov %i1, %o1
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
if (rc)
400226f8: 80 a2 20 00 cmp %o0, 0
400226fc: 02 bf ff e2 be 40022684 <rtems_rfs_rtems_file_write+0xa4>
40022700: ba 10 00 08 mov %o0, %i5
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
if (rc)
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
40022704: 40 00 05 0d call 40023b38 <__errno>
40022708: a2 10 3f ff mov -1, %l1
4002270c: fa 22 00 00 st %i5, [ %o0 ]
}
if (write >= 0)
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
40022710: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40022714: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_buffers_release (fs);
40022718: 7f ff ed 8c call 4001dd48 <rtems_rfs_buffers_release>
4002271c: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40022720: 7f ff ae 41 call 4000e024 <rtems_semaphore_release>
40022724: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40022728: ba 92 20 00 orcc %o0, 0, %i5
4002272c: 12 80 00 1b bne 40022798 <rtems_rfs_rtems_file_write+0x1b8><== NEVER TAKEN
40022730: 90 10 20 00 clr %o0
return write;
}
40022734: 81 c7 e0 08 ret
40022738: 91 e8 00 11 restore %g0, %l1, %o0
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
}
else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
4002273c: 12 bf ff cc bne 4002266c <rtems_rfs_rtems_file_write+0x8c><== NEVER TAKEN
40022740: a2 10 20 00 clr %l1
40022744: 80 a0 c0 0a cmp %g3, %o2
40022748: 28 bf ff ca bleu,a 40022670 <rtems_rfs_rtems_file_write+0x90>
4002274c: 84 10 20 00 clr %g2
40022750: 10 bf ff c3 b 4002265c <rtems_rfs_rtems_file_write+0x7c>
40022754: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
if (write >= 0)
40022758: 80 a4 60 00 cmp %l1, 0
4002275c: 06 bf ff ed bl 40022710 <rtems_rfs_rtems_file_write+0x130><== NEVER TAKEN
40022760: 85 3c 60 1f sra %l1, 0x1f, %g2
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
40022764: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
break;
}
}
if (write >= 0)
iop->offset = pos + write;
40022768: f8 1f bf f8 ldd [ %fp + -8 ], %i4
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4002276c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
break;
}
}
if (write >= 0)
iop->offset = pos + write;
40022770: b6 80 c0 1d addcc %g3, %i5, %i3
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40022774: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
40022778: b4 40 80 1c addx %g2, %i4, %i2
rtems_rfs_buffers_release (fs);
4002277c: 7f ff ed 73 call 4001dd48 <rtems_rfs_buffers_release>
40022780: f4 3e 20 08 std %i2, [ %i0 + 8 ]
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40022784: 7f ff ae 28 call 4000e024 <rtems_semaphore_release>
40022788: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
4002278c: ba 92 20 00 orcc %o0, 0, %i5
40022790: 02 bf ff e9 be 40022734 <rtems_rfs_rtems_file_write+0x154><== ALWAYS TAKEN
40022794: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40022798: 7f ff ca 43 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4002279c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400227a0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400227a4: 02 bf ff e4 be 40022734 <rtems_rfs_rtems_file_write+0x154><== NOT EXECUTED
400227a8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
400227ac: 7f ff d8 99 call 40018a10 <rtems_status_text> <== NOT EXECUTED
400227b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400227b4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400227b8: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
400227bc: 40 00 0a 70 call 4002517c <printf> <== NOT EXECUTED
400227c0: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400227c4: 30 bf ff dc b,a 40022734 <rtems_rfs_rtems_file_write+0x154><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
400227c8: 7f ff ca 37 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
400227cc: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400227d0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400227d4: 22 bf ff 90 be,a 40022614 <rtems_rfs_rtems_file_write+0x34><== NOT EXECUTED
400227d8: d2 04 20 1c ld [ %l0 + 0x1c ], %o1 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
400227dc: 7f ff d8 8d call 40018a10 <rtems_status_text> <== NOT EXECUTED
400227e0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400227e4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400227e8: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
400227ec: 40 00 0a 64 call 4002517c <printf> <== NOT EXECUTED
400227f0: 90 12 21 58 or %o0, 0x158, %o0 ! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
400227f4: d2 04 20 1c ld [ %l0 + 0x1c ], %o1 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
400227f8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 <== NOT EXECUTED
400227fc: d0 02 60 98 ld [ %o1 + 0x98 ], %o0 <== NOT EXECUTED
40022800: c4 3f bf f8 std %g2, [ %fp + -8 ] <== NOT EXECUTED
40022804: 7f ff e7 ed call 4001c7b8 <rtems_rfs_block_get_size> <== NOT EXECUTED
40022808: 92 02 60 84 add %o1, 0x84, %o1 <== NOT EXECUTED
4002280c: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
40022810: d2 07 bf f8 ld [ %fp + -8 ], %o1 <== NOT EXECUTED
40022814: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
40022818: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED
4002281c: 08 bf ff 8a bleu 40022644 <rtems_rfs_rtems_file_write+0x64><== NOT EXECUTED
40022820: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
/*
* If the iop position is past the physical end of the file we need to set
* the file size to the new length before writing. The
* rtems_rfs_file_io_end() will grow the file subsequently.
*/
rc = rtems_rfs_file_set_size (file, pos);
40022824: 7f ff f6 10 call 40020064 <rtems_rfs_file_set_size>
40022828: 90 10 00 10 mov %l0, %o0
if (rc)
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
4002282c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
/*
* If the iop position is past the physical end of the file we need to set
* the file size to the new length before writing. The
* rtems_rfs_file_io_end() will grow the file subsequently.
*/
rc = rtems_rfs_file_set_size (file, pos);
40022830: ba 10 00 08 mov %o0, %i5
if (rc)
40022834: 80 a7 60 00 cmp %i5, 0
40022838: 02 80 00 11 be 4002287c <rtems_rfs_rtems_file_write+0x29c><== ALWAYS TAKEN
4002283c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
40022840: 7f ff ed 42 call 4001dd48 <rtems_rfs_buffers_release> <== NOT EXECUTED
40022844: f8 02 20 80 ld [ %o0 + 0x80 ], %i4 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40022848: 7f ff ad f7 call 4000e024 <rtems_semaphore_release> <== NOT EXECUTED
4002284c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40022850: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40022854: 12 80 00 1b bne 400228c0 <rtems_rfs_rtems_file_write+0x2e0><== NOT EXECUTED
40022858: 90 10 20 00 clr %o0 <== NOT EXECUTED
pos = file_size;
rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
4002285c: 40 00 04 b7 call 40023b38 <__errno> <== NOT EXECUTED
40022860: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED
40022864: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return write;
}
40022868: 81 c7 e0 08 ret <== NOT EXECUTED
4002286c: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
40022870: 08 bf ff 78 bleu 40022650 <rtems_rfs_rtems_file_write+0x70>
40022874: 80 a0 80 09 cmp %g2, %o1
40022878: 30 bf ff eb b,a 40022824 <rtems_rfs_rtems_file_write+0x244>
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
4002287c: d2 07 bf f8 ld [ %fp + -8 ], %o1
40022880: d4 07 bf fc ld [ %fp + -4 ], %o2
40022884: 7f ff e7 9e call 4001c6fc <rtems_rfs_block_get_bpos>
40022888: 96 04 20 10 add %l0, 0x10, %o3
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
4002288c: 10 bf ff 78 b 4002266c <rtems_rfs_rtems_file_write+0x8c>
40022890: a2 10 20 00 clr %l1
rtems_rfs_file_set_bpos (file, pos);
}
else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
{
pos = file_size;
rc = rtems_rfs_file_seek (file, pos, &pos);
40022894: 90 10 00 10 mov %l0, %o0
40022898: 92 10 00 02 mov %g2, %o1
4002289c: 94 10 00 03 mov %g3, %o2
400228a0: 7f ff f5 ae call 4001ff58 <rtems_rfs_file_seek>
400228a4: 96 07 bf f8 add %fp, -8, %o3
if (rc)
400228a8: ba 92 20 00 orcc %o0, 0, %i5
400228ac: 02 bf ff 70 be 4002266c <rtems_rfs_rtems_file_write+0x8c> <== ALWAYS TAKEN
400228b0: a2 10 20 00 clr %l1
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
400228b4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
400228b8: 10 bf ff e2 b 40022840 <rtems_rfs_rtems_file_write+0x260> <== NOT EXECUTED
400228bc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
400228c0: 7f ff c9 f9 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
400228c4: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
400228c8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400228cc: 02 bf ff e4 be 4002285c <rtems_rfs_rtems_file_write+0x27c><== NOT EXECUTED
400228d0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
400228d4: 7f ff d8 4f call 40018a10 <rtems_status_text> <== NOT EXECUTED
400228d8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
400228dc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
400228e0: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
400228e4: 40 00 0a 26 call 4002517c <printf> <== NOT EXECUTED
400228e8: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400228ec: 30 bf ff dc b,a 4002285c <rtems_rfs_rtems_file_write+0x27c><== NOT EXECUTED
40014744 <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
40014744: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40014748: 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);
4001474c: 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);
40014750: 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);
40014754: 94 07 bf d8 add %fp, -40, %o2
40014758: 90 10 00 1d mov %i5, %o0
4001475c: 7f ff fb ab call 40013608 <rtems_rfs_inode_open>
40014760: 96 10 20 01 mov 1, %o3
if (rc)
40014764: b8 92 20 00 orcc %o0, 0, %i4
40014768: 12 80 00 6f bne 40014924 <rtems_rfs_rtems_fstat+0x1e0> <== NEVER TAKEN
4001476c: c2 07 bf e4 ld [ %fp + -28 ], %g1
return rtems_rfs_rtems_error ("stat: opening inode", rc);
}
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
40014770: 09 3f ff ec sethi %hi(0xffffb000), %g4
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
40014774: c4 08 60 02 ldub [ %g1 + 2 ], %g2
40014778: d0 08 60 03 ldub [ %g1 + 3 ], %o0
4001477c: 85 28 a0 08 sll %g2, 8, %g2
40014780: 07 00 00 08 sethi %hi(0x2000), %g3
40014784: 88 08 80 04 and %g2, %g4, %g4
40014788: 80 a1 00 03 cmp %g4, %g3
4001478c: 02 80 00 4b be 400148b8 <rtems_rfs_rtems_fstat+0x174> <== NEVER TAKEN
40014790: 84 10 80 08 or %g2, %o0, %g2
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
40014794: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
40014798: 91 28 a0 10 sll %g2, 0x10, %o0
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
4001479c: 87 38 60 1f sra %g1, 0x1f, %g3
400147a0: c2 26 60 04 st %g1, [ %i1 + 4 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
400147a4: c2 07 bf e0 ld [ %fp + -32 ], %g1
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
400147a8: c6 26 40 00 st %g3, [ %i1 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
400147ac: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = rtems_rfs_rtems_mode (mode);
400147b0: 40 00 02 3b call 4001509c <rtems_rfs_rtems_mode>
400147b4: 91 32 20 10 srl %o0, 0x10, %o0
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
400147b8: c2 07 bf e4 ld [ %fp + -28 ], %g1
400147bc: d0 26 60 0c st %o0, [ %i1 + 0xc ]
400147c0: c6 08 60 01 ldub [ %g1 + 1 ], %g3
400147c4: c4 08 40 00 ldub [ %g1 ], %g2
if (links == 0xffff)
links = 0;
400147c8: 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);
400147cc: 85 28 a0 08 sll %g2, 8, %g2
400147d0: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
400147d4: 87 28 a0 10 sll %g2, 0x10, %g3
400147d8: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
400147dc: 86 39 00 03 xnor %g4, %g3, %g3
400147e0: 80 a0 00 03 cmp %g0, %g3
400147e4: 86 60 20 00 subx %g0, 0, %g3
400147e8: 84 08 80 03 and %g2, %g3, %g2
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
400147ec: 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;
400147f0: c4 08 60 06 ldub [ %g1 + 6 ], %g2
400147f4: c6 08 60 07 ldub [ %g1 + 7 ], %g3
400147f8: 85 28 a0 08 sll %g2, 8, %g2
400147fc: 84 10 80 03 or %g2, %g3, %g2
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
40014800: c4 36 60 12 sth %g2, [ %i1 + 0x12 ]
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
40014804: c4 08 60 04 ldub [ %g1 + 4 ], %g2
40014808: c2 08 60 05 ldub [ %g1 + 5 ], %g1
/*
* Need to check is the ino is an open file. If so we take the values from
* the open file rather than the inode.
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
4001480c: d2 07 bf e0 ld [ %fp + -32 ], %o1
40014810: 85 28 a0 18 sll %g2, 0x18, %g2
40014814: 83 28 60 10 sll %g1, 0x10, %g1
40014818: 82 10 80 01 or %g2, %g1, %g1
4001481c: 83 30 60 10 srl %g1, 0x10, %g1
40014820: 90 10 00 1d mov %i5, %o0
40014824: 40 00 2e ec call 400203d4 <rtems_rfs_file_get_shared>
40014828: c2 36 60 14 sth %g1, [ %i1 + 0x14 ]
if (shared)
4001482c: 92 92 20 00 orcc %o0, 0, %o1
40014830: 02 80 00 42 be 40014938 <rtems_rfs_rtems_fstat+0x1f4>
40014834: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
40014838: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
4001483c: f8 02 60 8c ld [ %o1 + 0x8c ], %i4
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
40014840: c8 02 60 90 ld [ %o1 + 0x90 ], %g4
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
40014844: c6 02 60 94 ld [ %o1 + 0x94 ], %g3
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
40014848: c4 06 60 0c ld [ %i1 + 0xc ], %g2
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
4001484c: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
40014850: f8 26 60 28 st %i4, [ %i1 + 0x28 ]
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
40014854: 03 00 00 3c sethi %hi(0xf000), %g1
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
40014858: c8 26 60 30 st %g4, [ %i1 + 0x30 ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
4001485c: 84 08 80 01 and %g2, %g1, %g2
40014860: 03 00 00 28 sethi %hi(0xa000), %g1
40014864: 80 a0 80 01 cmp %g2, %g1
40014868: 02 80 00 2b be 40014914 <rtems_rfs_rtems_fstat+0x1d0> <== NEVER TAKEN
4001486c: c6 26 60 38 st %g3, [ %i1 + 0x38 ]
*/
static inline rtems_rfs_pos
rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,
rtems_rfs_file_shared* shared)
{
return rtems_rfs_block_get_size (fs, &shared->size);
40014870: 90 10 00 1d mov %i5, %o0
40014874: 40 00 1f d1 call 4001c7b8 <rtems_rfs_block_get_size>
40014878: 92 02 60 84 add %o1, 0x84, %o1
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
4001487c: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
40014880: c2 07 60 08 ld [ %i5 + 8 ], %g1
rc = rtems_rfs_inode_close (fs, &inode);
40014884: 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);
40014888: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
rc = rtems_rfs_inode_close (fs, &inode);
4001488c: 92 07 bf d8 add %fp, -40, %o1
40014890: 7f ff fb d6 call 400137e8 <rtems_rfs_inode_close>
40014894: b0 10 20 00 clr %i0
if (rc > 0)
40014898: 80 a2 20 00 cmp %o0, 0
4001489c: 04 80 00 05 ble 400148b0 <rtems_rfs_rtems_fstat+0x16c> <== ALWAYS TAKEN
400148a0: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
400148a4: 40 00 3c a5 call 40023b38 <__errno> <== NOT EXECUTED
400148a8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400148ac: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
400148b0: 81 c7 e0 08 ret
400148b4: 81 e8 00 00 restore
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
400148b8: da 08 60 21 ldub [ %g1 + 0x21 ], %o5 <== NOT EXECUTED
400148bc: c8 08 60 20 ldub [ %g1 + 0x20 ], %g4 <== NOT EXECUTED
400148c0: de 08 60 23 ldub [ %g1 + 0x23 ], %o7 <== NOT EXECUTED
400148c4: f4 08 60 22 ldub [ %g1 + 0x22 ], %i2 <== NOT EXECUTED
400148c8: f6 08 60 1c ldub [ %g1 + 0x1c ], %i3 <== NOT EXECUTED
400148cc: f0 08 60 1d ldub [ %g1 + 0x1d ], %i0 <== NOT EXECUTED
400148d0: f8 08 60 1f ldub [ %g1 + 0x1f ], %i4 <== NOT EXECUTED
400148d4: c6 08 60 1e ldub [ %g1 + 0x1e ], %g3 <== NOT EXECUTED
400148d8: 83 2b 60 10 sll %o5, 0x10, %g1 <== NOT EXECUTED
400148dc: 89 29 20 18 sll %g4, 0x18, %g4 <== NOT EXECUTED
400148e0: b5 2e a0 08 sll %i2, 8, %i2 <== NOT EXECUTED
400148e4: 88 11 00 01 or %g4, %g1, %g4 <== NOT EXECUTED
400148e8: b7 2e e0 18 sll %i3, 0x18, %i3 <== NOT EXECUTED
400148ec: 88 11 00 0f or %g4, %o7, %g4 <== NOT EXECUTED
400148f0: 83 2e 20 10 sll %i0, 0x10, %g1 <== NOT EXECUTED
400148f4: 88 11 00 1a or %g4, %i2, %g4 <== NOT EXECUTED
400148f8: 82 16 c0 01 or %i3, %g1, %g1 <== NOT EXECUTED
400148fc: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
40014900: 82 10 40 1c or %g1, %i4, %g1 <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
{
buf->st_rdev =
40014904: c8 26 60 1c st %g4, [ %i1 + 0x1c ] <== NOT EXECUTED
40014908: 82 10 40 03 or %g1, %g3, %g1 <== NOT EXECUTED
4001490c: 10 bf ff a2 b 40014794 <rtems_rfs_rtems_fstat+0x50> <== NOT EXECUTED
40014910: c2 26 60 18 st %g1, [ %i1 + 0x18 ] <== NOT EXECUTED
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
40014914: c2 12 60 8a lduh [ %o1 + 0x8a ], %g1 <== NOT EXECUTED
40014918: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
4001491c: 10 bf ff d9 b 40014880 <rtems_rfs_rtems_fstat+0x13c> <== NOT EXECUTED
40014920: c2 26 60 24 st %g1, [ %i1 + 0x24 ] <== NOT EXECUTED
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
return rtems_rfs_rtems_error ("stat: opening inode", rc);
40014924: 40 00 3c 85 call 40023b38 <__errno> <== NOT EXECUTED
40014928: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001492c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40014930: 81 c7 e0 08 ret <== NOT EXECUTED
40014934: 81 e8 00 00 restore <== NOT EXECUTED
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
40014938: c6 06 60 0c ld [ %i1 + 0xc ], %g3
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
4001493c: f8 08 60 13 ldub [ %g1 + 0x13 ], %i4
40014940: c4 08 60 10 ldub [ %g1 + 0x10 ], %g2
40014944: f6 08 60 11 ldub [ %g1 + 0x11 ], %i3
40014948: c8 08 60 12 ldub [ %g1 + 0x12 ], %g4
4001494c: b7 2e e0 10 sll %i3, 0x10, %i3
40014950: 89 29 20 08 sll %g4, 8, %g4
40014954: 85 28 a0 18 sll %g2, 0x18, %g2
40014958: 84 10 80 1b or %g2, %i3, %g2
4001495c: 84 10 80 1c or %g2, %i4, %g2
40014960: 84 10 80 04 or %g2, %g4, %g2
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
}
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
40014964: 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);
40014968: f8 08 60 17 ldub [ %g1 + 0x17 ], %i4
4001496c: c4 08 60 14 ldub [ %g1 + 0x14 ], %g2
40014970: f6 08 60 15 ldub [ %g1 + 0x15 ], %i3
40014974: c8 08 60 16 ldub [ %g1 + 0x16 ], %g4
40014978: b7 2e e0 10 sll %i3, 0x10, %i3
4001497c: 89 29 20 08 sll %g4, 8, %g4
40014980: 85 28 a0 18 sll %g2, 0x18, %g2
40014984: 84 10 80 1b or %g2, %i3, %g2
40014988: 84 10 80 1c or %g2, %i4, %g2
4001498c: 84 10 80 04 or %g2, %g4, %g2
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
40014990: 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);
40014994: f8 08 60 1b ldub [ %g1 + 0x1b ], %i4
40014998: c4 08 60 18 ldub [ %g1 + 0x18 ], %g2
4001499c: f6 08 60 19 ldub [ %g1 + 0x19 ], %i3
400149a0: c8 08 60 1a ldub [ %g1 + 0x1a ], %g4
400149a4: b7 2e e0 10 sll %i3, 0x10, %i3
400149a8: 89 29 20 08 sll %g4, 8, %g4
400149ac: 85 28 a0 18 sll %g2, 0x18, %g2
400149b0: 84 10 80 1b or %g2, %i3, %g2
400149b4: 84 10 80 1c or %g2, %i4, %g2
400149b8: 84 10 80 04 or %g2, %g4, %g2
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
400149bc: 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);
400149c0: c4 08 60 0c ldub [ %g1 + 0xc ], %g2
400149c4: f6 08 60 0d ldub [ %g1 + 0xd ], %i3
400149c8: f8 08 60 0f ldub [ %g1 + 0xf ], %i4
400149cc: c8 08 60 0e ldub [ %g1 + 0xe ], %g4
400149d0: 85 28 a0 18 sll %g2, 0x18, %g2
400149d4: b7 2e e0 10 sll %i3, 0x10, %i3
400149d8: 89 29 20 08 sll %g4, 8, %g4
400149dc: 84 10 80 1b or %g2, %i3, %g2
400149e0: 84 10 80 1c or %g2, %i4, %g2
400149e4: 84 10 80 04 or %g2, %g4, %g2
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
400149e8: c4 26 60 44 st %g2, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
400149ec: 05 00 00 3c sethi %hi(0xf000), %g2
400149f0: 86 08 c0 02 and %g3, %g2, %g3
400149f4: 05 00 00 28 sethi %hi(0xa000), %g2
400149f8: 80 a0 c0 02 cmp %g3, %g2
400149fc: 12 80 00 09 bne 40014a20 <rtems_rfs_rtems_fstat+0x2dc>
40014a00: 90 10 00 1d mov %i5, %o0
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
40014a04: c4 08 60 0b ldub [ %g1 + 0xb ], %g2
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
40014a08: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
40014a0c: c0 26 60 20 clr [ %i1 + 0x20 ]
40014a10: 83 28 e0 08 sll %g3, 8, %g1
40014a14: 82 10 80 01 or %g2, %g1, %g1
40014a18: 10 bf ff 9a b 40014880 <rtems_rfs_rtems_fstat+0x13c>
40014a1c: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
40014a20: 7f ff fd 2c call 40013ed0 <rtems_rfs_inode_get_size>
40014a24: 92 07 bf d8 add %fp, -40, %o1
40014a28: 10 bf ff 96 b 40014880 <rtems_rfs_rtems_fstat+0x13c>
40014a2c: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
40014c9c <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
40014c9c: 9d e3 bf 98 save %sp, -104, %sp
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
40014ca0: a2 10 20 05 mov 5, %l1
40014ca4: 80 a6 60 00 cmp %i1, 0
40014ca8: 02 80 00 1f be 40014d24 <rtems_rfs_rtems_initialise+0x88> <== ALWAYS TAKEN
40014cac: ba 10 20 00 clr %i5
{
printf ("options=%s\n", options);
40014cb0: 37 10 00 dc sethi %hi(0x40037000), %i3 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40014cb4: 39 10 00 dc sethi %hi(0x40037000), %i4 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
40014cb8: 35 10 00 dc sethi %hi(0x40037000), %i2 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
40014cbc: 21 10 00 dc sethi %hi(0x40037000), %l0 <== NOT EXECUTED
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
40014cc0: b6 16 e1 18 or %i3, 0x118, %i3 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40014cc4: b8 17 21 28 or %i4, 0x128, %i4 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
40014cc8: b4 16 a1 38 or %i2, 0x138, %i2 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
40014ccc: a0 14 21 48 or %l0, 0x148, %l0 <== NOT EXECUTED
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
40014cd0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40014cd4: 40 00 41 2a call 4002517c <printf> <== NOT EXECUTED
40014cd8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
40014cdc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40014ce0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40014ce4: 40 00 45 c9 call 40026408 <strncmp> <== NOT EXECUTED
40014ce8: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
40014cec: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40014cf0: 12 80 00 1e bne 40014d68 <rtems_rfs_rtems_initialise+0xcc><== NOT EXECUTED
40014cf4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
40014cf8: ba 17 60 01 or %i5, 1, %i5 <== NOT EXECUTED
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
options = strchr (options, ',');
40014cfc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40014d00: 40 00 43 48 call 40025a20 <strchr> <== NOT EXECUTED
40014d04: 92 10 20 2c mov 0x2c, %o1 <== NOT EXECUTED
if (options)
40014d08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40014d0c: 02 80 00 06 be 40014d24 <rtems_rfs_rtems_initialise+0x88> <== NOT EXECUTED
40014d10: 01 00 00 00 nop <== NOT EXECUTED
{
++options;
if (*options == '\0')
40014d14: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
40014d18: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40014d1c: 12 80 00 1b bne 40014d88 <rtems_rfs_rtems_initialise+0xec><== NOT EXECUTED
40014d20: b2 82 20 01 addcc %o0, 1, %i1 <== NOT EXECUTED
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
40014d24: 7f ff d2 9e call 4000979c <malloc>
40014d28: 90 10 20 04 mov 4, %o0
if (!rtems)
40014d2c: b8 92 20 00 orcc %o0, 0, %i4
40014d30: 02 80 00 75 be 40014f04 <rtems_rfs_rtems_initialise+0x268><== NEVER TAKEN
40014d34: 01 00 00 00 nop
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
rc = rtems_rfs_mutex_create (&rtems->access);
40014d38: 40 00 32 a5 call 400217cc <rtems_rfs_mutex_create>
40014d3c: c0 27 00 00 clr [ %i4 ]
if (rc > 0)
40014d40: b6 92 20 00 orcc %o0, 0, %i3
40014d44: 24 80 00 1f ble,a 40014dc0 <rtems_rfs_rtems_initialise+0x124><== ALWAYS TAKEN
40014d48: d0 07 00 00 ld [ %i4 ], %o0
{
free (rtems);
40014d4c: 7f ff d0 f7 call 40009128 <free> <== NOT EXECUTED
40014d50: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
40014d54: 40 00 3b 79 call 40023b38 <__errno> <== NOT EXECUTED
40014d58: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014d5c: f6 22 00 00 st %i3, [ %o0 ] <== NOT EXECUTED
40014d60: 81 c7 e0 08 ret <== NOT EXECUTED
40014d64: 81 e8 00 00 restore <== NOT EXECUTED
{
printf ("options=%s\n", options);
if (strncmp (options, "hold-bitmaps",
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
40014d68: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40014d6c: 40 00 45 a7 call 40026408 <strncmp> <== NOT EXECUTED
40014d70: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
40014d74: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40014d78: 12 80 00 07 bne 40014d94 <rtems_rfs_rtems_initialise+0xf8><== NOT EXECUTED
40014d7c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
40014d80: 10 bf ff df b 40014cfc <rtems_rfs_rtems_initialise+0x60> <== NOT EXECUTED
40014d84: ba 17 60 02 or %i5, 2, %i5 <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
40014d88: 12 bf ff d3 bne 40014cd4 <rtems_rfs_rtems_initialise+0x38><== NOT EXECUTED
40014d8c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40014d90: 30 bf ff e5 b,a 40014d24 <rtems_rfs_rtems_initialise+0x88><== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
40014d94: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40014d98: 40 00 45 9c call 40026408 <strncmp> <== NOT EXECUTED
40014d9c: 94 10 20 0d mov 0xd, %o2 <== NOT EXECUTED
40014da0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40014da4: 12 80 00 2c bne 40014e54 <rtems_rfs_rtems_initialise+0x1b8><== NOT EXECUTED
40014da8: 90 06 60 0e add %i1, 0xe, %o0 <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
40014dac: 92 10 20 00 clr %o1 <== NOT EXECUTED
40014db0: 40 00 46 75 call 40026784 <strtoul> <== NOT EXECUTED
40014db4: 94 10 20 00 clr %o2 <== NOT EXECUTED
40014db8: 10 bf ff d1 b 40014cfc <rtems_rfs_rtems_initialise+0x60> <== NOT EXECUTED
40014dbc: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40014dc0: 92 10 20 00 clr %o1
40014dc4: 7f ff e4 49 call 4000dee8 <rtems_semaphore_obtain>
40014dc8: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
40014dcc: b6 92 20 00 orcc %o0, 0, %i3
40014dd0: 12 80 00 11 bne 40014e14 <rtems_rfs_rtems_initialise+0x178><== NEVER TAKEN
40014dd4: 94 10 00 1d mov %i5, %o2
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
40014dd8: d0 06 20 38 ld [ %i0 + 0x38 ], %o0
40014ddc: 92 10 00 1c mov %i4, %o1
40014de0: 96 10 00 11 mov %l1, %o3
40014de4: 40 00 2d a1 call 40020468 <rtems_rfs_fs_open>
40014de8: 98 07 bf fc add %fp, -4, %o4
if (rc)
40014dec: ba 92 20 00 orcc %o0, 0, %i5
40014df0: 02 80 00 1f be 40014e6c <rtems_rfs_rtems_initialise+0x1d0><== ALWAYS TAKEN
40014df4: d0 07 bf fc ld [ %fp + -4 ], %o0
{
free (rtems);
40014df8: 7f ff d0 cc call 40009128 <free> <== NOT EXECUTED
40014dfc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
40014e00: 40 00 3b 4e call 40023b38 <__errno> <== NOT EXECUTED
40014e04: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014e08: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
40014e0c: 81 c7 e0 08 ret <== NOT EXECUTED
40014e10: 81 e8 00 00 restore <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40014e14: 90 10 20 00 clr %o0 <== NOT EXECUTED
40014e18: 40 00 00 a3 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40014e1c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40014e20: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40014e24: 12 80 00 25 bne 40014eb8 <rtems_rfs_rtems_initialise+0x21c><== NOT EXECUTED
40014e28: 01 00 00 00 nop <== NOT EXECUTED
}
rc = rtems_rfs_mutex_lock (&rtems->access);
if (rc > 0)
{
rtems_rfs_mutex_destroy (&rtems->access);
40014e2c: 40 00 32 83 call 40021838 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
40014e30: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
free (rtems);
40014e34: 7f ff d0 bd call 40009128 <free> <== NOT EXECUTED
40014e38: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
40014e3c: 40 00 3b 3f call 40023b38 <__errno> <== NOT EXECUTED
40014e40: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014e44: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40014e48: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
rtems_rfs_rtems_unlock (fs);
return 0;
}
40014e4c: 81 c7 e0 08 ret <== NOT EXECUTED
40014e50: 81 e8 00 00 restore <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
40014e54: 40 00 3b 39 call 40023b38 <__errno> <== NOT EXECUTED
40014e58: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014e5c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40014e60: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40014e64: 81 c7 e0 08 ret <== NOT EXECUTED
40014e68: 81 e8 00 00 restore <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
mt_entry->ops = &rtems_rfs_ops;
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
40014e6c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
mt_entry->ops = &rtems_rfs_ops;
40014e70: 05 10 00 dc sethi %hi(0x40037000), %g2
40014e74: 84 10 a1 80 or %g2, 0x180, %g2 ! 40037180 <rtems_rfs_ops>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40014e78: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
40014e7c: d0 26 20 08 st %o0, [ %i0 + 8 ]
mt_entry->ops = &rtems_rfs_ops;
40014e80: c4 26 20 0c st %g2, [ %i0 + 0xc ]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
40014e84: 84 10 20 01 mov 1, %g2
40014e88: c4 20 60 08 st %g2, [ %g1 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
40014e8c: 05 10 00 e5 sethi %hi(0x40039400), %g2
40014e90: 84 10 a0 c8 or %g2, 0xc8, %g2 ! 400394c8 <rtems_rfs_rtems_dir_handlers>
rtems_rfs_buffers_release (fs);
40014e94: 40 00 23 ad call 4001dd48 <rtems_rfs_buffers_release>
40014e98: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40014e9c: 7f ff e4 62 call 4000e024 <rtems_semaphore_release>
40014ea0: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40014ea4: ba 92 20 00 orcc %o0, 0, %i5
40014ea8: 12 80 00 0b bne 40014ed4 <rtems_rfs_rtems_initialise+0x238><== NEVER TAKEN
40014eac: 90 10 20 00 clr %o0
rtems_rfs_rtems_unlock (fs);
return 0;
40014eb0: 81 c7 e0 08 ret
40014eb4: 91 e8 20 00 restore %g0, 0, %o0
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40014eb8: 40 00 0e d6 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40014ebc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40014ec0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40014ec4: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40014ec8: 40 00 40 ad call 4002517c <printf> <== NOT EXECUTED
40014ecc: 90 12 21 58 or %o0, 0x158, %o0 ! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
40014ed0: 30 bf ff d7 b,a 40014e2c <rtems_rfs_rtems_initialise+0x190><== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40014ed4: 40 00 00 74 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40014ed8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40014edc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40014ee0: 02 bf ff f4 be 40014eb0 <rtems_rfs_rtems_initialise+0x214><== NOT EXECUTED
40014ee4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40014ee8: 40 00 0e ca call 40018a10 <rtems_status_text> <== NOT EXECUTED
40014eec: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40014ef0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40014ef4: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40014ef8: 40 00 40 a1 call 4002517c <printf> <== NOT EXECUTED
40014efc: 90 12 20 f0 or %o0, 0xf0, %o0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40014f00: 30 bf ff ec b,a 40014eb0 <rtems_rfs_rtems_initialise+0x214><== NOT EXECUTED
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
if (!rtems)
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
40014f04: 40 00 3b 0d call 40023b38 <__errno> <== NOT EXECUTED
40014f08: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014f0c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40014f10: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40014f14: 81 c7 e0 08 ret <== NOT EXECUTED
40014f18: 81 e8 00 00 restore <== NOT EXECUTED
40014048 <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)
{
40014048: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
4001404c: 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);
40014050: d6 06 20 08 ld [ %i0 + 8 ], %o3
40014054: d0 00 60 08 ld [ %g1 + 8 ], %o0
40014058: d8 06 60 08 ld [ %i1 + 8 ], %o4
4001405c: 92 10 00 1a mov %i2, %o1
40014060: 94 10 00 1b mov %i3, %o2
40014064: 9a 10 20 00 clr %o5
40014068: 40 00 33 4c call 40020d98 <rtems_rfs_link>
4001406c: b0 10 20 00 clr %i0
if (rc)
40014070: 80 a2 20 00 cmp %o0, 0
40014074: 02 80 00 05 be 40014088 <rtems_rfs_rtems_link+0x40> <== ALWAYS TAKEN
40014078: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("link: linking", rc);
4001407c: 40 00 3e af call 40023b38 <__errno> <== NOT EXECUTED
40014080: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014084: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40014088: 81 c7 e0 08 ret
4001408c: 81 e8 00 00 restore
40014f1c <rtems_rfs_rtems_lock_by_mt_entry>:
static void
rtems_rfs_rtems_lock_by_mt_entry (
const rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40014f1c: 9d e3 bf a0 save %sp, -96, %sp
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
40014f20: c2 06 20 08 ld [ %i0 + 8 ], %g1
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
40014f24: 92 10 20 00 clr %o1
/* FIXME: Return value? */
rtems_rfs_fs_close(fs);
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
}
40014f28: c2 00 60 80 ld [ %g1 + 0x80 ], %g1
40014f2c: 94 10 20 00 clr %o2
40014f30: 7f ff e3 ee call 4000dee8 <rtems_semaphore_obtain>
40014f34: d0 00 40 00 ld [ %g1 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40014f38: ba 92 20 00 orcc %o0, 0, %i5
40014f3c: 12 80 00 04 bne 40014f4c <rtems_rfs_rtems_lock_by_mt_entry+0x30><== NEVER TAKEN
40014f40: 90 10 20 00 clr %o0
40014f44: 81 c7 e0 08 ret
40014f48: 81 e8 00 00 restore
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40014f4c: 40 00 00 56 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40014f50: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40014f54: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40014f58: 02 bf ff fb be 40014f44 <rtems_rfs_rtems_lock_by_mt_entry+0x28><== NOT EXECUTED
40014f5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
40014f60: 40 00 0e ac call 40018a10 <rtems_status_text> <== NOT EXECUTED
40014f64: 31 10 00 dc sethi %hi(0x40037000), %i0 <== NOT EXECUTED
40014f68: b0 16 21 58 or %i0, 0x158, %i0 ! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
40014f6c: 40 00 40 84 call 4002517c <printf> <== NOT EXECUTED
40014f70: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
4001451c <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)
{
4001451c: 9d e3 bf 60 save %sp, -160, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
40014520: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
40014524: e0 06 20 08 ld [ %i0 + 8 ], %l0
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
40014528: 40 00 12 0f call 40018d64 <geteuid>
4001452c: f0 00 60 08 ld [ %g1 + 8 ], %i0
gid = getegid ();
40014530: 40 00 12 09 call 40018d54 <getegid>
40014534: a2 10 00 08 mov %o0, %l1
40014538: a4 10 00 08 mov %o0, %l2
#else
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
4001453c: 40 00 02 d5 call 40015090 <rtems_rfs_rtems_imode>
40014540: 90 10 00 1b mov %i3, %o0
40014544: 82 07 bf d4 add %fp, -44, %g1
40014548: 99 2a 20 10 sll %o0, 0x10, %o4
4001454c: 96 10 00 1a mov %i2, %o3
40014550: a3 2c 60 10 sll %l1, 0x10, %l1
40014554: a5 2c a0 10 sll %l2, 0x10, %l2
40014558: a3 34 60 10 srl %l1, 0x10, %l1
4001455c: a5 34 a0 10 srl %l2, 0x10, %l2
40014560: e2 23 a0 5c st %l1, [ %sp + 0x5c ]
40014564: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
40014568: 90 10 00 18 mov %i0, %o0
4001456c: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
40014570: 92 10 00 10 mov %l0, %o1
40014574: 94 10 00 19 mov %i1, %o2
40014578: 99 33 20 10 srl %o4, 0x10, %o4
4001457c: 7f ff fd 75 call 40013b50 <rtems_rfs_inode_create>
40014580: 9a 10 20 01 mov 1, %o5
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
40014584: b4 92 20 00 orcc %o0, 0, %i2
40014588: 04 80 00 07 ble 400145a4 <rtems_rfs_rtems_mknod+0x88>
4001458c: d2 07 bf d4 ld [ %fp + -44 ], %o1
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc > 0)
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
40014590: 40 00 3d 6a call 40023b38 <__errno>
40014594: b0 10 3f ff mov -1, %i0
40014598: f4 22 00 00 st %i2, [ %o0 ]
4001459c: 81 c7 e0 08 ret
400145a0: 81 e8 00 00 restore
if (rc > 0)
{
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
400145a4: 90 10 00 18 mov %i0, %o0
400145a8: 94 07 bf d8 add %fp, -40, %o2
400145ac: 7f ff fc 17 call 40013608 <rtems_rfs_inode_open>
400145b0: 96 10 20 01 mov 1, %o3
if (rc > 0)
400145b4: b4 92 20 00 orcc %o0, 0, %i2
400145b8: 14 bf ff f6 bg 40014590 <rtems_rfs_rtems_mknod+0x74> <== NEVER TAKEN
400145bc: 03 00 00 3c sethi %hi(0xf000), %g1
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
}
if (S_ISDIR(mode) || S_ISREG(mode))
400145c0: 05 00 00 20 sethi %hi(0x8000), %g2
400145c4: 82 0e c0 01 and %i3, %g1, %g1
400145c8: 80 a0 40 02 cmp %g1, %g2
400145cc: 02 80 00 1a be 40014634 <rtems_rfs_rtems_mknod+0x118>
400145d0: 05 00 00 10 sethi %hi(0x4000), %g2
400145d4: 80 a0 40 02 cmp %g1, %g2
400145d8: 02 80 00 17 be 40014634 <rtems_rfs_rtems_mknod+0x118> <== ALWAYS TAKEN
400145dc: 03 00 00 2c sethi %hi(0xb000), %g1
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
400145e0: b6 0e c0 01 and %i3, %g1, %i3 <== NOT EXECUTED
400145e4: 03 00 00 08 sethi %hi(0x2000), %g1 <== NOT EXECUTED
400145e8: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
400145ec: 12 80 00 1e bne 40014664 <rtems_rfs_rtems_mknod+0x148> <== NOT EXECUTED
400145f0: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
400145f4: b3 37 20 18 srl %i4, 0x18, %i1 <== NOT EXECUTED
400145f8: b5 37 20 10 srl %i4, 0x10, %i2 <== NOT EXECUTED
400145fc: b7 37 20 08 srl %i4, 8, %i3 <== NOT EXECUTED
40014600: 89 37 60 18 srl %i5, 0x18, %g4 <== NOT EXECUTED
40014604: 87 37 60 10 srl %i5, 0x10, %g3 <== NOT EXECUTED
40014608: 85 37 60 08 srl %i5, 8, %g2 <== NOT EXECUTED
4001460c: f8 28 60 1f stb %i4, [ %g1 + 0x1f ] <== NOT EXECUTED
40014610: f2 28 60 1c stb %i1, [ %g1 + 0x1c ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40014614: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
40014618: f4 28 60 1d stb %i2, [ %g1 + 0x1d ] <== NOT EXECUTED
4001461c: f6 28 60 1e stb %i3, [ %g1 + 0x1e ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40014620: f8 2f bf e8 stb %i4, [ %fp + -24 ] <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
40014624: c8 28 60 20 stb %g4, [ %g1 + 0x20 ] <== NOT EXECUTED
40014628: c6 28 60 21 stb %g3, [ %g1 + 0x21 ] <== NOT EXECUTED
4001462c: c4 28 60 22 stb %g2, [ %g1 + 0x22 ] <== NOT EXECUTED
40014630: fa 28 60 23 stb %i5, [ %g1 + 0x23 ] <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
}
rc = rtems_rfs_inode_close (fs, &inode);
40014634: 90 10 00 18 mov %i0, %o0
40014638: 92 07 bf d8 add %fp, -40, %o1
4001463c: 7f ff fc 6b call 400137e8 <rtems_rfs_inode_close>
40014640: b0 10 20 00 clr %i0
if (rc > 0)
40014644: 80 a2 20 00 cmp %o0, 0
40014648: 04 bf ff d5 ble 4001459c <rtems_rfs_rtems_mknod+0x80> <== ALWAYS TAKEN
4001464c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
40014650: 40 00 3d 3a call 40023b38 <__errno> <== NOT EXECUTED
40014654: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014658: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
4001465c: 81 c7 e0 08 ret <== NOT EXECUTED
40014660: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 0, major);
rtems_rfs_inode_set_block (&inode, 1, minor);
}
else
{
rtems_rfs_inode_close (fs, &inode);
40014664: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40014668: 7f ff fc 60 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
4001466c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
40014670: 40 00 3d 32 call 40023b38 <__errno> <== NOT EXECUTED
40014674: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014678: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4001467c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40014680: 81 c7 e0 08 ret <== NOT EXECUTED
40014684: 81 e8 00 00 restore <== NOT EXECUTED
400144b0 <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)
{
400144b0: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
400144b4: 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);
400144b8: 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);
400144bc: f8 00 60 08 ld [ %g1 + 8 ], %i4
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_filesystem_node_types_t type;
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
400144c0: 94 07 bf d8 add %fp, -40, %o2
400144c4: 90 10 00 1c mov %i4, %o0
400144c8: 7f ff fc 50 call 40013608 <rtems_rfs_inode_open>
400144cc: 96 10 20 01 mov 1, %o3
if (rc > 0)
400144d0: ba 92 20 00 orcc %o0, 0, %i5
400144d4: 04 80 00 07 ble 400144f0 <rtems_rfs_rtems_node_type+0x40> <== ALWAYS TAKEN
400144d8: 01 00 00 00 nop
type = rtems_rfs_rtems_node_type_by_inode (&inode);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
400144dc: 40 00 3d 97 call 40023b38 <__errno> <== NOT EXECUTED
400144e0: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
400144e4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return type;
}
400144e8: 81 c7 e0 08 ret <== NOT EXECUTED
400144ec: 81 e8 00 00 restore <== NOT EXECUTED
if (rc > 0)
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
}
type = rtems_rfs_rtems_node_type_by_inode (&inode);
400144f0: 7f ff fe 90 call 40013f30 <rtems_rfs_rtems_node_type_by_inode>
400144f4: 90 07 bf d8 add %fp, -40, %o0
rc = rtems_rfs_inode_close (fs, &inode);
400144f8: 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);
400144fc: b0 10 00 08 mov %o0, %i0
rc = rtems_rfs_inode_close (fs, &inode);
40014500: 7f ff fc ba call 400137e8 <rtems_rfs_inode_close>
40014504: 90 10 00 1c mov %i4, %o0
if (rc > 0)
40014508: ba 92 20 00 orcc %o0, 0, %i5
4001450c: 14 bf ff f4 bg 400144dc <rtems_rfs_rtems_node_type+0x2c> <== NEVER TAKEN
40014510: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
}
return type;
}
40014514: 81 c7 e0 08 ret
40014518: 81 e8 00 00 restore
40014160 <rtems_rfs_rtems_readlink>:
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
40014160: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40014164: 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);
40014168: d2 06 20 08 ld [ %i0 + 8 ], %o1
4001416c: d0 00 60 08 ld [ %g1 + 8 ], %o0
40014170: 94 10 00 19 mov %i1, %o2
40014174: 96 10 00 1a mov %i2, %o3
40014178: 40 00 35 23 call 40021604 <rtems_rfs_symlink_read>
4001417c: 98 07 bf fc add %fp, -4, %o4
if (rc)
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
return (ssize_t) length;
40014180: 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)
40014184: 80 a2 20 00 cmp %o0, 0
40014188: 02 80 00 05 be 4001419c <rtems_rfs_rtems_readlink+0x3c> <== ALWAYS TAKEN
4001418c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
40014190: 40 00 3e 6a call 40023b38 <__errno> <== NOT EXECUTED
40014194: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014198: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return (ssize_t) length;
}
4001419c: 81 c7 e0 08 ret
400141a0: 81 e8 00 00 restore
40014090 <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)
{
40014090: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
40014094: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 <== NOT EXECUTED
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
40014098: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
const rtems_filesystem_location_info_t* old_loc,
const rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name,
size_t new_name_len)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
4001409c: e0 00 60 08 ld [ %g1 + 8 ], %l0 <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, new_name_len, new_parent, ino, true);
400140a0: d6 06 a0 08 ld [ %i2 + 8 ], %o3 <== NOT EXECUTED
400140a4: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
rtems_rfs_ino new_parent;
rtems_rfs_ino ino;
uint32_t doff;
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
400140a8: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
doff = rtems_rfs_rtems_get_pathloc_doff (old_loc);
400140ac: f4 06 60 0c ld [ %i1 + 0xc ], %i2 <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, new_name_len, new_parent, ino, true);
400140b0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
400140b4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400140b8: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
400140bc: 40 00 33 37 call 40020d98 <rtems_rfs_link> <== NOT EXECUTED
400140c0: 9a 10 20 01 mov 1, %o5 <== NOT EXECUTED
if (rc)
400140c4: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
400140c8: 02 80 00 07 be 400140e4 <rtems_rfs_rtems_rename+0x54> <== NOT EXECUTED
400140cc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: linking", rc);
400140d0: 40 00 3e 9a call 40023b38 <__errno> <== NOT EXECUTED
400140d4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400140d8: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
400140dc: 81 c7 e0 08 ret <== NOT EXECUTED
400140e0: 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,
400140e4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400140e8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
400140ec: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
400140f0: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
400140f4: 40 00 33 9d call 40020f68 <rtems_rfs_unlink> <== NOT EXECUTED
400140f8: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
400140fc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40014100: 02 bf ff f7 be 400140dc <rtems_rfs_rtems_rename+0x4c> <== NOT EXECUTED
40014104: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
40014108: 40 00 3e 8c call 40023b38 <__errno> <== NOT EXECUTED
4001410c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014110: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40014114: 81 c7 e0 08 ret <== NOT EXECUTED
40014118: 81 e8 00 00 restore <== NOT EXECUTED
40014fa8 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
40014fa8: 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);
40014fac: c4 06 60 0c ld [ %i1 + 0xc ], %g2
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
40014fb0: 07 00 00 10 sethi %hi(0x4000), %g3
40014fb4: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
40014fb8: c4 08 a0 03 ldub [ %g2 + 3 ], %g2
40014fbc: 83 28 60 08 sll %g1, 8, %g1
40014fc0: 82 10 40 02 or %g1, %g2, %g1
40014fc4: 05 00 00 3c sethi %hi(0xf000), %g2
40014fc8: 84 08 40 02 and %g1, %g2, %g2
40014fcc: 80 a0 80 03 cmp %g2, %g3
40014fd0: 02 80 00 1d be 40015044 <rtems_rfs_rtems_set_handlers+0x9c>
40014fd4: c0 26 20 10 clr [ %i0 + 0x10 ]
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
40014fd8: 09 00 00 2c sethi %hi(0xb000), %g4
40014fdc: 07 00 00 08 sethi %hi(0x2000), %g3
40014fe0: 88 08 40 04 and %g1, %g4, %g4
40014fe4: 80 a1 00 03 cmp %g4, %g3
40014fe8: 02 80 00 10 be 40015028 <rtems_rfs_rtems_set_handlers+0x80><== NEVER TAKEN
40014fec: 07 00 00 28 sethi %hi(0xa000), %g3
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
40014ff0: 80 a0 80 03 cmp %g2, %g3
40014ff4: 02 80 00 22 be 4001507c <rtems_rfs_rtems_set_handlers+0xd4>
40014ff8: 07 00 00 20 sethi %hi(0x8000), %g3
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
40014ffc: 80 a0 80 03 cmp %g2, %g3
40015000: 02 80 00 18 be 40015060 <rtems_rfs_rtems_set_handlers+0xb8><== ALWAYS TAKEN
40015004: 93 28 60 10 sll %g1, 0x10, %o1
loc->handlers = rtems_rfs_rtems_handlers (file);
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
40015008: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001500c: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
40015010: 40 00 40 5b call 4002517c <printf> <== NOT EXECUTED
40015014: 90 12 22 08 or %o0, 0x208, %o0 <== NOT EXECUTED
return false;
40015018: 82 10 20 00 clr %g1 <== NOT EXECUTED
}
return true;
}
4001501c: b0 08 60 01 and %g1, 1, %i0
40015020: 81 c7 e0 08 ret
40015024: 81 e8 00 00 restore
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
40015028: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
4001502c: 05 10 00 e5 sethi %hi(0x40039400), %g2 <== NOT EXECUTED
40015030: 84 10 a0 9c or %g2, 0x9c, %g2 ! 4003949c <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
40015034: c4 26 20 10 st %g2, [ %i0 + 0x10 ] <== NOT EXECUTED
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
}
40015038: b0 08 60 01 and %g1, 1, %i0 <== NOT EXECUTED
4001503c: 81 c7 e0 08 ret <== NOT EXECUTED
40015040: 81 e8 00 00 restore <== NOT EXECUTED
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
40015044: 82 10 20 01 mov 1, %g1
rtems_rfs_inode_handle* inode)
{
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
40015048: 05 10 00 e5 sethi %hi(0x40039400), %g2
4001504c: 84 10 a0 c8 or %g2, 0xc8, %g2 ! 400394c8 <rtems_rfs_rtems_dir_handlers>
40015050: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
}
40015054: b0 08 60 01 and %g1, 1, %i0
40015058: 81 c7 e0 08 ret
4001505c: 81 e8 00 00 restore
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
40015060: 82 10 20 01 mov 1, %g1
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
loc->handlers = rtems_rfs_rtems_handlers (file);
40015064: 05 10 00 e5 sethi %hi(0x40039400), %g2
40015068: 84 10 a0 f4 or %g2, 0xf4, %g2 ! 400394f4 <rtems_rfs_rtems_file_handlers>
4001506c: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
}
40015070: b0 08 60 01 and %g1, 1, %i0
40015074: 81 c7 e0 08 ret
40015078: 81 e8 00 00 restore
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
4001507c: 05 10 00 dc sethi %hi(0x40037000), %g2
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
40015080: 82 10 20 01 mov 1, %g1
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
40015084: 84 10 a1 d4 or %g2, 0x1d4, %g2
40015088: 10 bf ff e5 b 4001501c <rtems_rfs_rtems_set_handlers+0x74>
4001508c: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
40013fb4 <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
40013fb4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40013fb8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
40013fbc: 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);
40013fc0: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
40013fc4: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
40013fc8: 7f ff fd 2e call 40013480 <rtems_rfs_group_usage> <== NOT EXECUTED
40013fcc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
40013fd0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
40013fd4: c4 07 60 04 ld [ %i5 + 4 ], %g2 <== NOT EXECUTED
40013fd8: c6 07 bf f8 ld [ %fp + -8 ], %g3 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
40013fdc: f0 07 60 08 ld [ %i5 + 8 ], %i0 <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
40013fe0: f4 00 60 20 ld [ %g1 + 0x20 ], %i2 <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
40013fe4: f6 00 60 1c ld [ %g1 + 0x1c ], %i3 <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
40013fe8: f8 07 40 00 ld [ %i5 ], %i4 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
40013fec: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
40013ff0: c8 07 60 1c ld [ %i5 + 0x1c ], %g4 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
40013ff4: 86 20 80 03 sub %g2, %g3, %g3 <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
40013ff8: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
40013ffc: f0 26 40 00 st %i0, [ %i1 ] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
40014000: 84 20 40 02 sub %g1, %g2, %g2 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
40014004: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== NOT EXECUTED
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
40014008: f4 26 60 04 st %i2, [ %i1 + 4 ] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
4001400c: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
40014010: f6 26 60 0c st %i3, [ %i1 + 0xc ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
40014014: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED
40014018: c6 26 60 14 st %g3, [ %i1 + 0x14 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
4001401c: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
40014020: c6 26 60 1c st %g3, [ %i1 + 0x1c ] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
40014024: c4 26 60 24 st %g2, [ %i1 + 0x24 ] <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
40014028: c4 26 60 28 st %g2, [ %i1 + 0x28 ] <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
4001402c: 03 0a 02 48 sethi %hi(0x28092000), %g1 <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
40014030: f8 26 60 30 st %i4, [ %i1 + 0x30 ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
40014034: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
40014038: c8 26 60 34 st %g4, [ %i1 + 0x34 ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
4001403c: c2 26 60 2c st %g1, [ %i1 + 0x2c ] <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
return 0;
}
40014040: 81 c7 e0 08 ret <== NOT EXECUTED
40014044: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
400141a4 <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)
{
400141a4: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
400141a8: 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),
400141ac: 90 10 00 1b mov %i3, %o0
400141b0: 40 00 48 64 call 40026340 <strlen>
400141b4: 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);
400141b8: f0 06 20 08 ld [ %i0 + 8 ], %i0
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
400141bc: 40 00 12 ea call 40018d64 <geteuid>
400141c0: ba 10 00 08 mov %o0, %i5
400141c4: 40 00 12 e4 call 40018d54 <getegid>
400141c8: a0 10 00 08 mov %o0, %l0
400141cc: 91 2a 20 10 sll %o0, 0x10, %o0
400141d0: 91 32 20 10 srl %o0, 0x10, %o0
400141d4: f0 23 a0 60 st %i0, [ %sp + 0x60 ]
400141d8: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
400141dc: 98 10 00 1d mov %i5, %o4
400141e0: 9b 2c 20 10 sll %l0, 0x10, %o5
400141e4: 90 10 00 1c mov %i4, %o0
400141e8: 92 10 00 19 mov %i1, %o1
400141ec: 94 10 00 1a mov %i2, %o2
400141f0: 96 10 00 1b mov %i3, %o3
400141f4: 9b 33 60 10 srl %o5, 0x10, %o5
400141f8: 40 00 34 68 call 40021398 <rtems_rfs_symlink>
400141fc: b0 10 20 00 clr %i0
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
40014200: 80 a2 20 00 cmp %o0, 0
40014204: 02 80 00 05 be 40014218 <rtems_rfs_rtems_symlink+0x74> <== ALWAYS TAKEN
40014208: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
4001420c: 40 00 3e 4b call 40023b38 <__errno> <== NOT EXECUTED
40014210: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014214: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
40014218: 81 c7 e0 08 ret
4001421c: 81 e8 00 00 restore
40014c48 <rtems_rfs_rtems_unlock_by_mt_entry>:
static void
rtems_rfs_rtems_unlock_by_mt_entry (
const rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40014c48: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = mt_entry->fs_info;
40014c4c: d0 06 20 08 ld [ %i0 + 8 ], %o0
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_buffers_release (fs);
40014c50: 40 00 24 3e call 4001dd48 <rtems_rfs_buffers_release>
40014c54: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
40014c58: 7f ff e4 f3 call 4000e024 <rtems_semaphore_release>
40014c5c: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40014c60: ba 92 20 00 orcc %o0, 0, %i5
40014c64: 12 80 00 04 bne 40014c74 <rtems_rfs_rtems_unlock_by_mt_entry+0x2c><== NEVER TAKEN
40014c68: 90 10 20 00 clr %o0
40014c6c: 81 c7 e0 08 ret
40014c70: 81 e8 00 00 restore
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
40014c74: 40 00 01 0c call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40014c78: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40014c7c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40014c80: 02 bf ff fb be 40014c6c <rtems_rfs_rtems_unlock_by_mt_entry+0x24><== NOT EXECUTED
40014c84: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
40014c88: 40 00 0f 62 call 40018a10 <rtems_status_text> <== NOT EXECUTED
40014c8c: 31 10 00 dc sethi %hi(0x40037000), %i0 <== NOT EXECUTED
40014c90: b0 16 20 f0 or %i0, 0xf0, %i0 ! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40014c94: 40 00 41 3a call 4002517c <printf> <== NOT EXECUTED
40014c98: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
40014220 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
40014220: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
40014224: 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);
40014228: 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);
4001422c: 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);
40014230: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
40014234: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40014238: 7f ff fc f4 call 40013608 <rtems_rfs_inode_open> <== NOT EXECUTED
4001423c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
40014240: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40014244: 02 80 00 07 be 40014260 <rtems_rfs_rtems_utime+0x40> <== NOT EXECUTED
40014248: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: read inode", rc);
4001424c: 40 00 3e 3b call 40023b38 <__errno> <== NOT EXECUTED
40014250: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40014254: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40014258: 81 c7 e0 08 ret <== NOT EXECUTED
4001425c: 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);
40014260: 85 36 60 18 srl %i1, 0x18, %g2 <== NOT EXECUTED
40014264: 87 36 60 10 srl %i1, 0x10, %g3 <== NOT EXECUTED
40014268: c4 28 60 10 stb %g2, [ %g1 + 0x10 ] <== NOT EXECUTED
4001426c: 85 36 60 08 srl %i1, 8, %g2 <== NOT EXECUTED
40014270: c6 28 60 11 stb %g3, [ %g1 + 0x11 ] <== NOT EXECUTED
40014274: c4 28 60 12 stb %g2, [ %g1 + 0x12 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40014278: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
4001427c: 85 36 a0 18 srl %i2, 0x18, %g2 <== NOT EXECUTED
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40014280: c6 2f bf e8 stb %g3, [ %fp + -24 ] <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
40014284: c4 28 60 14 stb %g2, [ %g1 + 0x14 ] <== NOT EXECUTED
40014288: 87 36 a0 10 srl %i2, 0x10, %g3 <== NOT EXECUTED
4001428c: 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);
40014290: 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);
40014294: 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);
40014298: c6 28 60 15 stb %g3, [ %g1 + 0x15 ] <== NOT EXECUTED
4001429c: c4 28 60 16 stb %g2, [ %g1 + 0x16 ] <== NOT EXECUTED
400142a0: f4 28 60 17 stb %i2, [ %g1 + 0x17 ] <== NOT EXECUTED
400142a4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
400142a8: 7f ff fd 50 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
400142ac: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (rc)
400142b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400142b4: 02 bf ff e9 be 40014258 <rtems_rfs_rtems_utime+0x38> <== NOT EXECUTED
400142b8: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
400142bc: 40 00 3e 1f call 40023b38 <__errno> <== NOT EXECUTED
400142c0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400142c4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
400142c8: 81 c7 e0 08 ret <== NOT EXECUTED
400142cc: 81 e8 00 00 restore <== NOT EXECUTED
40011e4c <rtems_rfs_rup_quotient>:
* Return a rounded up integer quotient given a dividend and divisor. That is:
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
40011e4c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
40011e50: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (dividend == 0)
40011e54: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40011e58: 02 80 00 06 be 40011e70 <rtems_rfs_rup_quotient+0x24> <== NOT EXECUTED
40011e5c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
40011e60: 90 02 3f ff add %o0, -1, %o0 <== NOT EXECUTED
40011e64: 7f ff c2 0f call 400026a0 <.udiv> <== NOT EXECUTED
40011e68: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40011e6c: b0 02 20 01 add %o0, 1, %i0 <== NOT EXECUTED
}
40011e70: 81 c7 e0 08 ret <== NOT EXECUTED
40011e74: 81 e8 00 00 restore <== NOT EXECUTED
4001d518 <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
4001d518: 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))
4001d51c: 90 10 20 00 clr %o0
4001d520: 92 10 20 80 mov 0x80, %o1
4001d524: 7f ff de e0 call 400150a4 <rtems_rfs_trace>
4001d528: fa 06 20 08 ld [ %i0 + 8 ], %i5
4001d52c: 80 8a 20 ff btst 0xff, %o0
4001d530: 32 80 00 37 bne,a 4001d60c <rtems_rfs_scan_chain+0xf4> <== NEVER TAKEN
4001d534: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
4001d538: 39 10 00 df sethi %hi(0x40037c00), %i4
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
4001d53c: 80 a7 40 18 cmp %i5, %i0
4001d540: 12 80 00 0b bne 4001d56c <rtems_rfs_scan_chain+0x54> <== ALWAYS TAKEN
4001d544: b8 17 23 58 or %i4, 0x358, %i4
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001d548: 10 80 00 2a b 4001d5f0 <rtems_rfs_scan_chain+0xd8> <== NOT EXECUTED
4001d54c: 90 10 20 00 clr %o0 <== NOT EXECUTED
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
4001d550: 80 a0 40 1a cmp %g1, %i2
4001d554: 02 80 00 14 be 4001d5a4 <rtems_rfs_scan_chain+0x8c>
4001d558: 90 10 20 00 clr %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(
Chain_Node *the_node
)
{
return the_node->previous;
4001d55c: fa 07 60 04 ld [ %i5 + 4 ], %i5
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
4001d560: 80 a7 40 18 cmp %i5, %i0
4001d564: 02 80 00 23 be 4001d5f0 <rtems_rfs_scan_chain+0xd8>
4001d568: 90 10 20 00 clr %o0
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001d56c: 90 10 20 00 clr %o0
4001d570: 7f ff de cd call 400150a4 <rtems_rfs_trace>
4001d574: 92 10 20 80 mov 0x80, %o1
4001d578: 80 8a 20 ff btst 0xff, %o0
4001d57c: 22 bf ff f5 be,a 4001d550 <rtems_rfs_scan_chain+0x38> <== ALWAYS TAKEN
4001d580: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
4001d584: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
4001d588: 40 00 1e fd call 4002517c <printf> <== NOT EXECUTED
4001d58c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
4001d590: c2 07 60 34 ld [ %i5 + 0x34 ], %g1 <== NOT EXECUTED
4001d594: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED
4001d598: 32 bf ff f2 bne,a 4001d560 <rtems_rfs_scan_chain+0x48> <== NOT EXECUTED
4001d59c: fa 07 60 04 ld [ %i5 + 4 ], %i5 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001d5a0: 90 10 20 00 clr %o0 <== NOT EXECUTED
4001d5a4: 7f ff de c0 call 400150a4 <rtems_rfs_trace>
4001d5a8: 92 10 20 80 mov 0x80, %o1
4001d5ac: 80 8a 20 ff btst 0xff, %o0
4001d5b0: 22 80 00 07 be,a 4001d5cc <rtems_rfs_scan_chain+0xb4> <== ALWAYS TAKEN
4001d5b4: c2 06 40 00 ld [ %i1 ], %g1
printf (": found block=%" PRIuPTR "\n",
4001d5b8: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
4001d5bc: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001d5c0: 40 00 1e ef call 4002517c <printf> <== NOT EXECUTED
4001d5c4: 90 12 23 60 or %o0, 0x360, %o0 ! 40037f60 <CSWTCH.2+0x170><== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
4001d5c8: 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 );
4001d5cc: 90 10 00 1d mov %i5, %o0
4001d5d0: 82 00 7f ff add %g1, -1, %g1
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
4001d5d4: b0 10 00 1d mov %i5, %i0
4001d5d8: 7f ff f3 a1 call 4001a45c <_Chain_Extract>
4001d5dc: c2 26 40 00 st %g1, [ %i1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
4001d5e0: c0 27 60 04 clr [ %i5 + 4 ]
4001d5e4: c0 27 40 00 clr [ %i5 ]
4001d5e8: 81 c7 e0 08 ret
4001d5ec: 81 e8 00 00 restore
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
4001d5f0: 7f ff de ad call 400150a4 <rtems_rfs_trace>
4001d5f4: 92 10 20 80 mov 0x80, %o1
4001d5f8: 80 8a 20 ff btst 0xff, %o0
4001d5fc: 12 80 00 0a bne 4001d624 <rtems_rfs_scan_chain+0x10c> <== NEVER TAKEN
4001d600: 11 10 00 df sethi %hi(0x40037c00), %o0
printf (": not found\n");
return NULL;
}
4001d604: 81 c7 e0 08 ret
4001d608: 91 e8 20 00 restore %g0, 0, %o0
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
4001d60c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4001d610: 11 10 00 df sethi %hi(0x40037c00), %o0 <== NOT EXECUTED
4001d614: 40 00 1e da call 4002517c <printf> <== NOT EXECUTED
4001d618: 90 12 23 28 or %o0, 0x328, %o0 ! 40037f28 <CSWTCH.2+0x138><== 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));
4001d61c: 10 bf ff c8 b 4001d53c <rtems_rfs_scan_chain+0x24> <== NOT EXECUTED
4001d620: 39 10 00 df sethi %hi(0x40037c00), %i4 <== NOT EXECUTED
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": not found\n");
return NULL;
4001d624: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": not found\n");
4001d628: 40 00 1f 6d call 400253dc <puts> <== NOT EXECUTED
4001d62c: 90 12 23 78 or %o0, 0x378, %o0 <== NOT EXECUTED
return NULL;
}
4001d630: 81 c7 e0 08 ret <== NOT EXECUTED
4001d634: 81 e8 00 00 restore <== NOT EXECUTED
4001bc08 <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,
4001bc08: 9d e3 bf 90 save %sp, -112, %sp
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
4001bc0c: 90 10 00 18 mov %i0, %o0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001bc10: ac 10 00 18 mov %i0, %l6
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
4001bc14: c0 2e 80 00 clrb [ %i2 ]
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
4001bc18: 7f ff ff e7 call 4001bbb4 <rtems_rfs_bitmap_load_map>
4001bc1c: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
4001bc20: b0 92 20 00 orcc %o0, 0, %i0
4001bc24: 24 80 00 04 ble,a 4001bc34 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2c><== ALWAYS TAKEN
4001bc28: f8 06 40 00 ld [ %i1 ], %i4
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
return 0;
}
4001bc2c: 81 c7 e0 08 ret <== NOT EXECUTED
4001bc30: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
end_bit = test_bit + (window * direction);
4001bc34: a1 2e e0 0b sll %i3, 0xb, %l0
if (end_bit < 0)
4001bc38: a0 84 00 1c addcc %l0, %i4, %l0
4001bc3c: 2c 80 00 06 bneg,a 4001bc54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
4001bc40: a0 10 20 00 clr %l0
end_bit = 0;
else if (end_bit >= control->size)
4001bc44: c2 05 a0 0c ld [ %l6 + 0xc ], %g1
4001bc48: 80 a4 00 01 cmp %l0, %g1
4001bc4c: 3a 80 00 02 bcc,a 4001bc54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
4001bc50: 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];
4001bc54: ee 05 a0 14 ld [ %l6 + 0x14 ], %l7
map_bits = &map[map_index];
4001bc58: e6 07 bf fc ld [ %fp + -4 ], %l3
if (end_bit < 0)
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
4001bc5c: a5 3f 20 05 sra %i4, 5, %l2
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
map_bits = &map[map_index];
4001bc60: 83 2c a0 02 sll %l2, 2, %g1
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
4001bc64: 85 3f 20 0a sra %i4, 0xa, %g2
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
4001bc68: ab 36 e0 1f srl %i3, 0x1f, %l5
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
4001bc6c: 85 28 a0 02 sll %g2, 2, %g2
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
|| ((direction > 0) && (test_bit >= end_bit)))
4001bc70: a9 3e e0 1f sra %i3, 0x1f, %l4
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
map_bits = &map[map_index];
4001bc74: a6 04 c0 01 add %l3, %g1, %l3
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
|| ((direction > 0) && (test_bit >= end_bit)))
4001bc78: a8 25 00 1b sub %l4, %i3, %l4
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
4001bc7c: 82 0d 60 ff and %l5, 0xff, %g1
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
4001bc80: ba 0f 20 1f and %i4, 0x1f, %i5
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
4001bc84: 92 0c a0 1f and %l2, 0x1f, %o1
search_bits = &control->search_bits[search_index];
4001bc88: ae 05 c0 02 add %l7, %g2, %l7
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
4001bc8c: b1 2e e0 02 sll %i3, 2, %i0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001bc90: 97 2e e0 05 sll %i3, 5, %o3
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
4001bc94: a2 10 20 01 mov 1, %l1
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
4001bc98: c2 27 bf f4 st %g1, [ %fp + -12 ]
|| ((direction > 0) && (test_bit >= end_bit)))
4001bc9c: a9 35 20 1f srl %l4, 0x1f, %l4
/*
* If any bit is clear find that bit and then search the map element. If
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
4001bca0: c8 05 c0 00 ld [ %l7 ], %g4
4001bca4: 80 a1 20 00 cmp %g4, 0
4001bca8: 02 80 00 49 be 4001bdcc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1c4>
4001bcac: 80 a6 e0 00 cmp %i3, 0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001bcb0: 86 06 c0 12 add %i3, %l2, %g3
4001bcb4: 87 28 e0 05 sll %g3, 5, %g3
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
4001bcb8: 80 a2 60 1f cmp %o1, 0x1f
4001bcbc: 18 80 00 52 bgu 4001be04 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1fc>
4001bcc0: 9f 2c 40 09 sll %l1, %o1, %o7
&& (search_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*search_bits, search_offset))
4001bcc4: 80 8b c0 04 btst %o7, %g4
4001bcc8: 22 80 00 13 be,a 4001bd14 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x10c>
4001bccc: a6 04 c0 18 add %l3, %i0, %l3
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
4001bcd0: c4 04 c0 00 ld [ %l3 ], %g2
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
4001bcd4: 83 2c 40 1d sll %l1, %i5, %g1
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
4001bcd8: 80 88 40 02 btst %g1, %g2
4001bcdc: 02 80 00 0b be 4001bd08 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x100>
4001bce0: 80 a4 00 1c cmp %l0, %i4
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
4001bce4: 10 80 00 55 b 4001be38 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x230>
4001bce8: 82 28 80 01 andn %g2, %g1, %g1
{
/*
* Find the clear bit in the map. Update the search map and map if
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
4001bcec: 80 a7 60 1f cmp %i5, 0x1f
4001bcf0: 18 80 00 08 bgu 4001bd10 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x108><== NEVER TAKEN
4001bcf4: b8 07 00 1b add %i4, %i3, %i4
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
4001bcf8: 83 2c 40 1d sll %l1, %i5, %g1
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
4001bcfc: 80 88 80 01 btst %g2, %g1
4001bd00: 12 80 00 4d bne 4001be34 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x22c>
4001bd04: 80 a4 00 1c cmp %l0, %i4
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
if (test_bit == end_bit)
4001bd08: 32 bf ff f9 bne,a 4001bcec <rtems_rfs_search_map_for_clear_bit.constprop.1+0xe4>
4001bd0c: ba 07 40 1b add %i5, %i3, %i5
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
4001bd10: a6 04 c0 18 add %l3, %i0, %l3
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001bd14: 80 a6 e0 00 cmp %i3, 0
4001bd18: 04 80 00 44 ble 4001be28 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x220>
4001bd1c: a4 04 80 1b add %l2, %i3, %l2
4001bd20: b8 10 20 00 clr %i4
4001bd24: ba 10 20 00 clr %i5
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
4001bd28: b8 00 c0 1c add %g3, %i4, %i4
search_offset += direction;
4001bd2c: 92 02 40 1b add %o1, %i3, %o1
if (((direction < 0) && (test_bit <= end_bit))
4001bd30: 84 10 00 15 mov %l5, %g2
4001bd34: 80 a4 00 1c cmp %l0, %i4
4001bd38: 16 80 00 03 bge 4001bd44 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x13c>
4001bd3c: 82 10 20 01 mov 1, %g1
4001bd40: 82 10 20 00 clr %g1
4001bd44: 80 88 60 ff btst 0xff, %g1
4001bd48: 32 80 00 5b bne,a 4001beb4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2ac>
4001bd4c: c2 07 bf f4 ld [ %fp + -12 ], %g1
4001bd50: 86 00 c0 0b add %g3, %o3, %g3
|| ((direction > 0) && (test_bit >= end_bit)))
4001bd54: 80 a4 00 1c cmp %l0, %i4
4001bd58: 04 80 00 03 ble 4001bd64 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x15c>
4001bd5c: 82 10 20 01 mov 1, %g1
4001bd60: 82 10 20 00 clr %g1
4001bd64: 80 88 60 ff btst 0xff, %g1
4001bd68: 02 bf ff d5 be 4001bcbc <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb4>
4001bd6c: 80 a2 60 1f cmp %o1, 0x1f
4001bd70: 80 a5 20 00 cmp %l4, 0
4001bd74: 02 bf ff d2 be 4001bcbc <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb4>
4001bd78: 80 a2 60 1f cmp %o1, 0x1f
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
4001bd7c: ae 05 c0 18 add %l7, %i0, %l7
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
|| ((direction > 0) && (test_bit >= end_bit)))
4001bd80: 82 10 20 01 mov 1, %g1
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001bd84: 92 10 20 00 clr %o1
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
4001bd88: 80 88 60 ff btst 0xff, %g1
4001bd8c: 02 80 00 06 be 4001bda4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x19c>
4001bd90: 80 a4 00 1c cmp %l0, %i4
4001bd94: 80 88 a0 ff btst 0xff, %g2
4001bd98: 32 bf ff c3 bne,a 4001bca4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x9c>
4001bd9c: c8 05 c0 00 ld [ %l7 ], %g4
4001bda0: 80 a4 00 1c cmp %l0, %i4
4001bda4: 16 80 00 03 bge 4001bdb0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a8>
4001bda8: 82 10 20 01 mov 1, %g1
4001bdac: 82 10 20 00 clr %g1
4001bdb0: 80 88 60 ff btst 0xff, %g1
4001bdb4: 02 80 00 04 be 4001bdc4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1bc>
4001bdb8: 80 a5 20 00 cmp %l4, 0
4001bdbc: 32 bf ff ba bne,a 4001bca4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x9c>
4001bdc0: c8 05 c0 00 ld [ %l7 ], %g4
return 0;
4001bdc4: 81 c7 e0 08 ret
4001bdc8: 91 e8 20 00 restore %g0, 0, %o0
* Align test_bit either up or down depending on the direction to next 32
* bit boundary.
*/
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
4001bdcc: 04 80 00 34 ble 4001be9c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x294>
4001bdd0: b8 0f 3f e0 and %i4, -32, %i4
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
4001bdd4: 82 10 20 20 mov 0x20, %g1
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
4001bdd8: ba 10 20 00 clr %i5
*/
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
4001bddc: 92 20 40 09 sub %g1, %o1, %o1
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
4001bde0: 83 2a 60 05 sll %o1, 5, %g1
4001bde4: b8 00 40 1c add %g1, %i4, %i4
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
4001bde8: d6 27 bf f0 st %o3, [ %fp + -16 ]
4001bdec: 7f ff 99 f3 call 400025b8 <.umul>
4001bdf0: 90 10 00 1b mov %i3, %o0
4001bdf4: d6 07 bf f0 ld [ %fp + -16 ], %o3
4001bdf8: 83 2a 20 02 sll %o0, 2, %g1
map_index += direction * bits_skipped;
4001bdfc: a4 04 80 08 add %l2, %o0, %l2
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
4001be00: a6 04 c0 01 add %l3, %g1, %l3
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001be04: 80 a6 e0 00 cmp %i3, 0
4001be08: 04 80 00 1c ble 4001be78 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x270>
4001be0c: ae 05 c0 18 add %l7, %i0, %l7
4001be10: 80 a4 00 1c cmp %l0, %i4
4001be14: 04 80 00 03 ble 4001be20 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
4001be18: 82 10 20 01 mov 1, %g1
4001be1c: 82 10 20 00 clr %g1
4001be20: 10 bf ff d9 b 4001bd84 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x17c>
4001be24: 84 10 20 00 clr %g2
}
}
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001be28: b8 10 20 1f mov 0x1f, %i4
4001be2c: 10 bf ff bf b 4001bd28 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x120>
4001be30: ba 10 20 1f mov 0x1f, %i5
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
4001be34: 82 28 80 01 andn %g2, %g1, %g1
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
{
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
4001be38: 80 a0 60 00 cmp %g1, 0
4001be3c: 12 80 00 05 bne 4001be50 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x248>
4001be40: c2 24 c0 00 st %g1, [ %l3 ]
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
4001be44: c2 05 c0 00 ld [ %l7 ], %g1
4001be48: 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,
4001be4c: de 25 c0 00 st %o7, [ %l7 ]
1 << search_offset);
control->free--;
4001be50: c2 05 a0 10 ld [ %l6 + 0x10 ], %g1
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
4001be54: c4 05 80 00 ld [ %l6 ], %g2
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
1 << search_offset);
control->free--;
4001be58: 82 00 7f ff add %g1, -1, %g1
4001be5c: c2 25 a0 10 st %g1, [ %l6 + 0x10 ]
*bit = test_bit;
4001be60: f8 26 40 00 st %i4, [ %i1 ]
*found = true;
4001be64: 82 10 20 01 mov 1, %g1
4001be68: c2 2e 80 00 stb %g1, [ %i2 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
4001be6c: c2 28 80 00 stb %g1, [ %g2 ]
return 0;
4001be70: 81 c7 e0 08 ret
4001be74: 91 e8 20 00 restore %g0, 0, %o0
4001be78: 84 10 00 15 mov %l5, %g2
4001be7c: 80 a4 00 1c cmp %l0, %i4
4001be80: 14 80 00 04 bg 4001be90 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x288>
4001be84: 82 10 20 01 mov 1, %g1
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001be88: 10 bf ff c0 b 4001bd88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
4001be8c: 92 10 20 1f mov 0x1f, %o1
4001be90: 82 10 20 00 clr %g1
4001be94: 10 bf ff bd b 4001bd88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
4001be98: 92 10 20 1f mov 0x1f, %o1
bits_skipped = search_offset + 1;
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
4001be9c: 83 2a 60 05 sll %o1, 5, %g1
map_offset = rtems_rfs_bitmap_element_bits () - 1;
4001bea0: ba 10 20 1f mov 0x1f, %i5
bits_skipped = search_offset + 1;
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
4001bea4: 82 38 00 01 xnor %g0, %g1, %g1
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
4001bea8: 92 02 60 01 inc %o1
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
4001beac: 10 bf ff cf b 4001bde8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e0>
4001beb0: b8 00 40 1c add %g1, %i4, %i4
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
4001beb4: 80 a0 60 00 cmp %g1, 0
4001beb8: 22 bf ff a7 be,a 4001bd54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x14c>
4001bebc: 86 00 c0 0b add %g3, %o3, %g3
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
4001bec0: ae 05 c0 18 add %l7, %i0, %l7
4001bec4: 80 a4 00 1c cmp %l0, %i4
4001bec8: 04 80 00 03 ble 4001bed4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2cc><== NEVER TAKEN
4001becc: 82 10 20 01 mov 1, %g1
4001bed0: 82 10 20 00 clr %g1
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
4001bed4: 84 10 20 01 mov 1, %g2
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001bed8: 10 bf ff ac b 4001bd88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
4001bedc: 92 10 20 1f mov 0x1f, %o1
40021398 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
40021398: 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))
4002139c: 90 10 20 02 mov 2, %o0
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
400213a0: 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))
400213a4: 7f ff cf 40 call 400150a4 <rtems_rfs_trace>
400213a8: 92 10 20 00 clr %o1
400213ac: 80 8a 20 ff btst 0xff, %o0
400213b0: 32 80 00 08 bne,a 400213d0 <rtems_rfs_symlink+0x38> <== NEVER TAKEN
400213b4: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 <== NOT EXECUTED
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
400213b8: c2 06 20 08 ld [ %i0 + 8 ], %g1
400213bc: 80 a7 00 01 cmp %i4, %g1
400213c0: 0a 80 00 22 bcs 40021448 <rtems_rfs_symlink+0xb0> <== ALWAYS TAKEN
400213c4: b4 10 20 5b mov 0x5b, %i2
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
400213c8: 81 c7 e0 08 ret
400213cc: 91 e8 00 1a restore %g0, %i2, %o0
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
400213d0: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
400213d4: 40 00 0f 6a call 4002517c <printf> <== NOT EXECUTED
400213d8: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 400393f8 <CSWTCH.2+0x1608><== NOT EXECUTED
400213dc: a0 10 00 19 mov %i1, %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
400213e0: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
400213e4: 04 80 00 08 ble 40021404 <rtems_rfs_symlink+0x6c> <== NOT EXECUTED
400213e8: a2 06 40 1a add %i1, %i2, %l1 <== NOT EXECUTED
printf ("%c", name[c]);
400213ec: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
400213f0: 40 00 0f cd call 40025324 <putchar> <== NOT EXECUTED
400213f4: 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++)
400213f8: 80 a4 00 11 cmp %l0, %l1 <== NOT EXECUTED
400213fc: 32 bf ff fd bne,a 400213f0 <rtems_rfs_symlink+0x58> <== NOT EXECUTED
40021400: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
40021404: 11 10 00 e5 sethi %hi(0x40039400), %o0 <== NOT EXECUTED
40021408: 40 00 0f 5d call 4002517c <printf> <== NOT EXECUTED
4002140c: 90 12 20 20 or %o0, 0x20, %o0 ! 40039420 <CSWTCH.2+0x1630><== NOT EXECUTED
40021410: b4 10 00 1b mov %i3, %i2 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
40021414: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40021418: 04 bf ff e8 ble 400213b8 <rtems_rfs_symlink+0x20> <== NOT EXECUTED
4002141c: a0 07 00 1b add %i4, %i3, %l0 <== NOT EXECUTED
printf ("%c", link[c]);
40021420: d0 4e 80 00 ldsb [ %i2 ], %o0 <== NOT EXECUTED
40021424: 40 00 0f c0 call 40025324 <putchar> <== NOT EXECUTED
40021428: 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++)
4002142c: 80 a6 80 10 cmp %i2, %l0 <== NOT EXECUTED
40021430: 32 bf ff fd bne,a 40021424 <rtems_rfs_symlink+0x8c> <== NOT EXECUTED
40021434: d0 4e 80 00 ldsb [ %i2 ], %o0 <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
40021438: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
4002143c: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
40021440: 1a bf ff e2 bcc 400213c8 <rtems_rfs_symlink+0x30> <== NOT EXECUTED
40021444: b4 10 20 5b mov 0x5b, %i2 <== NOT EXECUTED
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
40021448: 40 00 13 be call 40026340 <strlen>
4002144c: 90 10 00 19 mov %i1, %o0
40021450: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
40021454: 82 07 bf 74 add %fp, -140, %g1
40021458: 96 10 00 08 mov %o0, %o3
4002145c: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
40021460: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
40021464: 90 10 00 18 mov %i0, %o0
40021468: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
4002146c: 94 10 00 19 mov %i1, %o2
40021470: 9a 10 20 01 mov 1, %o5
40021474: 19 00 00 28 sethi %hi(0xa000), %o4
40021478: 7f ff c9 b6 call 40013b50 <rtems_rfs_inode_create>
4002147c: 98 13 21 ff or %o4, 0x1ff, %o4 ! a1ff <PROM_START+0xa1ff>
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
40021480: b4 92 20 00 orcc %o0, 0, %i2
40021484: 14 bf ff d1 bg 400213c8 <rtems_rfs_symlink+0x30> <== NEVER TAKEN
40021488: d2 07 bf 74 ld [ %fp + -140 ], %o1
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
4002148c: 90 10 00 18 mov %i0, %o0
40021490: 94 07 bf 88 add %fp, -120, %o2
40021494: 7f ff c8 5d call 40013608 <rtems_rfs_inode_open>
40021498: 96 10 20 01 mov 1, %o3
if (rc > 0)
4002149c: b4 92 20 00 orcc %o0, 0, %i2
400214a0: 14 bf ff ca bg 400213c8 <rtems_rfs_symlink+0x30> <== NEVER TAKEN
400214a4: 80 a7 20 13 cmp %i4, 0x13
/*
* If the link length is less than the length of data union in the inode
* place the link into the data area else allocate a block and write the link
* to that.
*/
if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
400214a8: 38 80 00 20 bgu,a 40021528 <rtems_rfs_symlink+0x190> <== NEVER TAKEN
400214ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
400214b0: d0 07 bf 94 ld [ %fp + -108 ], %o0
400214b4: 92 10 20 00 clr %o1
400214b8: 94 10 20 14 mov 0x14, %o2
400214bc: 40 00 0e b2 call 40024f84 <memset>
400214c0: 90 02 20 1c add %o0, 0x1c, %o0
memcpy (inode.node->data.name, link, link_length);
400214c4: d0 07 bf 94 ld [ %fp + -108 ], %o0
400214c8: 92 10 00 1b mov %i3, %o1
400214cc: 90 02 20 1c add %o0, 0x1c, %o0
400214d0: 40 00 0e 1e call 40024d48 <memcpy>
400214d4: 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);
400214d8: c2 07 bf 94 ld [ %fp + -108 ], %g1
400214dc: c0 28 60 0c clrb [ %g1 + 0xc ]
400214e0: c2 07 bf 94 ld [ %fp + -108 ], %g1
400214e4: c0 28 60 0d clrb [ %g1 + 0xd ]
400214e8: c2 07 bf 94 ld [ %fp + -108 ], %g1
400214ec: c0 28 60 0e clrb [ %g1 + 0xe ]
400214f0: c2 07 bf 94 ld [ %fp + -108 ], %g1
400214f4: c0 28 60 0f clrb [ %g1 + 0xf ]
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
400214f8: c2 07 bf 94 ld [ %fp + -108 ], %g1
400214fc: 85 37 20 08 srl %i4, 8, %g2
40021500: c4 28 60 0a stb %g2, [ %g1 + 0xa ]
40021504: c2 07 bf 94 ld [ %fp + -108 ], %g1
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
40021508: 90 10 00 18 mov %i0, %o0
4002150c: f8 28 60 0b stb %i4, [ %g1 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40021510: 82 10 20 01 mov 1, %g1
40021514: 92 07 bf 88 add %fp, -120, %o1
40021518: 7f ff c8 b4 call 400137e8 <rtems_rfs_inode_close>
4002151c: c2 2f bf 98 stb %g1, [ %fp + -104 ]
40021520: 10 bf ff aa b 400213c8 <rtems_rfs_symlink+0x30>
40021524: b4 10 00 08 mov %o0, %i2
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
uint8_t* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
40021528: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4002152c: 7f ff ec b9 call 4001c810 <rtems_rfs_block_map_open> <== NOT EXECUTED
40021530: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
40021534: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
if (rc > 0)
40021538: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4002153c: 04 80 00 05 ble 40021550 <rtems_rfs_symlink+0x1b8> <== NOT EXECUTED
40021540: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
40021544: 7f ff c8 a9 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40021548: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4002154c: 30 bf ff 9f b,a 400213c8 <rtems_rfs_symlink+0x30> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
40021550: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40021554: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40021558: 7f ff ee 07 call 4001cd74 <rtems_rfs_block_map_grow> <== NOT EXECUTED
4002155c: 96 07 bf 78 add %fp, -136, %o3 <== NOT EXECUTED
if (rc > 0)
40021560: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
40021564: 04 80 00 07 ble 40021580 <rtems_rfs_symlink+0x1e8> <== NOT EXECUTED
40021568: d4 07 bf 78 ld [ %fp + -136 ], %o2 <== NOT EXECUTED
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
4002156c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021570: 7f ff ed 09 call 4001c994 <rtems_rfs_block_map_close> <== NOT EXECUTED
40021574: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
40021578: 10 bf ff f3 b 40021544 <rtems_rfs_symlink+0x1ac> <== NOT EXECUTED
4002157c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
40021580: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
40021584: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
40021588: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
4002158c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021590: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
40021594: 7f ff f0 a3 call 4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40021598: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
4002159c: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
400215a0: 14 bf ff f4 bg 40021570 <rtems_rfs_symlink+0x1d8> <== NOT EXECUTED
400215a4: 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);
400215a8: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
400215ac: 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);
400215b0: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
400215b4: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
400215b8: 40 00 0e 73 call 40024f84 <memset> <== NOT EXECUTED
400215bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
memcpy (data, link, link_length);
400215c0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
400215c4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400215c8: 40 00 0d e0 call 40024d48 <memcpy> <== NOT EXECUTED
400215cc: 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);
400215d0: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
400215d4: 7f ff f0 19 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400215d8: 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);
400215dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
400215e0: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
400215e4: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
400215e8: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
400215ec: 7f ff ec ea call 4001c994 <rtems_rfs_block_map_close> <== NOT EXECUTED
400215f0: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
400215f4: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
400215f8: 04 bf ff c0 ble 400214f8 <rtems_rfs_symlink+0x160> <== NOT EXECUTED
400215fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021600: 30 bf ff d1 b,a 40021544 <rtems_rfs_symlink+0x1ac> <== NOT EXECUTED
40021604 <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)
{
40021604: 9d e3 bf 18 save %sp, -232, %sp
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
40021608: 90 10 20 04 mov 4, %o0
4002160c: 7f ff ce a6 call 400150a4 <rtems_rfs_trace>
40021610: 92 10 20 00 clr %o1
40021614: 80 8a 20 ff btst 0xff, %o0
40021618: 12 80 00 17 bne 40021674 <rtems_rfs_symlink_read+0x70> <== NEVER TAKEN
4002161c: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
40021620: 90 10 00 18 mov %i0, %o0
40021624: 92 10 00 19 mov %i1, %o1
40021628: 94 07 bf 88 add %fp, -120, %o2
4002162c: 7f ff c7 f7 call 40013608 <rtems_rfs_inode_open>
40021630: 96 10 20 01 mov 1, %o3
if (rc)
40021634: ba 92 20 00 orcc %o0, 0, %i5
40021638: 12 80 00 0d bne 4002166c <rtems_rfs_symlink_read+0x68> <== NEVER TAKEN
4002163c: d2 07 bf 94 ld [ %fp + -108 ], %o1
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
40021640: 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);
40021644: c4 0a 60 02 ldub [ %o1 + 2 ], %g2
40021648: 85 28 a0 08 sll %g2, 8, %g2
4002164c: 84 08 80 01 and %g2, %g1, %g2
40021650: 03 00 00 28 sethi %hi(0xa000), %g1
40021654: 80 a0 80 01 cmp %g2, %g1
40021658: 02 80 00 0c be 40021688 <rtems_rfs_symlink_read+0x84> <== ALWAYS TAKEN
4002165c: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_close (fs, &inode);
40021660: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
40021664: 7f ff c8 61 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40021668: ba 10 20 16 mov 0x16, %i5 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
4002166c: 81 c7 e0 08 ret
40021670: 91 e8 00 1d restore %g0, %i5, %o0
{
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
40021674: 11 10 00 e5 sethi %hi(0x40039400), %o0 <== NOT EXECUTED
40021678: 40 00 0e c1 call 4002517c <printf> <== NOT EXECUTED
4002167c: 90 12 20 28 or %o0, 0x28, %o0 ! 40039428 <CSWTCH.2+0x1638><== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
40021680: 10 bf ff e9 b 40021624 <rtems_rfs_symlink_read+0x20> <== NOT EXECUTED
40021684: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
40021688: d4 0a 60 0a ldub [ %o1 + 0xa ], %o2
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
4002168c: c2 0a 60 0b ldub [ %o1 + 0xb ], %g1
40021690: 95 2a a0 08 sll %o2, 8, %o2
40021694: 94 10 40 0a or %g1, %o2, %o2
40021698: 80 a2 80 1b cmp %o2, %i3
4002169c: 38 80 00 02 bgu,a 400216a4 <rtems_rfs_symlink_read+0xa0>
400216a0: 94 10 00 1b mov %i3, %o2
400216a4: 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);
400216a8: c8 0a 60 0c ldub [ %o1 + 0xc ], %g4
400216ac: c4 0a 60 0d ldub [ %o1 + 0xd ], %g2
400216b0: c6 0a 60 0f ldub [ %o1 + 0xf ], %g3
400216b4: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
400216b8: 89 29 20 18 sll %g4, 0x18, %g4
400216bc: 85 28 a0 10 sll %g2, 0x10, %g2
400216c0: 83 28 60 08 sll %g1, 8, %g1
400216c4: 84 11 00 02 or %g4, %g2, %g2
400216c8: 84 10 80 03 or %g2, %g3, %g2
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
400216cc: 80 90 80 01 orcc %g2, %g1, %g0
400216d0: 12 80 00 0a bne 400216f8 <rtems_rfs_symlink_read+0xf4> <== NEVER TAKEN
400216d4: 90 10 00 18 mov %i0, %o0
{
memcpy (path, inode.node->data.name, *length);
400216d8: 90 10 00 1a mov %i2, %o0
400216dc: 40 00 0d 9b call 40024d48 <memcpy>
400216e0: 92 02 60 1c add %o1, 0x1c, %o1
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
400216e4: 90 10 00 18 mov %i0, %o0
400216e8: 7f ff c8 40 call 400137e8 <rtems_rfs_inode_close>
400216ec: 92 07 bf 88 add %fp, -120, %o1
400216f0: 10 bf ff df b 4002166c <rtems_rfs_symlink_read+0x68>
400216f4: ba 10 00 08 mov %o0, %i5
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
char* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
400216f8: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
400216fc: 7f ff ec 45 call 4001c810 <rtems_rfs_block_map_open> <== NOT EXECUTED
40021700: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
40021704: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
if (rc > 0)
40021708: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4002170c: 04 80 00 05 ble 40021720 <rtems_rfs_symlink_read+0x11c> <== NOT EXECUTED
40021710: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
40021714: 7f ff c8 35 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40021718: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
4002171c: 30 bf ff d4 b,a 4002166c <rtems_rfs_symlink_read+0x68> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
40021720: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40021724: 94 10 20 00 clr %o2 <== NOT EXECUTED
40021728: 96 10 20 00 clr %o3 <== NOT EXECUTED
4002172c: 7f ff ed 68 call 4001cccc <rtems_rfs_block_map_seek> <== NOT EXECUTED
40021730: 98 07 bf 78 add %fp, -136, %o4 <== NOT EXECUTED
if (rc > 0)
40021734: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40021738: 04 80 00 09 ble 4002175c <rtems_rfs_symlink_read+0x158> <== NOT EXECUTED
4002173c: d4 07 bf 78 ld [ %fp + -136 ], %o2 <== NOT EXECUTED
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
40021740: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40021744: 7f ff ec 94 call 4001c994 <rtems_rfs_block_map_close> <== NOT EXECUTED
40021748: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
4002174c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021750: 7f ff c8 26 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40021754: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
40021758: 30 bf ff c5 b,a 4002166c <rtems_rfs_symlink_read+0x68> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
4002175c: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
40021760: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
40021764: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
40021768: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4002176c: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
40021770: 7f ff f0 2c call 4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40021774: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
40021778: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4002177c: 34 bf ff f2 bg,a 40021744 <rtems_rfs_symlink_read+0x140> <== NOT EXECUTED
40021780: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
40021784: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
40021788: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
4002178c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
40021790: 40 00 0d 6e call 40024d48 <memcpy> <== NOT EXECUTED
40021794: 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);
40021798: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
4002179c: 7f ff ef a7 call 4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400217a0: 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);
400217a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
400217a8: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
400217ac: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
400217b0: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
400217b4: 7f ff ec 78 call 4001c994 <rtems_rfs_block_map_close> <== NOT EXECUTED
400217b8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
400217bc: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
400217c0: 04 bf ff c9 ble 400216e4 <rtems_rfs_symlink_read+0xe0> <== NOT EXECUTED
400217c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400217c8: 30 bf ff d3 b,a 40021714 <rtems_rfs_symlink_read+0x110> <== NOT EXECUTED
400150e4 <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;
400150e4: 03 10 01 2b sethi %hi(0x4004ac00), %g1 <== NOT EXECUTED
400150e8: c4 18 60 90 ldd [ %g1 + 0x90 ], %g2 ! 4004ac90 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
400150ec: 98 28 80 08 andn %g2, %o0, %o4 <== NOT EXECUTED
400150f0: 9a 28 c0 09 andn %g3, %o1, %o5 <== NOT EXECUTED
return state;
}
400150f4: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags &= ~mask;
400150f8: d8 38 60 90 std %o4, [ %g1 + 0x90 ] <== NOT EXECUTED
return state;
}
400150fc: 81 c3 e0 08 retl <== NOT EXECUTED
40015100: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
400150c4 <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;
400150c4: 03 10 01 2b sethi %hi(0x4004ac00), %g1 <== NOT EXECUTED
400150c8: c4 18 60 90 ldd [ %g1 + 0x90 ], %g2 ! 4004ac90 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
400150cc: 98 12 00 02 or %o0, %g2, %o4 <== NOT EXECUTED
400150d0: 9a 12 40 03 or %o1, %g3, %o5 <== NOT EXECUTED
return state;
}
400150d4: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
rtems_rfs_trace_flags |= mask;
400150d8: d8 38 60 90 std %o4, [ %g1 + 0x90 ] <== NOT EXECUTED
return state;
}
400150dc: 81 c3 e0 08 retl <== NOT EXECUTED
400150e0: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
40015104 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
40015104: 9d e3 bf 00 save %sp, -256, %sp <== NOT EXECUTED
const char* table[] =
40015108: 13 10 00 dd sethi %hi(0x40037400), %o1 <== NOT EXECUTED
4001510c: a8 07 bf 64 add %fp, -156, %l4 <== NOT EXECUTED
40015110: 92 12 61 0c or %o1, 0x10c, %o1 <== NOT EXECUTED
40015114: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
40015118: 40 00 3f 0c call 40024d48 <memcpy> <== NOT EXECUTED
4001511c: 94 10 20 9c mov 0x9c, %o2 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40015120: 80 a6 20 01 cmp %i0, 1 <== NOT EXECUTED
40015124: 04 80 00 3f ble 40015220 <rtems_rfs_trace_shell_command+0x11c><== NOT EXECUTED
40015128: 01 00 00 00 nop <== NOT EXECUTED
{
if (argv[arg][0] == '-')
4001512c: e4 06 60 04 ld [ %i1 + 4 ], %l2 <== NOT EXECUTED
40015130: c2 4c 80 00 ldsb [ %l2 ], %g1 <== NOT EXECUTED
40015134: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
40015138: 02 80 00 6e be 400152f0 <rtems_rfs_trace_shell_command+0x1ec><== NOT EXECUTED
4001513c: 2f 10 01 2b sethi %hi(0x4004ac00), %l7 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40015140: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
40015144: f8 1d e0 90 ldd [ %l7 + 0x90 ], %i4 <== NOT EXECUTED
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
40015148: aa 10 20 01 mov 1, %l5 <== NOT EXECUTED
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
4001514c: b4 10 20 00 clr %i2 <== NOT EXECUTED
40015150: b6 10 20 00 clr %i3 <== NOT EXECUTED
"file-close",
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
40015154: a0 10 20 00 clr %l0 <== NOT EXECUTED
40015158: a2 10 20 00 clr %l1 <== NOT EXECUTED
4001515c: 10 80 00 10 b 4001519c <rtems_rfs_trace_shell_command+0x98><== NOT EXECUTED
40015160: ae 15 e0 90 or %l7, 0x90, %l7 <== NOT EXECUTED
40015164: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
40015168: aa 10 20 00 clr %l5 <== NOT EXECUTED
4001516c: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
40015170: ba 2f 40 1b andn %i5, %i3, %i5 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40015174: a6 04 e0 01 inc %l3 <== NOT EXECUTED
40015178: 80 a4 c0 18 cmp %l3, %i0 <== NOT EXECUTED
4001517c: 02 80 00 29 be 40015220 <rtems_rfs_trace_shell_command+0x11c><== NOT EXECUTED
40015180: f8 3d c0 00 std %i4, [ %l7 ] <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
40015184: 83 2c e0 02 sll %l3, 2, %g1 <== NOT EXECUTED
int arg;
int t;
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
40015188: e4 06 40 01 ld [ %i1 + %g1 ], %l2 <== NOT EXECUTED
4001518c: c2 4c 80 00 ldsb [ %l2 ], %g1 <== NOT EXECUTED
40015190: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
40015194: 22 80 00 58 be,a 400152f4 <rtems_rfs_trace_shell_command+0x1f0><== NOT EXECUTED
40015198: c2 4c a0 01 ldsb [ %l2 + 1 ], %g1 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
4001519c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
400151a0: 13 10 00 d5 sethi %hi(0x40035400), %o1 <== NOT EXECUTED
400151a4: 40 00 42 7d call 40025b98 <strcmp> <== NOT EXECUTED
400151a8: 92 12 60 68 or %o1, 0x68, %o1 ! 40035468 <Callbacks.6428+0x220><== NOT EXECUTED
400151ac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400151b0: 22 80 00 02 be,a 400151b8 <rtems_rfs_trace_shell_command+0xb4><== NOT EXECUTED
400151b4: aa 10 20 01 mov 1, %l5 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
400151b8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
400151bc: 13 10 00 dc sethi %hi(0x40037000), %o1 <== NOT EXECUTED
400151c0: 40 00 42 76 call 40025b98 <strcmp> <== NOT EXECUTED
400151c4: 92 12 62 a0 or %o1, 0x2a0, %o1 ! 400372a0 <rtems_rfs_rtems_eval_config+0xa0><== NOT EXECUTED
400151c8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400151cc: 22 bf ff e6 be,a 40015164 <rtems_rfs_trace_shell_command+0x60><== NOT EXECUTED
400151d0: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
400151d4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
400151d8: 13 10 00 dc sethi %hi(0x40037000), %o1 <== NOT EXECUTED
400151dc: 40 00 42 6f call 40025b98 <strcmp> <== NOT EXECUTED
400151e0: 92 12 62 a8 or %o1, 0x2a8, %o1 ! 400372a8 <rtems_rfs_rtems_eval_config+0xa8><== NOT EXECUTED
400151e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400151e8: 12 80 00 13 bne 40015234 <rtems_rfs_trace_shell_command+0x130><== NOT EXECUTED
400151ec: ac 10 20 00 clr %l6 <== NOT EXECUTED
{
if (set)
400151f0: 80 8d 60 ff btst 0xff, %l5 <== NOT EXECUTED
400151f4: 22 80 00 23 be,a 40015280 <rtems_rfs_trace_shell_command+0x17c><== NOT EXECUTED
400151f8: 35 3f ff ff sethi %hi(0xfffffc00), %i2 <== NOT EXECUTED
400151fc: b8 3e a0 00 xnor %i2, 0, %i4 <== NOT EXECUTED
40015200: ba 3e e0 00 xnor %i3, 0, %i5 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
40015204: f8 3d c0 00 std %i4, [ %l7 ] <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
40015208: 21 3f ff ff sethi %hi(0xfffffc00), %l0 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
4001520c: a6 04 e0 01 inc %l3 <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
40015210: a0 14 23 ff or %l0, 0x3ff, %l0 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
40015214: 80 a4 c0 18 cmp %l3, %i0 <== NOT EXECUTED
40015218: 12 bf ff db bne 40015184 <rtems_rfs_trace_shell_command+0x80><== NOT EXECUTED
4001521c: a2 10 00 10 mov %l0, %l1 <== NOT EXECUTED
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
40015220: 81 c7 e0 08 ret <== NOT EXECUTED
40015224: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
40015228: 80 a5 a0 27 cmp %l6, 0x27 <== NOT EXECUTED
4001522c: 22 80 00 11 be,a 40015270 <rtems_rfs_trace_shell_command+0x16c><== NOT EXECUTED
40015230: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
40015234: 85 2d a0 02 sll %l6, 2, %g2 <== NOT EXECUTED
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
40015238: d2 05 00 02 ld [ %l4 + %g2 ], %o1 <== NOT EXECUTED
4001523c: 40 00 42 57 call 40025b98 <strcmp> <== NOT EXECUTED
40015240: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
40015244: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40015248: 32 bf ff f8 bne,a 40015228 <rtems_rfs_trace_shell_command+0x124><== NOT EXECUTED
4001524c: ac 05 a0 01 inc %l6 <== NOT EXECUTED
{
if (set)
40015250: 80 8d 60 ff btst 0xff, %l5 <== NOT EXECUTED
40015254: 02 80 00 10 be 40015294 <rtems_rfs_trace_shell_command+0x190><== NOT EXECUTED
40015258: 80 8d a0 20 btst 0x20, %l6 <== NOT EXECUTED
set_value = 1ULL << t;
4001525c: 12 80 00 1e bne 400152d4 <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED
40015260: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40015264: a0 10 20 00 clr %l0 <== NOT EXECUTED
40015268: a3 28 40 16 sll %g1, %l6, %l1 <== NOT EXECUTED
4001526c: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
40015270: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
40015274: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
40015278: 10 bf ff bf b 40015174 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
4001527c: ba 2f 40 1b andn %i5, %i3, %i5 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
40015280: b8 10 20 00 clr %i4 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
40015284: b4 16 a3 ff or %i2, 0x3ff, %i2 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
40015288: ba 10 20 00 clr %i5 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
4001528c: 10 bf ff ba b 40015174 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
40015290: b6 10 00 1a mov %i2, %i3 <== NOT EXECUTED
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
set_value = 1ULL << t;
else
clear_value = 1ULL << t;
40015294: 12 80 00 09 bne 400152b8 <rtems_rfs_trace_shell_command+0x1b4><== NOT EXECUTED
40015298: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4001529c: b4 10 20 00 clr %i2 <== NOT EXECUTED
400152a0: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
400152a4: b7 28 40 16 sll %g1, %l6, %i3 <== NOT EXECUTED
400152a8: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
400152ac: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
400152b0: 10 bf ff b1 b 40015174 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
400152b4: ba 2f 40 1b andn %i5, %i3, %i5 <== NOT EXECUTED
400152b8: b6 10 20 00 clr %i3 <== NOT EXECUTED
400152bc: b5 28 40 16 sll %g1, %l6, %i2 <== NOT EXECUTED
400152c0: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
400152c4: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
400152c8: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
400152cc: 10 bf ff aa b 40015174 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
400152d0: ba 2f 40 1b andn %i5, %i3, %i5 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
set_value = 1ULL << t;
400152d4: a2 10 20 00 clr %l1 <== NOT EXECUTED
400152d8: a1 28 40 16 sll %g1, %l6, %l0 <== NOT EXECUTED
400152dc: ba 14 40 1d or %l1, %i5, %i5 <== NOT EXECUTED
400152e0: b8 14 00 1c or %l0, %i4, %i4 <== NOT EXECUTED
400152e4: ba 2f 40 1b andn %i5, %i3, %i5 <== NOT EXECUTED
400152e8: 10 bf ff a3 b 40015174 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
400152ec: b8 2f 00 1a andn %i4, %i2, %i4 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
400152f0: c2 4c a0 01 ldsb [ %l2 + 1 ], %g1 <== NOT EXECUTED
400152f4: 80 a0 60 68 cmp %g1, 0x68 <== NOT EXECUTED
400152f8: 02 80 00 09 be 4001531c <rtems_rfs_trace_shell_command+0x218><== NOT EXECUTED
400152fc: 80 a0 60 6c cmp %g1, 0x6c <== NOT EXECUTED
40015300: 02 80 00 0e be 40015338 <rtems_rfs_trace_shell_command+0x234><== NOT EXECUTED
40015304: 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");
40015308: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
4001530c: 40 00 40 34 call 400253dc <puts> <== NOT EXECUTED
40015310: 90 12 22 88 or %o0, 0x288, %o0 ! 40037288 <rtems_rfs_rtems_eval_config+0x88><== NOT EXECUTED
40015314: 81 c7 e0 08 ret <== NOT EXECUTED
40015318: 81 e8 00 00 restore <== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
4001531c: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
40015320: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
return 0;
40015324: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
40015328: 40 00 3f 95 call 4002517c <printf> <== NOT EXECUTED
4001532c: 90 12 22 30 or %o0, 0x230, %o0 <== NOT EXECUTED
40015330: 81 c7 e0 08 ret <== NOT EXECUTED
40015334: 81 e8 00 00 restore <== NOT EXECUTED
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
40015338: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
4001533c: 11 10 00 dc sethi %hi(0x40037000), %o0 <== NOT EXECUTED
40015340: 3b 10 00 dc sethi %hi(0x40037000), %i5 <== NOT EXECUTED
40015344: 90 12 22 58 or %o0, 0x258, %o0 <== NOT EXECUTED
40015348: 40 00 3f 8d call 4002517c <printf> <== NOT EXECUTED
4001534c: b8 10 00 1e mov %fp, %i4 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
40015350: ba 17 62 80 or %i5, 0x280, %i5 <== NOT EXECUTED
40015354: d2 05 00 00 ld [ %l4 ], %o1 <== NOT EXECUTED
40015358: 40 00 3f 89 call 4002517c <printf> <== NOT EXECUTED
4001535c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40015360: a8 05 20 04 add %l4, 4, %l4 <== NOT EXECUTED
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
40015364: 80 a5 00 1c cmp %l4, %i4 <== NOT EXECUTED
40015368: 32 bf ff fc bne,a 40015358 <rtems_rfs_trace_shell_command+0x254><== NOT EXECUTED
4001536c: d2 05 00 00 ld [ %l4 ], %o1 <== NOT EXECUTED
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
40015370: 81 c7 e0 08 ret <== NOT EXECUTED
40015374: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40015378: 40 01 63 f4 call 4006e348 <__end+0x225f8> <== NOT EXECUTED
4001537c: 40 01 65 90 call 4006e9bc <__end+0x22c6c> <== NOT EXECUTED
40015380: 40 01 65 88 call 4006e9a0 <__end+0x22c50> <== NOT EXECUTED
40015384: 40 01 65 74 call 4006e954 <__end+0x22c04> <== NOT EXECUTED
40015388: 40 01 65 74 call 4006e958 <__end+0x22c08> <== NOT EXECUTED
4001538c: 40 01 65 74 call 4006e95c <__end+0x22c0c> <== NOT EXECUTED
40015390: 40 01 65 74 call 4006e960 <__end+0x22c10> <== NOT EXECUTED
40015394: 40 01 65 40 call 4006e894 <__end+0x22b44> <== NOT EXECUTED
40015398: 40 01 65 2c call 4006e848 <__end+0x22af8> <== NOT EXECUTED
4001539c: 40 01 65 2c call 4006e84c <__end+0x22afc> <== NOT EXECUTED
400153a0: 40 01 65 2c call 4006e850 <__end+0x22b00> <== NOT EXECUTED
400153a4: 40 01 64 3c call 4006e494 <__end+0x22744> <== NOT EXECUTED
400153a8: 40 01 64 2c call 4006e458 <__end+0x22708> <== NOT EXECUTED
400153ac: 40 01 64 2c call 4006e45c <__end+0x2270c> <== NOT EXECUTED
400153b0: 40 01 65 08 call 4006e7d0 <__end+0x22a80> <== NOT EXECUTED
400153b4: 40 01 65 08 call 4006e7d4 <__end+0x22a84> <== NOT EXECUTED
400153b8: 40 01 65 08 call 4006e7d8 <__end+0x22a88> <== NOT EXECUTED
400153bc: 40 01 65 08 call 4006e7dc <__end+0x22a8c> <== NOT EXECUTED
400153c0: 40 01 64 d4 call 4006e710 <__end+0x229c0> <== NOT EXECUTED
400153c4: 40 01 64 c0 call 4006e6c4 <__end+0x22974> <== NOT EXECUTED
400153c8: 40 01 64 c0 call 4006e6c8 <__end+0x22978> <== NOT EXECUTED
400153cc: 40 01 64 c0 call 4006e6cc <__end+0x2297c> <== NOT EXECUTED
400153d0: 40 01 7a 40 call 40073cd0 <__end+0x27f80> <== NOT EXECUTED
400153d4: 40 01 7a 40 call 40073cd4 <__end+0x27f84> <== NOT EXECUTED
400153d8: 40 01 7b 68 call 40074178 <__end+0x28428> <== NOT EXECUTED
400153dc: 40 01 7b 90 call 4007421c <__end+0x284cc> <== NOT EXECUTED
400153e0: 40 01 7b 90 call 40074220 <__end+0x284d0> <== NOT EXECUTED
400153e4: 40 01 7b 90 call 40074224 <__end+0x284d4> <== NOT EXECUTED
400153e8: 40 01 7a 40 call 40073ce8 <__end+0x27f98> <== NOT EXECUTED
400153ec: 40 01 7b 58 call 4007414c <__end+0x283fc> <== NOT EXECUTED
400153f0: 40 01 7b 50 call 40074130 <__end+0x283e0> <== NOT EXECUTED
400153f4: 40 01 7b 98 call 40074254 <__end+0x28504> <== NOT EXECUTED
400153f8: 40 01 7a 40 call 40073cf8 <__end+0x27fa8> <== NOT EXECUTED
40020f68 <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)
{
40020f68: 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))
40020f6c: 90 10 20 00 clr %o0
40020f70: 7f ff d0 4d call 400150a4 <rtems_rfs_trace>
40020f74: 13 00 80 00 sethi %hi(0x2000000), %o1
40020f78: 80 8a 20 ff btst 0xff, %o0
40020f7c: 12 80 00 4a bne 400210a4 <rtems_rfs_unlink+0x13c> <== NEVER TAKEN
40020f80: 92 10 00 19 mov %i1, %o1
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
40020f84: 90 10 00 18 mov %i0, %o0
40020f88: 92 10 00 1a mov %i2, %o1
40020f8c: 94 07 bf d8 add %fp, -40, %o2
40020f90: 7f ff c9 9e call 40013608 <rtems_rfs_inode_open>
40020f94: 96 10 20 01 mov 1, %o3
if (rc)
40020f98: ba 92 20 00 orcc %o0, 0, %i5
40020f9c: 12 80 00 19 bne 40021000 <rtems_rfs_unlink+0x98> <== NEVER TAKEN
40020fa0: 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));
40020fa4: 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);
40020fa8: c2 08 60 02 ldub [ %g1 + 2 ], %g1
40020fac: 83 28 60 08 sll %g1, 8, %g1
40020fb0: 82 08 40 02 and %g1, %g2, %g1
40020fb4: 05 00 00 10 sethi %hi(0x4000), %g2
40020fb8: 82 18 40 02 xor %g1, %g2, %g1
if (dir)
40020fbc: 80 a0 00 01 cmp %g0, %g1
40020fc0: a0 60 3f ff subx %g0, -1, %l0
40020fc4: 80 a4 20 00 cmp %l0, 0
40020fc8: 02 80 00 12 be 40021010 <rtems_rfs_unlink+0xa8>
40020fcc: 80 a7 20 00 cmp %i4, 0
{
switch (dir_mode)
40020fd0: 12 80 00 0e bne 40021008 <rtems_rfs_unlink+0xa0> <== ALWAYS TAKEN
40020fd4: 80 a7 20 01 cmp %i4, 1
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40020fd8: 90 10 20 00 clr %o0 <== NOT EXECUTED
40020fdc: 7f ff d0 32 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40020fe0: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
40020fe4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40020fe8: 12 80 00 5a bne 40021150 <rtems_rfs_unlink+0x1e8> <== NOT EXECUTED
40020fec: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
40020ff0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40020ff4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40020ff8: 7f ff c9 fc call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40020ffc: 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;
}
40021000: 81 c7 e0 08 ret
40021004: 91 e8 00 1d restore %g0, %i5, %o0
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
if (dir)
{
switch (dir_mode)
40021008: 02 80 00 3f be 40021104 <rtems_rfs_unlink+0x19c> <== ALWAYS TAKEN
4002100c: 90 10 00 18 mov %i0, %o0
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
40021010: 90 10 00 18 mov %i0, %o0
40021014: 92 10 00 19 mov %i1, %o1
40021018: 94 07 bf b0 add %fp, -80, %o2
4002101c: 7f ff c9 7b call 40013608 <rtems_rfs_inode_open>
40021020: 96 10 20 01 mov 1, %o3
if (rc)
40021024: ba 92 20 00 orcc %o0, 0, %i5
40021028: 12 80 00 25 bne 400210bc <rtems_rfs_unlink+0x154> <== NEVER TAKEN
4002102c: 90 10 20 00 clr %o0
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
40021030: 90 10 00 18 mov %i0, %o0
40021034: 92 07 bf b0 add %fp, -80, %o1
40021038: 94 10 00 1a mov %i2, %o2
4002103c: 7f ff f6 43 call 4001e948 <rtems_rfs_dir_del_entry>
40021040: 96 10 00 1b mov %i3, %o3
if (rc > 0)
40021044: ba 92 20 00 orcc %o0, 0, %i5
40021048: 04 80 00 46 ble 40021160 <rtems_rfs_unlink+0x1f8> <== ALWAYS TAKEN
4002104c: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40021050: 7f ff d0 15 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
40021054: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
40021058: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
4002105c: 02 80 00 0a be 40021084 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
40021060: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
40021064: 40 00 14 90 call 400262a4 <strerror> <== NOT EXECUTED
40021068: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4002106c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40021070: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40021074: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
40021078: 40 00 10 41 call 4002517c <printf> <== NOT EXECUTED
4002107c: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 400392c8 <CSWTCH.2+0x14d8><== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
40021080: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
40021084: 7f ff c9 d9 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40021088: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
4002108c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40021090: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
40021094: 7f ff c9 d5 call 400137e8 <rtems_rfs_inode_close> <== NOT EXECUTED
40021098: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
4002109c: 81 c7 e0 08 ret <== NOT EXECUTED
400210a0: 81 e8 00 00 restore <== NOT EXECUTED
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
400210a4: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
400210a8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
400210ac: 40 00 10 34 call 4002517c <printf> <== NOT EXECUTED
400210b0: 90 12 22 28 or %o0, 0x228, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
400210b4: 10 bf ff b5 b 40020f88 <rtems_rfs_unlink+0x20> <== NOT EXECUTED
400210b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
if (rc)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400210bc: 7f ff cf fa call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
400210c0: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
400210c4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400210c8: 22 80 00 0a be,a 400210f0 <rtems_rfs_unlink+0x188> <== NOT EXECUTED
400210cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
400210d0: 40 00 14 75 call 400262a4 <strerror> <== NOT EXECUTED
400210d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400210d8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400210dc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400210e0: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
400210e4: 40 00 10 26 call 4002517c <printf> <== NOT EXECUTED
400210e8: 90 12 22 98 or %o0, 0x298, %o0 ! 40039298 <CSWTCH.2+0x14a8><== 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);
400210ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400210f0: 92 07 bf d8 add %fp, -40, %o1
400210f4: 7f ff c9 bd call 400137e8 <rtems_rfs_inode_close>
400210f8: b0 10 00 1d mov %i5, %i0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
400210fc: 81 c7 e0 08 ret
40021100: 81 e8 00 00 restore
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
return EISDIR;
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
40021104: 7f ff f8 14 call 4001f154 <rtems_rfs_dir_empty>
40021108: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4002110c: ba 92 20 00 orcc %o0, 0, %i5
40021110: 04 bf ff c0 ble 40021010 <rtems_rfs_unlink+0xa8>
40021114: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40021118: 7f ff cf e3 call 400150a4 <rtems_rfs_trace>
4002111c: 13 00 80 00 sethi %hi(0x2000000), %o1
40021120: 80 8a 20 ff btst 0xff, %o0
40021124: 22 bf ff f3 be,a 400210f0 <rtems_rfs_unlink+0x188> <== ALWAYS TAKEN
40021128: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
4002112c: 40 00 14 5e call 400262a4 <strerror> <== NOT EXECUTED
40021130: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021134: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40021138: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4002113c: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
40021140: 40 00 10 0f call 4002517c <printf> <== NOT EXECUTED
40021144: 90 12 22 78 or %o0, 0x278, %o0 ! 40039278 <CSWTCH.2+0x1488><== 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);
40021148: 10 bf ff ea b 400210f0 <rtems_rfs_unlink+0x188> <== NOT EXECUTED
4002114c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
switch (dir_mode)
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link is a directory\n");
40021150: 40 00 10 a3 call 400253dc <puts> <== NOT EXECUTED
40021154: 90 12 22 58 or %o0, 0x258, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
40021158: 10 bf ff a7 b 40020ff4 <rtems_rfs_unlink+0x8c> <== NOT EXECUTED
4002115c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
40021160: c4 07 bf e4 ld [ %fp + -28 ], %g2
if (links == 0xffff)
links = 0;
40021164: 07 3f ff c0 sethi %hi(0xffff0000), %g3
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
40021168: c2 08 80 00 ldub [ %g2 ], %g1
4002116c: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
40021170: 83 28 60 08 sll %g1, 8, %g1
40021174: 82 10 40 02 or %g1, %g2, %g1
if (links == 0xffff)
40021178: 85 28 60 10 sll %g1, 0x10, %g2
4002117c: 85 30 a0 10 srl %g2, 0x10, %g2
links = 0;
40021180: 84 38 c0 02 xnor %g3, %g2, %g2
40021184: 80 a0 00 02 cmp %g0, %g2
40021188: ba 60 20 00 subx %g0, 0, %i5
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
4002118c: 13 00 80 00 sethi %hi(0x2000000), %o1
40021190: 7f ff cf c5 call 400150a4 <rtems_rfs_trace>
40021194: ba 08 40 1d and %g1, %i5, %i5
40021198: 80 8a 20 ff btst 0xff, %o0
4002119c: 12 80 00 22 bne 40021224 <rtems_rfs_unlink+0x2bc> <== NEVER TAKEN
400211a0: b9 2f 60 10 sll %i5, 0x10, %i4
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
if (links > 1)
400211a4: b9 37 20 10 srl %i4, 0x10, %i4
400211a8: 80 a7 20 01 cmp %i4, 1
400211ac: 08 80 00 39 bleu 40021290 <rtems_rfs_unlink+0x328>
400211b0: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
links--;
400211b4: 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);
400211b8: 85 37 60 08 srl %i5, 8, %g2
400211bc: c4 28 40 00 stb %g2, [ %g1 ]
400211c0: c2 07 bf e4 ld [ %fp + -28 ], %g1
400211c4: fa 28 60 01 stb %i5, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
400211c8: 82 10 20 01 mov 1, %g1
400211cc: c2 2f bf e8 stb %g1, [ %fp + -24 ]
links--;
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
400211d0: 90 07 bf b0 add %fp, -80, %o0
400211d4: 92 10 20 01 mov 1, %o1
400211d8: 7f ff c9 df call 40013954 <rtems_rfs_inode_time_stamp_now>
400211dc: 94 10 20 01 mov 1, %o2
if (rc > 0)
400211e0: ba 92 20 00 orcc %o0, 0, %i5
400211e4: 04 80 00 17 ble 40021240 <rtems_rfs_unlink+0x2d8> <== ALWAYS TAKEN
400211e8: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400211ec: 7f ff cf ae call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
400211f0: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
400211f4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400211f8: 22 bf ff a3 be,a 40021084 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
400211fc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
40021200: 40 00 14 29 call 400262a4 <strerror> <== NOT EXECUTED
40021204: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021208: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4002120c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40021210: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
40021214: 40 00 0f da call 4002517c <printf> <== NOT EXECUTED
40021218: 90 12 23 50 or %o0, 0x350, %o0 ! 40039350 <CSWTCH.2+0x1560><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
4002121c: 10 bf ff 9a b 40021084 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
40021220: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
}
links = rtems_rfs_inode_get_links (&target_inode);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
40021224: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40021228: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
4002122c: 95 37 20 10 srl %i4, 0x10, %o2 <== NOT EXECUTED
40021230: 40 00 0f d3 call 4002517c <printf> <== NOT EXECUTED
40021234: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
if (links > 1)
40021238: 10 bf ff dc b 400211a8 <rtems_rfs_unlink+0x240> <== NOT EXECUTED
4002123c: b9 37 20 10 srl %i4, 0x10, %i4 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
40021240: 90 10 00 18 mov %i0, %o0
40021244: 7f ff c9 69 call 400137e8 <rtems_rfs_inode_close>
40021248: 92 07 bf b0 add %fp, -80, %o1
if (rc > 0)
4002124c: ba 92 20 00 orcc %o0, 0, %i5
40021250: 04 80 00 24 ble 400212e0 <rtems_rfs_unlink+0x378> <== ALWAYS TAKEN
40021254: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
40021258: 7f ff cf 93 call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
4002125c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
40021260: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021264: 22 bf ff a3 be,a 400210f0 <rtems_rfs_unlink+0x188> <== NOT EXECUTED
40021268: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
4002126c: 40 00 14 0e call 400262a4 <strerror> <== NOT EXECUTED
40021270: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021274: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40021278: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4002127c: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
40021280: 40 00 0f bf call 4002517c <printf> <== NOT EXECUTED
40021284: 90 12 23 88 or %o0, 0x388, %o0 ! 40039388 <CSWTCH.2+0x1598><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
40021288: 10 bf ff 9a b 400210f0 <rtems_rfs_unlink+0x188> <== NOT EXECUTED
4002128c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
40021290: 90 10 00 18 mov %i0, %o0
40021294: 7f ff c9 7b call 40013880 <rtems_rfs_inode_delete>
40021298: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
4002129c: ba 92 20 00 orcc %o0, 0, %i5
400212a0: 04 80 00 23 ble 4002132c <rtems_rfs_unlink+0x3c4> <== ALWAYS TAKEN
400212a4: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400212a8: 7f ff cf 7f call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
400212ac: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
400212b0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
400212b4: 22 bf ff 74 be,a 40021084 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
400212b8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
400212bc: 40 00 13 fa call 400262a4 <strerror> <== NOT EXECUTED
400212c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
400212c4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400212c8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400212cc: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
400212d0: 40 00 0f ab call 4002517c <printf> <== NOT EXECUTED
400212d4: 90 12 23 20 or %o0, 0x320, %o0 ! 40039320 <CSWTCH.2+0x1530><== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
400212d8: 10 bf ff 6b b 40021084 <rtems_rfs_unlink+0x11c> <== NOT EXECUTED
400212dc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
400212e0: 90 10 00 18 mov %i0, %o0
400212e4: 7f ff c9 41 call 400137e8 <rtems_rfs_inode_close>
400212e8: 92 07 bf d8 add %fp, -40, %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
400212ec: ba 92 20 00 orcc %o0, 0, %i5
400212f0: 04 bf ff 44 ble 40021000 <rtems_rfs_unlink+0x98> <== ALWAYS TAKEN
400212f4: 90 10 20 00 clr %o0
400212f8: 7f ff cf 6b call 400150a4 <rtems_rfs_trace> <== NOT EXECUTED
400212fc: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
40021300: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
40021304: 02 bf ff 3f be 40021000 <rtems_rfs_unlink+0x98> <== NOT EXECUTED
40021308: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
4002130c: 40 00 13 e6 call 400262a4 <strerror> <== NOT EXECUTED
40021310: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40021314: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40021318: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4002131c: 11 10 00 e4 sethi %hi(0x40039000), %o0 <== NOT EXECUTED
40021320: 40 00 0f 97 call 4002517c <printf> <== NOT EXECUTED
40021324: 90 12 23 c0 or %o0, 0x3c0, %o0 ! 400393c0 <CSWTCH.2+0x15d0><== NOT EXECUTED
40021328: 30 bf ff 36 b,a 40021000 <rtems_rfs_unlink+0x98> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
4002132c: 80 a4 20 00 cmp %l0, 0
40021330: 02 bf ff a9 be 400211d4 <rtems_rfs_unlink+0x26c>
40021334: 90 07 bf b0 add %fp, -80, %o0
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
40021338: c4 07 bf bc ld [ %fp + -68 ], %g2
if (links == 0xffff)
4002133c: 3b 00 00 3f sethi %hi(0xfc00), %i5
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
40021340: c2 08 a0 01 ldub [ %g2 + 1 ], %g1
40021344: c6 08 80 00 ldub [ %g2 ], %g3
if (links == 0xffff)
40021348: ba 17 63 ff or %i5, 0x3ff, %i5
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
4002134c: 87 28 e0 08 sll %g3, 8, %g3
40021350: 86 10 c0 01 or %g3, %g1, %g3
if (links == 0xffff)
40021354: 89 28 e0 10 sll %g3, 0x10, %g4
40021358: 89 31 20 10 srl %g4, 0x10, %g4
4002135c: 80 a1 00 1d cmp %g4, %i5
40021360: 02 80 00 0c be 40021390 <rtems_rfs_unlink+0x428> <== NEVER TAKEN
40021364: 82 10 00 03 mov %g3, %g1
{
links = rtems_rfs_inode_get_links (&parent_inode);
if (links > 1)
40021368: 80 a1 20 01 cmp %g4, 1
4002136c: 38 80 00 02 bgu,a 40021374 <rtems_rfs_unlink+0x40c>
40021370: 82 00 ff ff add %g3, -1, %g1
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
40021374: 87 30 60 08 srl %g1, 8, %g3
40021378: c6 28 80 00 stb %g3, [ %g2 ]
4002137c: c4 07 bf bc ld [ %fp + -68 ], %g2
40021380: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
40021384: 82 10 20 01 mov 1, %g1
40021388: 10 bf ff 92 b 400211d0 <rtems_rfs_unlink+0x268>
4002138c: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
links = 0;
40021390: 10 bf ff f9 b 40021374 <rtems_rfs_unlink+0x40c> <== NOT EXECUTED
40021394: 82 10 20 00 clr %g1 <== NOT EXECUTED
40024844 <rtems_shell_rfs_format>:
return 1;
}
int
rtems_shell_rfs_format (int argc, char* argv[])
{
40024844: 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));
40024848: c0 27 bf e8 clr [ %fp + -24 ] <== NOT EXECUTED
4002484c: c0 27 bf ec clr [ %fp + -20 ] <== NOT EXECUTED
40024850: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED
40024854: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
40024858: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
4002485c: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
40024860: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
40024864: b8 10 20 00 clr %i4 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
40024868: 37 10 00 8c sethi %hi(0x40023000), %i3 <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
4002486c: 80 a6 20 01 cmp %i0, 1 <== NOT EXECUTED
40024870: 14 80 00 0a bg 40024898 <rtems_shell_rfs_format+0x54> <== NOT EXECUTED
40024874: b4 10 20 01 mov 1, %i2 <== NOT EXECUTED
}
}
}
if (!driver) {
printf ("error: no driver name provided\n");
40024878: 10 80 00 69 b 40024a1c <rtems_shell_rfs_format+0x1d8> <== NOT EXECUTED
4002487c: 11 10 01 7c sethi %hi(0x4005f000), %o0 <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
40024880: 12 80 00 55 bne 400249d4 <rtems_shell_rfs_format+0x190> <== NOT EXECUTED
40024884: b8 10 00 09 mov %o1, %i4 <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
40024888: ba 07 60 01 inc %i5 <== NOT EXECUTED
4002488c: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
40024890: 04 80 00 1d ble 40024904 <rtems_shell_rfs_format+0xc0> <== NOT EXECUTED
40024894: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
40024898: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
4002489c: d2 06 40 01 ld [ %i1 + %g1 ], %o1 <== NOT EXECUTED
400248a0: c2 4a 40 00 ldsb [ %o1 ], %g1 <== NOT EXECUTED
400248a4: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
400248a8: 12 bf ff f6 bne 40024880 <rtems_shell_rfs_format+0x3c> <== NOT EXECUTED
400248ac: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
{
switch (argv[arg][1])
400248b0: c2 0a 60 01 ldub [ %o1 + 1 ], %g1 <== NOT EXECUTED
400248b4: 82 00 7f b7 add %g1, -73, %g1 <== NOT EXECUTED
400248b8: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED
400248bc: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
400248c0: 08 80 00 08 bleu 400248e0 <rtems_shell_rfs_format+0x9c> <== NOT EXECUTED
400248c4: 84 16 e2 18 or %i3, 0x218, %g2 <== NOT EXECUTED
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
break;
default:
printf ("error: invalid option: %s\n", argv[arg]);
400248c8: 11 10 01 75 sethi %hi(0x4005d400), %o0 <== NOT EXECUTED
return 1;
400248cc: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
break;
default:
printf ("error: invalid option: %s\n", argv[arg]);
400248d0: 40 00 71 f5 call 400410a4 <printf> <== NOT EXECUTED
400248d4: 90 12 20 a8 or %o0, 0xa8, %o0 <== NOT EXECUTED
400248d8: 81 c7 e0 08 ret <== NOT EXECUTED
400248dc: 81 e8 00 00 restore <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
400248e0: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
400248e4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED
400248e8: 81 c0 40 00 jmp %g1 <== NOT EXECUTED
400248ec: 01 00 00 00 nop <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
400248f0: ba 07 60 01 inc %i5 <== NOT EXECUTED
400248f4: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
400248f8: 14 bf ff e8 bg 40024898 <rtems_shell_rfs_format+0x54> <== NOT EXECUTED
400248fc: f4 2f bf fd stb %i2, [ %fp + -3 ] <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
40024900: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40024904: 02 80 00 45 be 40024a18 <rtems_shell_rfs_format+0x1d4> <== NOT EXECUTED
40024908: 92 07 bf e8 add %fp, -24, %o1 <== NOT EXECUTED
printf ("error: no driver name provided\n");
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
4002490c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
40024910: 40 00 3a e5 call 400334a4 <rtems_rfs_format> <== NOT EXECUTED
40024914: b0 10 20 00 clr %i0 <== NOT EXECUTED
40024918: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4002491c: 06 80 00 34 bl 400249ec <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
40024920: 01 00 00 00 nop <== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
40024924: 81 c7 e0 08 ret <== NOT EXECUTED
40024928: 81 e8 00 00 restore <== NOT EXECUTED
case 'v':
config.verbose = true;
break;
case 's':
arg++;
4002492c: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
40024930: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
40024934: 04 80 00 45 ble 40024a48 <rtems_shell_rfs_format+0x204> <== NOT EXECUTED
40024938: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: block size needs an argument\n");
return 1;
}
config.block_size = strtoul (argv[arg], 0, 0);
4002493c: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
40024940: 92 10 20 00 clr %o1 <== NOT EXECUTED
40024944: 40 00 81 ad call 40044ff8 <strtoul> <== NOT EXECUTED
40024948: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
4002494c: 10 bf ff cf b 40024888 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
40024950: d0 27 bf e8 st %o0, [ %fp + -24 ] <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
case 'o':
arg++;
40024954: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
40024958: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
4002495c: 04 80 00 47 ble 40024a78 <rtems_shell_rfs_format+0x234> <== NOT EXECUTED
40024960: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: inode percentage overhead needs an argument\n");
return 1;
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
40024964: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
40024968: 92 10 20 00 clr %o1 <== NOT EXECUTED
4002496c: 40 00 81 a3 call 40044ff8 <strtoul> <== NOT EXECUTED
40024970: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
40024974: 10 bf ff c5 b 40024888 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
40024978: d0 27 bf f4 st %o0, [ %fp + -12 ] <== NOT EXECUTED
}
config.group_blocks = strtoul (argv[arg], 0, 0);
break;
case 'i':
arg++;
4002497c: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
40024980: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
40024984: 04 80 00 37 ble 40024a60 <rtems_shell_rfs_format+0x21c> <== NOT EXECUTED
40024988: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group inode count needs an argument\n");
return 1;
}
config.group_inodes = strtoul (argv[arg], 0, 0);
4002498c: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
40024990: 92 10 20 00 clr %o1 <== NOT EXECUTED
40024994: 40 00 81 99 call 40044ff8 <strtoul> <== NOT EXECUTED
40024998: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
4002499c: 10 bf ff bb b 40024888 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
400249a0: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED
}
config.block_size = strtoul (argv[arg], 0, 0);
break;
case 'b':
arg++;
400249a4: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
400249a8: 80 a6 00 1d cmp %i0, %i5 <== NOT EXECUTED
400249ac: 04 80 00 21 ble 40024a30 <rtems_shell_rfs_format+0x1ec> <== NOT EXECUTED
400249b0: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group block count needs an argument\n");
return 1;
}
config.group_blocks = strtoul (argv[arg], 0, 0);
400249b4: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
400249b8: 92 10 20 00 clr %o1 <== NOT EXECUTED
400249bc: 40 00 81 8f call 40044ff8 <strtoul> <== NOT EXECUTED
400249c0: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
400249c4: 10 bf ff b1 b 40024888 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
400249c8: d0 27 bf ec st %o0, [ %fp + -20 ] <== NOT EXECUTED
config.group_inodes = strtoul (argv[arg], 0, 0);
break;
case 'I':
config.initialise_inodes = true;
break;
400249cc: 10 bf ff af b 40024888 <rtems_shell_rfs_format+0x44> <== NOT EXECUTED
400249d0: f4 2f bf fc stb %i2, [ %fp + -4 ] <== NOT EXECUTED
{
if (!driver)
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
400249d4: 11 10 01 7d sethi %hi(0x4005f400), %o0 <== NOT EXECUTED
return 1;
400249d8: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
{
if (!driver)
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
400249dc: 40 00 71 b2 call 400410a4 <printf> <== NOT EXECUTED
400249e0: 90 12 20 70 or %o0, 0x70, %o0 <== NOT EXECUTED
400249e4: 81 c7 e0 08 ret <== NOT EXECUTED
400249e8: 81 e8 00 00 restore <== NOT EXECUTED
}
if (rtems_rfs_format (driver, &config) < 0)
{
printf ("error: format of %s failed: %s\n",
driver, strerror (errno));
400249ec: 40 00 5f 5f call 4003c768 <__errno> <== NOT EXECUTED
400249f0: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
{
printf ("error: format of %s failed: %s\n",
400249f4: 40 00 7b 04 call 40043604 <strerror> <== NOT EXECUTED
400249f8: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
400249fc: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40024a00: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40024a04: 11 10 01 7d sethi %hi(0x4005f400), %o0 <== NOT EXECUTED
40024a08: 40 00 71 a7 call 400410a4 <printf> <== NOT EXECUTED
40024a0c: 90 12 20 a0 or %o0, 0xa0, %o0 ! 4005f4a0 <rtems_rtc_shell_usage+0x18a0><== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
40024a10: 81 c7 e0 08 ret <== NOT EXECUTED
40024a14: 81 e8 00 00 restore <== NOT EXECUTED
}
}
}
if (!driver) {
printf ("error: no driver name provided\n");
40024a18: 11 10 01 7c sethi %hi(0x4005f000), %o0 <== NOT EXECUTED
return 1;
40024a1c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
}
}
if (!driver) {
printf ("error: no driver name provided\n");
40024a20: 40 00 72 39 call 40041304 <puts> <== NOT EXECUTED
40024a24: 90 12 23 90 or %o0, 0x390, %o0 <== NOT EXECUTED
40024a28: 81 c7 e0 08 ret <== NOT EXECUTED
40024a2c: 81 e8 00 00 restore <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
{
printf ("error: group block count needs an argument\n");
40024a30: 11 10 01 7c sethi %hi(0x4005f000), %o0 <== NOT EXECUTED
return 1;
40024a34: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
{
printf ("error: group block count needs an argument\n");
40024a38: 40 00 72 33 call 40041304 <puts> <== NOT EXECUTED
40024a3c: 90 12 23 d8 or %o0, 0x3d8, %o0 <== NOT EXECUTED
40024a40: 81 c7 e0 08 ret <== NOT EXECUTED
40024a44: 81 e8 00 00 restore <== NOT EXECUTED
case 's':
arg++;
if (arg >= argc)
{
printf ("error: block size needs an argument\n");
40024a48: 11 10 01 7c sethi %hi(0x4005f000), %o0 <== NOT EXECUTED
return 1;
40024a4c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
case 's':
arg++;
if (arg >= argc)
{
printf ("error: block size needs an argument\n");
40024a50: 40 00 72 2d call 40041304 <puts> <== NOT EXECUTED
40024a54: 90 12 23 b0 or %o0, 0x3b0, %o0 <== NOT EXECUTED
40024a58: 81 c7 e0 08 ret <== NOT EXECUTED
40024a5c: 81 e8 00 00 restore <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
{
printf ("error: group inode count needs an argument\n");
40024a60: 11 10 01 7d sethi %hi(0x4005f400), %o0 <== NOT EXECUTED
return 1;
40024a64: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
{
printf ("error: group inode count needs an argument\n");
40024a68: 40 00 72 27 call 40041304 <puts> <== NOT EXECUTED
40024a6c: 90 12 20 08 or %o0, 8, %o0 <== NOT EXECUTED
40024a70: 81 c7 e0 08 ret <== NOT EXECUTED
40024a74: 81 e8 00 00 restore <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
{
printf ("error: inode percentage overhead needs an argument\n");
40024a78: 11 10 01 7d sethi %hi(0x4005f400), %o0 <== NOT EXECUTED
return 1;
40024a7c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
{
printf ("error: inode percentage overhead needs an argument\n");
40024a80: 40 00 72 21 call 40041304 <puts> <== NOT EXECUTED
40024a84: 90 12 20 38 or %o0, 0x38, %o0 <== NOT EXECUTED
40024a88: 81 c7 e0 08 ret <== NOT EXECUTED
40024a8c: 81 e8 00 00 restore <== NOT EXECUTED
40017790 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
40017790: 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 )
40017794: 80 a6 60 00 cmp %i1, 0
40017798: 12 80 00 04 bne 400177a8 <rtems_signal_send+0x18>
4001779c: 82 10 20 0a mov 0xa, %g1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400177a0: 81 c7 e0 08 ret
400177a4: 91 e8 00 01 restore %g0, %g1, %o0
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
400177a8: 90 10 00 18 mov %i0, %o0
400177ac: 40 00 13 a5 call 4001c640 <_Thread_Get>
400177b0: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
400177b4: c2 07 bf fc ld [ %fp + -4 ], %g1
400177b8: 80 a0 60 00 cmp %g1, 0
400177bc: 12 80 00 20 bne 4001783c <rtems_signal_send+0xac>
400177c0: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
400177c4: fa 02 21 4c ld [ %o0 + 0x14c ], %i5
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
400177c8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400177cc: 80 a0 60 00 cmp %g1, 0
400177d0: 02 80 00 1e be 40017848 <rtems_signal_send+0xb8>
400177d4: 01 00 00 00 nop
if ( asr->is_enabled ) {
400177d8: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
400177dc: 80 a0 60 00 cmp %g1, 0
400177e0: 02 80 00 1e be 40017858 <rtems_signal_send+0xc8>
400177e4: 01 00 00 00 nop
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
400177e8: 7f ff df 75 call 4000f5bc <sparc_disable_interrupts>
400177ec: 01 00 00 00 nop
*signal_set |= signals;
400177f0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
400177f4: b2 10 40 19 or %g1, %i1, %i1
400177f8: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
_ISR_Enable( _level );
400177fc: 7f ff df 74 call 4000f5cc <sparc_enable_interrupts>
40017800: 01 00 00 00 nop
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
40017804: 03 10 00 fb sethi %hi(0x4003ec00), %g1
40017808: 82 10 61 80 or %g1, 0x180, %g1 ! 4003ed80 <_Per_CPU_Information>
4001780c: c4 00 60 08 ld [ %g1 + 8 ], %g2
40017810: 80 a0 a0 00 cmp %g2, 0
40017814: 02 80 00 06 be 4001782c <rtems_signal_send+0x9c>
40017818: 01 00 00 00 nop
4001781c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
40017820: 80 a7 00 02 cmp %i4, %g2
40017824: 02 80 00 15 be 40017878 <rtems_signal_send+0xe8> <== ALWAYS TAKEN
40017828: 84 10 20 01 mov 1, %g2
_Thread_Dispatch_necessary = true;
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
4001782c: 40 00 13 79 call 4001c610 <_Thread_Enable_dispatch>
40017830: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
40017834: 10 bf ff db b 400177a0 <rtems_signal_send+0x10>
40017838: 82 10 20 00 clr %g1 ! 0 <PROM_START>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4001783c: 82 10 20 04 mov 4, %g1
}
40017840: 81 c7 e0 08 ret
40017844: 91 e8 00 01 restore %g0, %g1, %o0
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
40017848: 40 00 13 72 call 4001c610 <_Thread_Enable_dispatch>
4001784c: 01 00 00 00 nop
return RTEMS_NOT_DEFINED;
40017850: 10 bf ff d4 b 400177a0 <rtems_signal_send+0x10>
40017854: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
40017858: 7f ff df 59 call 4000f5bc <sparc_disable_interrupts>
4001785c: 01 00 00 00 nop
*signal_set |= signals;
40017860: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
40017864: b2 10 40 19 or %g1, %i1, %i1
40017868: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
_ISR_Enable( _level );
4001786c: 7f ff df 58 call 4000f5cc <sparc_enable_interrupts>
40017870: 01 00 00 00 nop
40017874: 30 bf ff ee b,a 4001782c <rtems_signal_send+0x9c>
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
if ( asr->is_enabled ) {
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
40017878: c4 28 60 0c stb %g2, [ %g1 + 0xc ]
4001787c: 30 bf ff ec b,a 4001782c <rtems_signal_send+0x9c>
40010110 <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 )
{
40010110: 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 )
40010114: 92 10 00 1a mov %i2, %o1
40010118: 7f ff c9 1d call 4000258c <.umul>
4001011c: 90 06 60 08 add %i1, 8, %o0
+ key_table_size + data_size;
rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(
40010120: 7f ff d8 6e call 400062d8 <malloc>
40010124: 90 02 20 1c add %o0, 0x1c, %o0
40010128: 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 ) {
4001012c: 80 a2 60 00 cmp %o1, 0
40010130: 02 80 00 0b be 4001015c <rtems_sparse_disk_create_and_register+0x4c><== NEVER TAKEN
40010134: 90 10 20 1a mov 0x1a, %o0
sc = rtems_sparse_disk_register(
40010138: 03 10 00 40 sethi %hi(0x40010000), %g1
4001013c: 82 10 60 18 or %g1, 0x18, %g1 ! 40010018 <rtems_sparse_disk_free>
40010140: 90 10 00 18 mov %i0, %o0
40010144: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40010148: 94 10 00 19 mov %i1, %o2
4001014c: 96 10 00 1a mov %i2, %o3
40010150: 98 10 00 1b mov %i3, %o4
40010154: 7f ff ff b4 call 40010024 <rtems_sparse_disk_register>
40010158: 9a 10 00 1c mov %i4, %o5
} else {
sc = RTEMS_NO_MEMORY;
}
return sc;
}
4001015c: 81 c7 e0 08 ret
40010160: 91 e8 00 08 restore %g0, %o0, %o0
40010164: 40 01 11 e0 call 400548e4 <__end+0x24454> <== NOT EXECUTED
40010168: 40 01 13 7c call 40054f58 <__end+0x24ac8> <== NOT EXECUTED
4001016c: 40 01 13 74 call 40054f3c <__end+0x24aac> <== NOT EXECUTED
40010170: 40 01 13 60 call 40054ef0 <__end+0x24a60> <== NOT EXECUTED
40010174: 40 01 13 60 call 40054ef4 <__end+0x24a64> <== NOT EXECUTED
40010178: 40 01 13 60 call 40054ef8 <__end+0x24a68> <== NOT EXECUTED
4001017c: 40 01 13 60 call 40054efc <__end+0x24a6c> <== NOT EXECUTED
40010180: 40 01 13 2c call 40054e30 <__end+0x249a0> <== NOT EXECUTED
40010184: 40 01 13 18 call 40054de4 <__end+0x24954> <== NOT EXECUTED
40010188: 40 01 13 18 call 40054de8 <__end+0x24958> <== NOT EXECUTED
4001018c: 40 01 13 18 call 40054dec <__end+0x2495c> <== NOT EXECUTED
40010190: 40 01 12 28 call 40054a30 <__end+0x245a0> <== NOT EXECUTED
40010194: 40 01 12 18 call 400549f4 <__end+0x24564> <== NOT EXECUTED
40010198: 40 01 12 18 call 400549f8 <__end+0x24568> <== NOT EXECUTED
4001019c: 40 01 12 f4 call 40054d6c <__end+0x248dc> <== NOT EXECUTED
400101a0: 40 01 12 f4 call 40054d70 <__end+0x248e0> <== NOT EXECUTED
400101a4: 40 01 12 f4 call 40054d74 <__end+0x248e4> <== NOT EXECUTED
400101a8: 40 01 12 f4 call 40054d78 <__end+0x248e8> <== NOT EXECUTED
400101ac: 40 01 12 c0 call 40054cac <__end+0x2481c> <== NOT EXECUTED
400101b0: 40 01 12 ac call 40054c60 <__end+0x247d0> <== NOT EXECUTED
400101b4: 40 01 12 ac call 40054c64 <__end+0x247d4> <== NOT EXECUTED
400101b8: 40 01 12 ac call 40054c68 <__end+0x247d8> <== NOT EXECUTED
400101bc: 40 01 28 2c call 4005a26c <__end+0x29ddc> <== NOT EXECUTED
400101c0: 40 01 28 2c call 4005a270 <__end+0x29de0> <== NOT EXECUTED
400101c4: 40 01 29 54 call 4005a714 <__end+0x2a284> <== NOT EXECUTED
400101c8: 40 01 29 7c call 4005a7b8 <__end+0x2a328> <== NOT EXECUTED
400101cc: 40 01 29 7c call 4005a7bc <__end+0x2a32c> <== NOT EXECUTED
400101d0: 40 01 29 7c call 4005a7c0 <__end+0x2a330> <== NOT EXECUTED
400101d4: 40 01 28 2c call 4005a284 <__end+0x29df4> <== NOT EXECUTED
400101d8: 40 01 29 44 call 4005a6e8 <__end+0x2a258> <== NOT EXECUTED
400101dc: 40 01 29 3c call 4005a6cc <__end+0x2a23c> <== NOT EXECUTED
400101e0: 40 01 29 84 call 4005a7f0 <__end+0x2a360> <== NOT EXECUTED
400101e4: 40 01 28 2c call 4005a294 <__end+0x29e04> <== NOT EXECUTED
40010024 <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 )
{
40010024: 9d e3 bf a0 save %sp, -96, %sp
40010028: a2 10 00 18 mov %i0, %l1
4001002c: a0 10 00 19 mov %i1, %l0
sparse_disk_ioctl,
sparse_disk
);
}
} else {
sc = RTEMS_INVALID_NUMBER;
40010030: b0 10 20 0a mov 0xa, %i0
uint8_t fill_pattern,
rtems_sparse_disk_delete_handler sparse_disk_delete )
{
rtems_status_code sc;
if ( blocks_with_buffer <= media_block_count ) {
40010034: 80 a6 c0 1c cmp %i3, %i4
40010038: 08 80 00 04 bleu 40010048 <rtems_sparse_disk_register+0x24><== ALWAYS TAKEN
4001003c: f2 07 a0 5c ld [ %fp + 0x5c ], %i1
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
40010040: 81 c7 e0 08 ret <== NOT EXECUTED
40010044: 81 e8 00 00 restore <== NOT EXECUTED
const uint8_t fill_pattern )
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
40010048: 80 a4 20 00 cmp %l0, 0
4001004c: 02 80 00 2f be 40010108 <rtems_sparse_disk_register+0xe4> <== NEVER TAKEN
40010050: 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
40010054: a5 2e e0 03 sll %i3, 3, %l2
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
40010058: 90 10 00 10 mov %l0, %o0
4001005c: b0 04 a0 1c add %l2, 0x1c, %i0
40010060: 40 00 38 2e call 4001e118 <memset>
40010064: 94 10 00 18 mov %i0, %o2
return RTEMS_INVALID_ADDRESS;
uint8_t *data = (uint8_t *) sd;
size_t const key_table_size = blocks_with_buffer
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
40010068: 92 10 00 1a mov %i2, %o1
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
sd->fill_pattern = fill_pattern;
4001006c: 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;
40010070: 7f ff c9 47 call 4000258c <.umul>
40010074: 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 ),
40010078: b0 04 00 18 add %l0, %i0, %i0
return RTEMS_INVALID_ADDRESS;
uint8_t *data = (uint8_t *) sd;
size_t const key_table_size = blocks_with_buffer
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
4001007c: 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 ),
40010080: 92 10 00 1d mov %i5, %o1
40010084: 40 00 38 25 call 4001e118 <memset>
40010088: 90 10 00 18 mov %i0, %o0
sd->fill_pattern,
data_size );
sd->delete_handler = sparse_disk_delete;
sc = rtems_semaphore_create(
4001008c: 92 10 20 01 mov 1, %o1
sd->fill_pattern = fill_pattern;
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
sd->fill_pattern,
data_size );
sd->delete_handler = sparse_disk_delete;
40010090: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
sc = rtems_semaphore_create(
40010094: 94 10 20 54 mov 0x54, %o2
40010098: 11 14 d4 10 sethi %hi(0x53504000), %o0
4001009c: 96 10 20 00 clr %o3
400100a0: 90 12 21 52 or %o0, 0x152, %o0
400100a4: 7f ff e8 ad call 4000a358 <rtems_semaphore_create>
400100a8: 98 10 00 10 mov %l0, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY,
0,
&sd->mutex
);
if ( sc != RTEMS_SUCCESSFUL ) {
400100ac: b0 92 20 00 orcc %o0, 0, %i0
400100b0: 12 bf ff e4 bne 40010040 <rtems_sparse_disk_register+0x1c><== NEVER TAKEN
400100b4: 84 04 20 1c add %l0, 0x1c, %g2
return sc;
}
data += sizeof( rtems_sparse_disk );
sd->blocks_with_buffer = blocks_with_buffer;
400100b8: f6 24 20 04 st %i3, [ %l0 + 4 ]
sd->key_table = (rtems_sparse_disk_key *) data;
400100bc: c4 24 20 18 st %g2, [ %l0 + 0x18 ]
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
400100c0: 82 10 20 00 clr %g1
400100c4: 80 a6 e0 00 cmp %i3, 0
400100c8: 02 80 00 08 be 400100e8 <rtems_sparse_disk_register+0xc4> <== NEVER TAKEN
400100cc: 84 00 80 12 add %g2, %l2, %g2
}
return sc;
}
rtems_status_code rtems_sparse_disk_register(
400100d0: 86 04 00 01 add %l0, %g1, %g3
sd->key_table = (rtems_sparse_disk_key *) data;
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
sd->key_table[i].data = data;
400100d4: c4 20 e0 20 st %g2, [ %g3 + 0x20 ]
400100d8: 82 00 60 08 add %g1, 8, %g1
sd->blocks_with_buffer = blocks_with_buffer;
sd->key_table = (rtems_sparse_disk_key *) data;
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
400100dc: 80 a4 80 01 cmp %l2, %g1
400100e0: 12 bf ff fc bne 400100d0 <rtems_sparse_disk_register+0xac>
400100e4: 84 00 80 1a add %g2, %i2, %g2
sd->key_table[i].data = data;
}
sd->media_block_size = media_block_size;
400100e8: f4 24 20 0c st %i2, [ %l0 + 0xc ]
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
400100ec: b2 10 00 1a mov %i2, %i1
400100f0: 37 10 00 3f sethi %hi(0x4000fc00), %i3
400100f4: b4 10 00 1c mov %i4, %i2
400100f8: b0 10 00 11 mov %l1, %i0
400100fc: b6 16 e1 40 or %i3, 0x140, %i3
40010100: 40 00 0b 63 call 40012e8c <rtems_blkdev_create>
40010104: 99 e8 00 10 restore %g0, %l0, %o4
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
40010108: 81 c7 e0 08 ret <== NOT EXECUTED
4001010c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
40026450 <rtems_stack_checker_begin_extension>:
Thread_Control *the_thread
)
{
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
40026450: c2 02 20 08 ld [ %o0 + 8 ], %g1
40026454: 80 a0 60 00 cmp %g1, 0
40026458: 02 80 00 0c be 40026488 <rtems_stack_checker_begin_extension+0x38><== NEVER TAKEN
4002645c: 05 10 01 a8 sethi %hi(0x4006a000), %g2
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
40026460: c2 02 20 b8 ld [ %o0 + 0xb8 ], %g1
40026464: c6 00 a2 cc ld [ %g2 + 0x2cc ], %g3
40026468: 84 10 a2 cc or %g2, 0x2cc, %g2
4002646c: c6 20 60 08 st %g3, [ %g1 + 8 ]
40026470: c6 00 a0 04 ld [ %g2 + 4 ], %g3
40026474: c6 20 60 0c st %g3, [ %g1 + 0xc ]
40026478: c6 00 a0 08 ld [ %g2 + 8 ], %g3
4002647c: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
40026480: c4 00 a0 0c ld [ %g2 + 0xc ], %g2
40026484: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
40026488: 81 c3 e0 08 retl
4002639c <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
4002639c: 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 )
400263a0: 3b 10 01 a3 sethi %hi(0x40068c00), %i5
400263a4: c2 07 63 80 ld [ %i5 + 0x380 ], %g1 ! 40068f80 <Stack_check_Initialized>
400263a8: 80 a0 60 00 cmp %g1, 0
400263ac: 12 80 00 20 bne 4002642c <rtems_stack_checker_create_extension+0x90>
400263b0: 07 10 01 a8 sethi %hi(0x4006a000), %g3
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
400263b4: 09 3f bb 7c sethi %hi(0xfeedf000), %g4
400263b8: 82 10 e2 cc or %g3, 0x2cc, %g1
400263bc: 88 11 20 0d or %g4, 0xd, %g4
400263c0: c8 20 e2 cc st %g4, [ %g3 + 0x2cc ]
400263c4: 07 02 eb 43 sethi %hi(0xbad0c00), %g3
400263c8: 86 10 e1 06 or %g3, 0x106, %g3 ! bad0d06 <RAM_SIZE+0xb6d0d06>
/*
* 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) {
400263cc: 05 10 01 a7 sethi %hi(0x40069c00), %g2
400263d0: d0 00 a1 a0 ld [ %g2 + 0x1a0 ], %o0 ! 40069da0 <_Per_CPU_Information>
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
400263d4: c6 20 60 04 st %g3, [ %g1 + 4 ]
400263d8: 07 37 ab 7c sethi %hi(0xdeadf000), %g3
400263dc: 86 10 e0 0d or %g3, 0xd, %g3 ! deadf00d <LEON_REG+0x5eadf00d>
400263e0: c6 20 60 08 st %g3, [ %g1 + 8 ]
400263e4: 07 18 03 43 sethi %hi(0x600d0c00), %g3
400263e8: 86 10 e1 06 or %g3, 0x106, %g3 ! 600d0d06 <RAM_END+0x1fcd0d06>
400263ec: c6 20 60 0c st %g3, [ %g1 + 0xc ]
/*
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
400263f0: 80 a2 20 00 cmp %o0, 0
400263f4: 02 80 00 0c be 40026424 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
400263f8: 84 10 a1 a0 or %g2, 0x1a0, %g2
400263fc: d4 00 a0 04 ld [ %g2 + 4 ], %o2
40026400: 80 a2 a0 00 cmp %o2, 0
40026404: 02 80 00 08 be 40026424 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
40026408: 03 10 01 a8 sethi %hi(0x4006a000), %g1
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
4002640c: 84 10 62 dc or %g1, 0x2dc, %g2 ! 4006a2dc <Stack_check_Interrupt_stack>
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
40026410: 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;
40026414: d0 20 a0 04 st %o0, [ %g2 + 4 ]
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
40026418: d4 20 62 dc st %o2, [ %g1 + 0x2dc ]
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
4002641c: 40 00 66 b1 call 4003fee0 <memset>
40026420: 92 10 20 a5 mov 0xa5, %o1
}
#endif
Stack_check_Initialized = 1;
40026424: 82 10 20 01 mov 1, %g1
40026428: c2 27 63 80 st %g1, [ %i5 + 0x380 ]
Thread_Control *the_thread
)
{
Stack_check_Initialize();
if (the_thread)
4002642c: 80 a6 60 00 cmp %i1, 0
40026430: 02 80 00 06 be 40026448 <rtems_stack_checker_create_extension+0xac><== NEVER TAKEN
40026434: 01 00 00 00 nop
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
40026438: d0 06 60 b8 ld [ %i1 + 0xb8 ], %o0
4002643c: d4 06 60 b4 ld [ %i1 + 0xb4 ], %o2
40026440: 40 00 66 a8 call 4003fee0 <memset>
40026444: 92 10 20 a5 mov 0xa5, %o1
return true;
}
40026448: 81 c7 e0 08 ret
4002644c: 91 e8 20 01 restore %g0, 1, %o0
400265b0 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
400265b0: 9d e3 bf a0 save %sp, -96, %sp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
400265b4: 39 10 01 a7 sethi %hi(0x40069c00), %i4
400265b8: b8 17 21 a0 or %i4, 0x1a0, %i4 ! 40069da0 <_Per_CPU_Information>
400265bc: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
400265c0: d0 00 60 b8 ld [ %g1 + 0xb8 ], %o0
400265c4: 80 a7 80 08 cmp %fp, %o0
400265c8: 0a 80 00 06 bcs 400265e0 <rtems_stack_checker_is_blown+0x30><== NEVER TAKEN
400265cc: ba 10 20 01 mov 1, %i5
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
400265d0: c2 00 60 b4 ld [ %g1 + 0xb4 ], %g1
400265d4: 82 02 00 01 add %o0, %g1, %g1
400265d8: 80 a0 40 1e cmp %g1, %fp
400265dc: ba 40 20 00 addx %g0, 0, %i5
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
400265e0: 03 10 01 a3 sethi %hi(0x40068c00), %g1
400265e4: c2 00 63 80 ld [ %g1 + 0x380 ], %g1 ! 40068f80 <Stack_check_Initialized>
400265e8: 80 a0 60 00 cmp %g1, 0
400265ec: 02 80 00 12 be 40026634 <rtems_stack_checker_is_blown+0x84><== NEVER TAKEN
400265f0: 82 10 20 00 clr %g1
pattern_ok = (!memcmp(
400265f4: 90 02 20 08 add %o0, 8, %o0
400265f8: 94 10 20 10 mov 0x10, %o2
400265fc: 13 10 01 a8 sethi %hi(0x4006a000), %o1
40026600: 40 00 65 7f call 4003fbfc <memcmp>
40026604: 92 12 62 cc or %o1, 0x2cc, %o1 ! 4006a2cc <Stack_check_Pattern>
40026608: 80 a0 00 08 cmp %g0, %o0
4002660c: 82 60 3f ff subx %g0, -1, %g1
40026610: 92 10 00 01 mov %g1, %o1
40026614: 82 18 60 01 xor %g1, 1, %g1
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
40026618: 80 88 60 ff btst 0xff, %g1
4002661c: 12 80 00 08 bne 4002663c <rtems_stack_checker_is_blown+0x8c><== NEVER TAKEN
40026620: 80 8f 60 ff btst 0xff, %i5
40026624: 12 80 00 06 bne 4002663c <rtems_stack_checker_is_blown+0x8c><== NEVER TAKEN
40026628: b0 10 20 00 clr %i0
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
4002662c: 81 c7 e0 08 ret
40026630: 81 e8 00 00 restore
*/
bool rtems_stack_checker_is_blown( void )
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
40026634: 10 bf ff f9 b 40026618 <rtems_stack_checker_is_blown+0x68><== NOT EXECUTED
40026638: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
4002663c: d0 07 20 10 ld [ %i4 + 0x10 ], %o0 <== NOT EXECUTED
40026640: 7f ff ff 94 call 40026490 <Stack_check_report_blown_task> <== NOT EXECUTED
40026644: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
400266ac <rtems_stack_checker_report_usage>:
}
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
400266ac: 13 10 00 a3 sethi %hi(0x40028c00), %o1 <== NOT EXECUTED
400266b0: 90 10 20 00 clr %o0 <== NOT EXECUTED
400266b4: 92 12 61 44 or %o1, 0x144, %o1 <== NOT EXECUTED
400266b8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400266bc: 7f ff ff e4 call 4002664c <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
400266c0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4002664c <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
4002664c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if ( !print )
40026650: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40026654: 02 80 00 14 be 400266a4 <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED
40026658: 39 10 01 a3 sethi %hi(0x40068c00), %i4 <== NOT EXECUTED
return;
print_context = context;
print_handler = print;
4002665c: 3b 10 01 a3 sethi %hi(0x40068c00), %i5 <== NOT EXECUTED
)
{
if ( !print )
return;
print_context = context;
40026660: f0 27 23 84 st %i0, [ %i4 + 0x384 ] <== NOT EXECUTED
print_handler = print;
40026664: f2 27 63 88 st %i1, [ %i5 + 0x388 ] <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
40026668: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4002666c: 13 10 01 7f sethi %hi(0x4005fc00), %o1 <== NOT EXECUTED
40026670: 9f c6 40 00 call %i1 <== NOT EXECUTED
40026674: 92 12 62 20 or %o1, 0x220, %o1 ! 4005fe20 <RTEMS_BDPART_MBR_MASTER_TYPE+0x3f8><== NOT EXECUTED
(*print)( context,
40026678: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4002667c: 13 10 01 7f sethi %hi(0x4005fc00), %o1 <== NOT EXECUTED
40026680: 9f c6 40 00 call %i1 <== NOT EXECUTED
40026684: 92 12 62 38 or %o1, 0x238, %o1 ! 4005fe38 <RTEMS_BDPART_MBR_MASTER_TYPE+0x410><== NOT EXECUTED
" 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 );
40026688: 11 10 00 98 sethi %hi(0x40026000), %o0 <== NOT EXECUTED
4002668c: 40 00 12 83 call 4002b098 <rtems_iterate_over_all_threads><== NOT EXECUTED
40026690: 90 12 22 1c or %o0, 0x21c, %o0 ! 4002621c <Stack_check_Dump_threads_usage><== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
40026694: 7f ff fe e2 call 4002621c <Stack_check_Dump_threads_usage><== NOT EXECUTED
40026698: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
#endif
print_context = NULL;
4002669c: c0 27 23 84 clr [ %i4 + 0x384 ] <== NOT EXECUTED
print_handler = NULL;
400266a0: c0 27 63 88 clr [ %i5 + 0x388 ] <== NOT EXECUTED
400266a4: 81 c7 e0 08 ret <== NOT EXECUTED
400266a8: 81 e8 00 00 restore <== NOT EXECUTED
40026540 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
40026540: 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);
40026544: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
40026548: 13 10 01 a8 sethi %hi(0x4006a000), %o1
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = Stack_check_Get_pattern_area(the_stack);
4002654c: 90 00 60 08 add %g1, 8, %o0
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
40026550: 94 10 20 10 mov 0x10, %o2
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
40026554: 80 a7 80 01 cmp %fp, %g1
40026558: 0a 80 00 07 bcs 40026574 <rtems_stack_checker_switch_extension+0x34><== NEVER TAKEN
4002655c: 92 12 62 cc or %o1, 0x2cc, %o1
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
40026560: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2
40026564: 82 00 40 02 add %g1, %g2, %g1
40026568: 80 a7 80 01 cmp %fp, %g1
4002656c: 08 80 00 0a bleu 40026594 <rtems_stack_checker_switch_extension+0x54><== ALWAYS TAKEN
40026570: 01 00 00 00 nop
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
40026574: 40 00 65 a2 call 4003fbfc <memcmp> <== NOT EXECUTED
40026578: 01 00 00 00 nop <== NOT EXECUTED
4002657c: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
40026580: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
40026584: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
40026588: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4002658c: 7f ff ff c1 call 40026490 <Stack_check_report_blown_task> <== NOT EXECUTED
40026590: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
/*
* 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,
40026594: 40 00 65 9a call 4003fbfc <memcmp>
40026598: 01 00 00 00 nop
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
4002659c: 80 a2 20 00 cmp %o0, 0
400265a0: 12 bf ff fa bne 40026588 <rtems_stack_checker_switch_extension+0x48><== NEVER TAKEN
400265a4: 92 10 20 00 clr %o1
400265a8: 81 c7 e0 08 ret
400265ac: 81 e8 00 00 restore
4000ef44 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
4000ef44: 9d e3 bf 98 save %sp, -104, %sp
double result;
char *end;
if ( !n )
4000ef48: 80 a6 60 00 cmp %i1, 0
4000ef4c: 02 80 00 1b be 4000efb8 <rtems_string_to_double+0x74>
4000ef50: b6 10 20 09 mov 9, %i3
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000ef54: 40 00 0c 00 call 40011f54 <__errno>
4000ef58: 01 00 00 00 nop
4000ef5c: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000ef60: c0 26 40 00 clr [ %i1 ]
4000ef64: c0 26 60 04 clr [ %i1 + 4 ]
result = strtod( s, &end );
4000ef68: 90 10 00 18 mov %i0, %o0
4000ef6c: 40 00 17 5b call 40014cd8 <strtod>
4000ef70: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
*endptr = end;
4000ef74: c2 07 bf fc ld [ %fp + -4 ], %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
4000ef78: b8 10 00 08 mov %o0, %i4
if ( endptr )
4000ef7c: 80 a6 a0 00 cmp %i2, 0
4000ef80: 02 80 00 03 be 4000ef8c <rtems_string_to_double+0x48>
4000ef84: ba 10 00 09 mov %o1, %i5
*endptr = end;
4000ef88: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
4000ef8c: 80 a6 00 01 cmp %i0, %g1
4000ef90: 02 80 00 0a be 4000efb8 <rtems_string_to_double+0x74>
4000ef94: b6 10 20 0b mov 0xb, %i3
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000ef98: 40 00 0b ef call 40011f54 <__errno>
4000ef9c: 01 00 00 00 nop
4000efa0: c2 02 00 00 ld [ %o0 ], %g1
4000efa4: 80 a0 60 22 cmp %g1, 0x22
4000efa8: 02 80 00 06 be 4000efc0 <rtems_string_to_double+0x7c>
4000efac: 90 10 00 1c mov %i4, %o0
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000efb0: f8 3e 40 00 std %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000efb4: b6 10 20 00 clr %i3
}
4000efb8: 81 c7 e0 08 ret
4000efbc: 91 e8 00 1b restore %g0, %i3, %o0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000efc0: 92 10 00 1d mov %i5, %o1
4000efc4: 94 10 20 00 clr %o2
4000efc8: 96 10 20 00 clr %o3
4000efcc: 40 00 41 ce call 4001f704 <__eqdf2>
4000efd0: b6 10 20 0a mov 0xa, %i3
4000efd4: 80 a2 20 00 cmp %o0, 0
4000efd8: 02 bf ff f8 be 4000efb8 <rtems_string_to_double+0x74> <== NEVER TAKEN
4000efdc: 90 10 00 1c mov %i4, %o0
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
4000efe0: 92 10 00 1d mov %i5, %o1
4000efe4: 15 1f fb ff sethi %hi(0x7feffc00), %o2
4000efe8: 96 10 3f ff mov -1, %o3
4000efec: 40 00 41 dc call 4001f75c <__gtdf2>
4000eff0: 94 12 a3 ff or %o2, 0x3ff, %o2
4000eff4: 80 a2 20 00 cmp %o0, 0
4000eff8: 14 bf ff f0 bg 4000efb8 <rtems_string_to_double+0x74>
4000effc: 90 10 00 1c mov %i4, %o0
4000f000: 92 10 00 1d mov %i5, %o1
4000f004: 15 3f fb ff sethi %hi(0xffeffc00), %o2
4000f008: 96 10 3f ff mov -1, %o3
4000f00c: 40 00 42 00 call 4001f80c <__ltdf2>
4000f010: 94 12 a3 ff or %o2, 0x3ff, %o2
4000f014: 80 a2 20 00 cmp %o0, 0
4000f018: 06 bf ff e8 bl 4000efb8 <rtems_string_to_double+0x74> <== ALWAYS TAKEN
4000f01c: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
4000f020: 10 bf ff e5 b 4000efb4 <rtems_string_to_double+0x70> <== NOT EXECUTED
4000f024: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
4000f028 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
4000f028: 9d e3 bf 98 save %sp, -104, %sp
float result;
char *end;
if ( !n )
4000f02c: 80 a6 60 00 cmp %i1, 0
4000f030: 02 80 00 19 be 4000f094 <rtems_string_to_float+0x6c>
4000f034: ba 10 20 09 mov 9, %i5
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000f038: 40 00 0b c7 call 40011f54 <__errno>
4000f03c: 01 00 00 00 nop
4000f040: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000f044: c0 26 40 00 clr [ %i1 ]
result = strtof( s, &end );
4000f048: 90 10 00 18 mov %i0, %o0
4000f04c: 40 00 17 2a call 40014cf4 <strtof>
4000f050: 92 07 bf fc add %fp, -4, %o1
if ( endptr )
*endptr = end;
4000f054: c2 07 bf fc ld [ %fp + -4 ], %g1
errno = 0;
*n = 0;
result = strtof( s, &end );
if ( endptr )
4000f058: 80 a6 a0 00 cmp %i2, 0
4000f05c: 02 80 00 03 be 4000f068 <rtems_string_to_float+0x40>
4000f060: b8 10 00 08 mov %o0, %i4
*endptr = end;
4000f064: c2 26 80 00 st %g1, [ %i2 ]
if ( end == s )
4000f068: 80 a6 00 01 cmp %i0, %g1
4000f06c: 02 80 00 0a be 4000f094 <rtems_string_to_float+0x6c>
4000f070: ba 10 20 0b mov 0xb, %i5
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000f074: 40 00 0b b8 call 40011f54 <__errno>
4000f078: 01 00 00 00 nop
4000f07c: c2 02 00 00 ld [ %o0 ], %g1
4000f080: 80 a0 60 22 cmp %g1, 0x22
4000f084: 02 80 00 06 be 4000f09c <rtems_string_to_float+0x74>
4000f088: 90 10 00 1c mov %i4, %o0
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000f08c: f8 26 40 00 st %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000f090: ba 10 20 00 clr %i5
}
4000f094: 81 c7 e0 08 ret
4000f098: 91 e8 00 1d restore %g0, %i5, %o0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000f09c: 92 10 20 00 clr %o1
4000f0a0: 40 00 3e f4 call 4001ec70 <__eqsf2>
4000f0a4: ba 10 20 0a mov 0xa, %i5
4000f0a8: 80 a2 20 00 cmp %o0, 0
4000f0ac: 02 bf ff fa be 4000f094 <rtems_string_to_float+0x6c> <== NEVER TAKEN
4000f0b0: 90 10 00 1c mov %i4, %o0
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
4000f0b4: 13 1f df ff sethi %hi(0x7f7ffc00), %o1
4000f0b8: 40 00 3f 03 call 4001ecc4 <__gtsf2>
4000f0bc: 92 12 63 ff or %o1, 0x3ff, %o1 ! 7f7fffff <RAM_END+0x3f3fffff>
4000f0c0: 80 a2 20 00 cmp %o0, 0
4000f0c4: 14 bf ff f4 bg 4000f094 <rtems_string_to_float+0x6c>
4000f0c8: 90 10 00 1c mov %i4, %o0
4000f0cc: 13 3f df ff sethi %hi(0xff7ffc00), %o1
4000f0d0: 40 00 3f 12 call 4001ed18 <__ltsf2>
4000f0d4: 92 12 63 ff or %o1, 0x3ff, %o1 ! ff7fffff <LEON_REG+0x7f7fffff>
4000f0d8: 80 a2 20 00 cmp %o0, 0
4000f0dc: 06 bf ff ee bl 4000f094 <rtems_string_to_float+0x6c> <== ALWAYS TAKEN
4000f0e0: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
4000f0e4: 10 bf ff eb b 4000f090 <rtems_string_to_float+0x68> <== NOT EXECUTED
4000f0e8: f8 26 40 00 st %i4, [ %i1 ] <== NOT EXECUTED
40020758 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
40020758: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
4002075c: 80 a6 60 00 cmp %i1, 0
40020760: 02 80 00 1a be 400207c8 <rtems_string_to_int+0x70>
40020764: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
40020768: 40 00 70 00 call 4003c768 <__errno>
4002076c: 01 00 00 00 nop
40020770: c0 22 00 00 clr [ %o0 ]
*n = 0;
40020774: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
40020778: 90 10 00 18 mov %i0, %o0
4002077c: 92 07 bf fc add %fp, -4, %o1
40020780: 40 00 90 d0 call 40044ac0 <strtol>
40020784: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
40020788: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
4002078c: 80 a6 a0 00 cmp %i2, 0
40020790: 02 80 00 03 be 4002079c <rtems_string_to_int+0x44>
40020794: ba 10 00 08 mov %o0, %i5
*endptr = end;
40020798: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4002079c: 80 a6 00 02 cmp %i0, %g2
400207a0: 02 80 00 0a be 400207c8 <rtems_string_to_int+0x70>
400207a4: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
400207a8: 40 00 6f f0 call 4003c768 <__errno>
400207ac: 01 00 00 00 nop
400207b0: c2 02 00 00 ld [ %o0 ], %g1
400207b4: 80 a0 60 22 cmp %g1, 0x22
400207b8: 02 80 00 06 be 400207d0 <rtems_string_to_int+0x78>
400207bc: 03 20 00 00 sethi %hi(0x80000000), %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
400207c0: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
400207c4: 82 10 20 00 clr %g1
}
400207c8: 81 c7 e0 08 ret
400207cc: 91 e8 00 01 restore %g0, %g1, %o0
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
400207d0: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
400207d4: 80 a0 60 00 cmp %g1, 0
400207d8: 02 bf ff fc be 400207c8 <rtems_string_to_int+0x70>
400207dc: 82 10 20 0a mov 0xa, %g1
400207e0: 80 a7 60 00 cmp %i5, 0
400207e4: 02 bf ff f9 be 400207c8 <rtems_string_to_int+0x70> <== NEVER TAKEN
400207e8: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
400207ec: 80 a7 40 02 cmp %i5, %g2
400207f0: 02 bf ff f6 be 400207c8 <rtems_string_to_int+0x70> <== ALWAYS TAKEN
400207f4: 01 00 00 00 nop
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
400207f8: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
400207fc: 10 bf ff f3 b 400207c8 <rtems_string_to_int+0x70> <== NOT EXECUTED
40020800: 82 10 20 00 clr %g1 <== NOT EXECUTED
4000f270 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
4000f270: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
4000f274: 80 a6 60 00 cmp %i1, 0
4000f278: 02 80 00 1a be 4000f2e0 <rtems_string_to_long+0x70>
4000f27c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000f280: 40 00 0b 35 call 40011f54 <__errno>
4000f284: 01 00 00 00 nop
4000f288: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000f28c: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
4000f290: 90 10 00 18 mov %i0, %o0
4000f294: 92 07 bf fc add %fp, -4, %o1
4000f298: 40 00 17 38 call 40014f78 <strtol>
4000f29c: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
4000f2a0: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
4000f2a4: 80 a6 a0 00 cmp %i2, 0
4000f2a8: 02 80 00 03 be 4000f2b4 <rtems_string_to_long+0x44>
4000f2ac: ba 10 00 08 mov %o0, %i5
*endptr = end;
4000f2b0: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000f2b4: 80 a6 00 02 cmp %i0, %g2
4000f2b8: 02 80 00 0a be 4000f2e0 <rtems_string_to_long+0x70>
4000f2bc: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000f2c0: 40 00 0b 25 call 40011f54 <__errno>
4000f2c4: 01 00 00 00 nop
4000f2c8: c2 02 00 00 ld [ %o0 ], %g1
4000f2cc: 80 a0 60 22 cmp %g1, 0x22
4000f2d0: 02 80 00 06 be 4000f2e8 <rtems_string_to_long+0x78>
4000f2d4: 03 20 00 00 sethi %hi(0x80000000), %g1
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000f2d8: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000f2dc: 82 10 20 00 clr %g1
}
4000f2e0: 81 c7 e0 08 ret
4000f2e4: 91 e8 00 01 restore %g0, %g1, %o0
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4000f2e8: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000f2ec: 80 a0 60 00 cmp %g1, 0
4000f2f0: 02 bf ff fc be 4000f2e0 <rtems_string_to_long+0x70>
4000f2f4: 82 10 20 0a mov 0xa, %g1
4000f2f8: 80 a7 60 00 cmp %i5, 0
4000f2fc: 02 bf ff f9 be 4000f2e0 <rtems_string_to_long+0x70> <== NEVER TAKEN
4000f300: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4000f304: 80 a7 40 02 cmp %i5, %g2
4000f308: 02 bf ff f6 be 4000f2e0 <rtems_string_to_long+0x70> <== ALWAYS TAKEN
4000f30c: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
4000f310: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000f314: 10 bf ff f3 b 4000f2e0 <rtems_string_to_long+0x70> <== NOT EXECUTED
4000f318: 82 10 20 00 clr %g1 <== NOT EXECUTED
4000f198 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
4000f198: 9d e3 bf 98 save %sp, -104, %sp
long long result;
char *end;
if ( !n )
4000f19c: 80 a6 60 00 cmp %i1, 0
4000f1a0: 02 80 00 1c be 4000f210 <rtems_string_to_long_long+0x78>
4000f1a4: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000f1a8: 40 00 0b 6b call 40011f54 <__errno>
4000f1ac: 01 00 00 00 nop
4000f1b0: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000f1b4: c0 26 40 00 clr [ %i1 ]
4000f1b8: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoll( s, &end, base );
4000f1bc: 90 10 00 18 mov %i0, %o0
4000f1c0: 92 07 bf fc add %fp, -4, %o1
4000f1c4: 40 00 17 76 call 40014f9c <strtoll>
4000f1c8: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
4000f1cc: c4 07 bf fc ld [ %fp + -4 ], %g2
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
4000f1d0: b8 10 00 08 mov %o0, %i4
if ( endptr )
4000f1d4: 80 a6 a0 00 cmp %i2, 0
4000f1d8: 02 80 00 03 be 4000f1e4 <rtems_string_to_long_long+0x4c>
4000f1dc: ba 10 00 09 mov %o1, %i5
*endptr = end;
4000f1e0: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000f1e4: 80 a6 00 02 cmp %i0, %g2
4000f1e8: 02 80 00 0a be 4000f210 <rtems_string_to_long_long+0x78>
4000f1ec: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000f1f0: 40 00 0b 59 call 40011f54 <__errno>
4000f1f4: 01 00 00 00 nop
4000f1f8: c2 02 00 00 ld [ %o0 ], %g1
4000f1fc: 80 a0 60 22 cmp %g1, 0x22
4000f200: 02 80 00 06 be 4000f218 <rtems_string_to_long_long+0x80>
4000f204: 05 1f ff ff sethi %hi(0x7ffffc00), %g2
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000f208: f8 3e 40 00 std %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000f20c: 82 10 20 00 clr %g1
}
4000f210: 81 c7 e0 08 ret
4000f214: 91 e8 00 01 restore %g0, %g1, %o0
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4000f218: 07 3f ff ff sethi %hi(0xfffffc00), %g3
4000f21c: 84 10 a3 ff or %g2, 0x3ff, %g2
4000f220: 86 10 e3 ff or %g3, 0x3ff, %g3
4000f224: 84 1f 00 02 xor %i4, %g2, %g2
4000f228: 86 1f 40 03 xor %i5, %g3, %g3
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000f22c: 80 90 80 03 orcc %g2, %g3, %g0
4000f230: 12 80 00 04 bne 4000f240 <rtems_string_to_long_long+0xa8>
4000f234: 80 97 00 1d orcc %i4, %i5, %g0
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
4000f238: 10 bf ff f6 b 4000f210 <rtems_string_to_long_long+0x78>
4000f23c: 82 10 20 0a mov 0xa, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000f240: 02 bf ff f4 be 4000f210 <rtems_string_to_long_long+0x78> <== NEVER TAKEN
4000f244: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4000f248: 03 20 00 00 sethi %hi(0x80000000), %g1
4000f24c: 80 a7 00 01 cmp %i4, %g1
4000f250: 32 bf ff ef bne,a 4000f20c <rtems_string_to_long_long+0x74><== NEVER TAKEN
4000f254: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
4000f258: 80 a7 60 00 cmp %i5, 0
4000f25c: 22 bf ff ed be,a 4000f210 <rtems_string_to_long_long+0x78><== ALWAYS TAKEN
4000f260: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
*n = result;
4000f264: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000f268: 10 bf ff ea b 4000f210 <rtems_string_to_long_long+0x78> <== NOT EXECUTED
4000f26c: 82 10 20 00 clr %g1 <== NOT EXECUTED
40020814 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
40020814: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
40020818: 80 a6 60 00 cmp %i1, 0
4002081c: 02 80 00 1b be 40020888 <rtems_string_to_unsigned_char+0x74>
40020820: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
40020824: 40 00 6f d1 call 4003c768 <__errno>
40020828: 01 00 00 00 nop
4002082c: c0 22 00 00 clr [ %o0 ]
*n = 0;
40020830: c0 2e 40 00 clrb [ %i1 ]
result = strtoul( s, &end, base );
40020834: 90 10 00 18 mov %i0, %o0
40020838: 92 07 bf fc add %fp, -4, %o1
4002083c: 40 00 91 ef call 40044ff8 <strtoul>
40020840: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
40020844: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
40020848: 80 a6 a0 00 cmp %i2, 0
4002084c: 02 80 00 03 be 40020858 <rtems_string_to_unsigned_char+0x44>
40020850: ba 10 00 08 mov %o0, %i5
*endptr = end;
40020854: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
40020858: 80 a6 00 02 cmp %i0, %g2
4002085c: 02 80 00 0b be 40020888 <rtems_string_to_unsigned_char+0x74>
40020860: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
40020864: 40 00 6f c1 call 4003c768 <__errno>
40020868: 01 00 00 00 nop
4002086c: c2 02 00 00 ld [ %o0 ], %g1
40020870: 80 a0 60 22 cmp %g1, 0x22
40020874: 02 80 00 0e be 400208ac <rtems_string_to_unsigned_char+0x98>
40020878: 80 a7 60 ff cmp %i5, 0xff
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
4002087c: 18 80 00 05 bgu 40020890 <rtems_string_to_unsigned_char+0x7c>
40020880: 82 10 20 00 clr %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
40020884: fa 2e 40 00 stb %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
}
40020888: 81 c7 e0 08 ret
4002088c: 91 e8 00 01 restore %g0, %g1, %o0
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
errno = ERANGE;
40020890: 40 00 6f b6 call 4003c768 <__errno>
40020894: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
40020898: 82 10 20 0a mov 0xa, %g1 ! a <PROM_START+0xa>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
errno = ERANGE;
4002089c: 84 10 20 22 mov 0x22, %g2
400208a0: c4 22 00 00 st %g2, [ %o0 ]
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
400208a4: 81 c7 e0 08 ret
400208a8: 91 e8 00 01 restore %g0, %g1, %o0
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
400208ac: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
400208b0: 80 a0 bf fd cmp %g2, -3
400208b4: 18 bf ff f5 bgu 40020888 <rtems_string_to_unsigned_char+0x74><== ALWAYS TAKEN
400208b8: 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 ) {
400208bc: 10 bf ff f0 b 4002087c <rtems_string_to_unsigned_char+0x68><== NOT EXECUTED
400208c0: 80 a7 60 ff cmp %i5, 0xff <== NOT EXECUTED
4000f3dc <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
4000f3dc: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
4000f3e0: 80 a6 60 00 cmp %i1, 0
4000f3e4: 02 80 00 1a be 4000f44c <rtems_string_to_unsigned_int+0x70>
4000f3e8: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000f3ec: 40 00 0a da call 40011f54 <__errno>
4000f3f0: 01 00 00 00 nop
4000f3f4: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000f3f8: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
4000f3fc: 90 10 00 18 mov %i0, %o0
4000f400: 92 07 bf fc add %fp, -4, %o1
4000f404: 40 00 18 2b call 400154b0 <strtoul>
4000f408: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
4000f40c: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
4000f410: 80 a6 a0 00 cmp %i2, 0
4000f414: 02 80 00 03 be 4000f420 <rtems_string_to_unsigned_int+0x44>
4000f418: ba 10 00 08 mov %o0, %i5
*endptr = end;
4000f41c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000f420: 80 a6 00 02 cmp %i0, %g2
4000f424: 02 80 00 0a be 4000f44c <rtems_string_to_unsigned_int+0x70>
4000f428: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000f42c: 40 00 0a ca call 40011f54 <__errno>
4000f430: 01 00 00 00 nop
4000f434: c2 02 00 00 ld [ %o0 ], %g1
4000f438: 80 a0 60 22 cmp %g1, 0x22
4000f43c: 02 80 00 06 be 4000f454 <rtems_string_to_unsigned_int+0x78>
4000f440: 84 07 7f ff add %i5, -1, %g2
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4000f444: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000f448: 82 10 20 00 clr %g1
}
4000f44c: 81 c7 e0 08 ret
4000f450: 91 e8 00 01 restore %g0, %g1, %o0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000f454: 80 a0 bf fd cmp %g2, -3
4000f458: 18 bf ff fd bgu 4000f44c <rtems_string_to_unsigned_int+0x70><== ALWAYS TAKEN
4000f45c: 82 10 20 0a mov 0xa, %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4000f460: 10 bf ff fa b 4000f448 <rtems_string_to_unsigned_int+0x6c><== NOT EXECUTED
4000f464: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
4000c98c <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
4000c98c: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
4000c990: 80 a6 60 00 cmp %i1, 0
4000c994: 02 80 00 1a be 4000c9fc <rtems_string_to_unsigned_long+0x70>
4000c998: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000c99c: 40 00 bf 73 call 4003c768 <__errno>
4000c9a0: 01 00 00 00 nop
4000c9a4: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000c9a8: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
4000c9ac: 90 10 00 18 mov %i0, %o0
4000c9b0: 92 07 bf fc add %fp, -4, %o1
4000c9b4: 40 00 e1 91 call 40044ff8 <strtoul>
4000c9b8: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
4000c9bc: c4 07 bf fc ld [ %fp + -4 ], %g2
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
4000c9c0: 80 a6 a0 00 cmp %i2, 0
4000c9c4: 02 80 00 03 be 4000c9d0 <rtems_string_to_unsigned_long+0x44>
4000c9c8: ba 10 00 08 mov %o0, %i5
*endptr = end;
4000c9cc: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000c9d0: 80 a6 00 02 cmp %i0, %g2
4000c9d4: 02 80 00 0a be 4000c9fc <rtems_string_to_unsigned_long+0x70>
4000c9d8: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000c9dc: 40 00 bf 63 call 4003c768 <__errno>
4000c9e0: 01 00 00 00 nop
4000c9e4: c2 02 00 00 ld [ %o0 ], %g1
4000c9e8: 80 a0 60 22 cmp %g1, 0x22
4000c9ec: 02 80 00 06 be 4000ca04 <rtems_string_to_unsigned_long+0x78>
4000c9f0: 84 07 7f ff add %i5, -1, %g2
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000c9f4: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000c9f8: 82 10 20 00 clr %g1
}
4000c9fc: 81 c7 e0 08 ret
4000ca00: 91 e8 00 01 restore %g0, %g1, %o0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000ca04: 80 a0 bf fd cmp %g2, -3
4000ca08: 18 bf ff fd bgu 4000c9fc <rtems_string_to_unsigned_long+0x70><== ALWAYS TAKEN
4000ca0c: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000ca10: 10 bf ff fa b 4000c9f8 <rtems_string_to_unsigned_long+0x6c><== NOT EXECUTED
4000ca14: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
4000f468 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
4000f468: 9d e3 bf 98 save %sp, -104, %sp
unsigned long long result;
char *end;
if ( !n )
4000f46c: 80 a6 60 00 cmp %i1, 0
4000f470: 02 80 00 1c be 4000f4e0 <rtems_string_to_unsigned_long_long+0x78>
4000f474: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000f478: 40 00 0a b7 call 40011f54 <__errno>
4000f47c: 01 00 00 00 nop
4000f480: c0 22 00 00 clr [ %o0 ]
*n = 0;
4000f484: c0 26 40 00 clr [ %i1 ]
4000f488: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoull( s, &end, base );
4000f48c: 90 10 00 18 mov %i0, %o0
4000f490: 92 07 bf fc add %fp, -4, %o1
4000f494: 40 00 18 10 call 400154d4 <strtoull>
4000f498: 94 10 00 1b mov %i3, %o2
if ( endptr )
*endptr = end;
4000f49c: c4 07 bf fc ld [ %fp + -4 ], %g2
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
4000f4a0: b8 10 00 08 mov %o0, %i4
if ( endptr )
4000f4a4: 80 a6 a0 00 cmp %i2, 0
4000f4a8: 02 80 00 03 be 4000f4b4 <rtems_string_to_unsigned_long_long+0x4c>
4000f4ac: ba 10 00 09 mov %o1, %i5
*endptr = end;
4000f4b0: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000f4b4: 80 a6 00 02 cmp %i0, %g2
4000f4b8: 02 80 00 0a be 4000f4e0 <rtems_string_to_unsigned_long_long+0x78>
4000f4bc: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000f4c0: 40 00 0a a5 call 40011f54 <__errno>
4000f4c4: 01 00 00 00 nop
4000f4c8: c2 02 00 00 ld [ %o0 ], %g1
4000f4cc: 80 a0 60 22 cmp %g1, 0x22
4000f4d0: 02 80 00 06 be 4000f4e8 <rtems_string_to_unsigned_long_long+0x80>
4000f4d4: 86 87 7f ff addcc %i5, -1, %g3
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000f4d8: f8 3e 40 00 std %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000f4dc: 82 10 20 00 clr %g1
}
4000f4e0: 81 c7 e0 08 ret
4000f4e4: 91 e8 00 01 restore %g0, %g1, %o0
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
4000f4e8: 84 47 3f ff addx %i4, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000f4ec: 80 a0 bf ff cmp %g2, -1
4000f4f0: 12 bf ff fa bne 4000f4d8 <rtems_string_to_unsigned_long_long+0x70><== NEVER TAKEN
4000f4f4: 80 a0 ff fd cmp %g3, -3
4000f4f8: 18 bf ff fa bgu 4000f4e0 <rtems_string_to_unsigned_long_long+0x78><== ALWAYS TAKEN
4000f4fc: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000f500: 10 bf ff f7 b 4000f4dc <rtems_string_to_unsigned_long_long+0x74><== NOT EXECUTED
4000f504: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
40003d3c <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
40003d3c: 9d e3 bd e0 save %sp, -544, %sp
IMFS_jnode_t *node;
int rv = 0;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
rtems_filesystem_eval_path_context_t ctx;
rtems_filesystem_location_info_t rootloc;
rtems_filesystem_location_info_t *currentloc =
40003d40: 94 10 20 18 mov 0x18, %o2
40003d44: 92 10 00 18 mov %i0, %o1
40003d48: 40 00 08 18 call 40005da8 <rtems_filesystem_eval_path_start>
40003d4c: 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(
40003d50: 92 07 be 78 add %fp, -392, %o1
40003d54: aa 10 00 08 mov %o0, %l5
40003d58: 40 00 09 0d call 4000618c <rtems_filesystem_location_copy_and_detach>
40003d5c: 90 07 be 48 add %fp, -440, %o0
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
rootloc.mt_entry->ops != &IMFS_ops
40003d60: c2 07 be 5c ld [ %fp + -420 ], %g1
static inline void rtems_filesystem_eval_path_set_flags(
rtems_filesystem_eval_path_context_t *ctx,
int flags
)
{
ctx->flags = flags;
40003d64: 84 10 20 60 mov 0x60, %g2
40003d68: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40003d6c: c4 27 be 70 st %g2, [ %fp + -400 ]
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
40003d70: 05 10 00 8a sethi %hi(0x40022800), %g2
40003d74: 84 10 a2 e8 or %g2, 0x2e8, %g2 ! 40022ae8 <IMFS_ops>
40003d78: 80 a0 40 02 cmp %g1, %g2
40003d7c: 02 80 00 06 be 40003d94 <rtems_tarfs_load+0x58>
40003d80: 05 10 00 8d sethi %hi(0x40023400), %g2
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
40003d84: 84 10 a2 28 or %g2, 0x228, %g2 ! 40023628 <fifoIMFS_ops>
40003d88: 80 a0 40 02 cmp %g1, %g2
40003d8c: 12 80 00 78 bne 40003f6c <rtems_tarfs_load+0x230> <== ALWAYS TAKEN
40003d90: 01 00 00 00 nop
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
40003d94: 80 a6 a1 ff cmp %i2, 0x1ff
40003d98: 08 80 00 4b bleu 40003ec4 <rtems_tarfs_load+0x188> <== NEVER TAKEN
40003d9c: 01 00 00 00 nop
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
40003da0: ac 07 bf 00 add %fp, -256, %l6
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
40003da4: 27 10 00 8a sethi %hi(0x40022800), %l3
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
40003da8: 84 38 00 16 xnor %g0, %l6, %g2
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
40003dac: a2 10 22 00 mov 0x200, %l1
40003db0: b8 10 22 00 mov 0x200, %i4
40003db4: ba 10 20 00 clr %i5
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
40003db8: a6 14 e3 70 or %l3, 0x370, %l3
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
40003dbc: a0 07 be 98 add %fp, -360, %l0
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
40003dc0: 10 80 00 08 b 40003de0 <rtems_tarfs_load+0xa4>
40003dc4: c4 27 be 44 st %g2, [ %fp + -444 ]
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
}
/*
* Create a LINEAR_FILE node
*/
else if (linkflag == REGTYPE) {
40003dc8: 02 80 00 46 be 40003ee0 <rtems_tarfs_load+0x1a4>
40003dcc: ba 10 00 1c mov %i4, %i5
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
40003dd0: b8 07 62 00 add %i5, 0x200, %i4
40003dd4: 80 a7 00 1a cmp %i4, %i2
40003dd8: 18 80 00 3b bgu 40003ec4 <rtems_tarfs_load+0x188> <== NEVER TAKEN
40003ddc: a2 10 00 1c mov %i4, %l1
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
40003de0: ba 06 40 1d add %i1, %i5, %i5
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
40003de4: 92 10 00 13 mov %l3, %o1
40003de8: 90 07 61 01 add %i5, 0x101, %o0
40003dec: 40 00 46 a4 call 4001587c <strncmp>
40003df0: 94 10 20 05 mov 5, %o2
40003df4: 80 a2 20 00 cmp %o0, 0
40003df8: 12 80 00 33 bne 40003ec4 <rtems_tarfs_load+0x188>
40003dfc: 94 10 20 63 mov 0x63, %o2
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
40003e00: 92 10 00 1d mov %i5, %o1
40003e04: 40 00 46 f4 call 400159d4 <strncpy>
40003e08: 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);
40003e0c: 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';
40003e10: c0 2f be fb clrb [ %fp + -261 ]
linkflag = hdr_ptr[156];
40003e14: f6 0f 60 9c ldub [ %i5 + 0x9c ], %i3
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
40003e18: 40 00 23 d5 call 4000cd6c <_rtems_octal2ulong>
40003e1c: 90 07 60 64 add %i5, 0x64, %o0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
40003e20: 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);
40003e24: a8 10 00 08 mov %o0, %l4
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
40003e28: 40 00 23 d1 call 4000cd6c <_rtems_octal2ulong>
40003e2c: 90 07 60 7c add %i5, 0x7c, %o0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
40003e30: 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);
40003e34: a4 10 00 08 mov %o0, %l2
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
40003e38: 40 00 23 cd call 4000cd6c <_rtems_octal2ulong>
40003e3c: 90 07 60 94 add %i5, 0x94, %o0
40003e40: ae 10 00 08 mov %o0, %l7
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
40003e44: 40 00 25 24 call 4000d2d4 <_rtems_tar_header_checksum>
40003e48: 90 10 00 1d mov %i5, %o0
40003e4c: 80 a2 00 17 cmp %o0, %l7
40003e50: 12 80 00 1d bne 40003ec4 <rtems_tarfs_load+0x188> <== NEVER TAKEN
40003e54: 01 00 00 00 nop
* Generate an IMFS node depending on the file type.
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
40003e58: b6 0e e0 ff and %i3, 0xff, %i3
40003e5c: 80 a6 e0 35 cmp %i3, 0x35
40003e60: 12 bf ff da bne 40003dc8 <rtems_tarfs_load+0x8c>
40003e64: 80 a6 e0 30 cmp %i3, 0x30
strcpy(full_filename, mountpoint);
40003e68: 90 10 00 16 mov %l6, %o0
40003e6c: 40 00 44 20 call 40014eec <stpcpy>
40003e70: 92 10 00 18 mov %i0, %o1
if (full_filename[strlen(full_filename)-1] != '/')
40003e74: c4 07 be 44 ld [ %fp + -444 ], %g2
40003e78: 82 07 80 08 add %fp, %o0, %g1
40003e7c: 82 00 40 02 add %g1, %g2, %g1
40003e80: c2 48 7f 00 ldsb [ %g1 + -256 ], %g1
40003e84: 80 a0 60 2f cmp %g1, 0x2f
40003e88: 02 80 00 04 be 40003e98 <rtems_tarfs_load+0x15c> <== ALWAYS TAKEN
40003e8c: 82 10 20 2f mov 0x2f, %g1
strcat(full_filename, "/");
40003e90: c0 2a 20 01 clrb [ %o0 + 1 ] <== NOT EXECUTED
40003e94: c2 2a 00 00 stb %g1, [ %o0 ] <== NOT EXECUTED
strcat(full_filename, filename);
40003e98: 92 10 00 10 mov %l0, %o1
40003e9c: 40 00 44 33 call 40014f68 <strcat>
40003ea0: 90 10 00 16 mov %l6, %o0
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
40003ea4: 90 10 00 16 mov %l6, %o0
40003ea8: 40 00 04 14 call 40004ef8 <mkdir>
40003eac: 92 10 21 ff mov 0x1ff, %o1
40003eb0: ba 10 00 1c mov %i4, %i5
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
40003eb4: b8 07 62 00 add %i5, 0x200, %i4
40003eb8: 80 a7 00 1a cmp %i4, %i2
40003ebc: 08 bf ff c9 bleu 40003de0 <rtems_tarfs_load+0xa4> <== ALWAYS TAKEN
40003ec0: a2 10 00 1c mov %i4, %l1
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
40003ec4: 40 00 02 6e call 4000487c <rtems_filesystem_location_free>
40003ec8: 90 07 be 48 add %fp, -440, %o0
if (
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
) {
rv = -1;
40003ecc: b0 10 20 00 clr %i0
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
rtems_filesystem_eval_path_cleanup( &ctx );
40003ed0: 40 00 07 f6 call 40005ea8 <rtems_filesystem_eval_path_cleanup>
40003ed4: 90 07 be 60 add %fp, -416, %o0
40003ed8: 81 c7 e0 08 ret
40003edc: 81 e8 00 00 restore
}
/*
* Create a LINEAR_FILE node
*/
else if (linkflag == REGTYPE) {
rtems_filesystem_location_free( currentloc );
40003ee0: 40 00 02 67 call 4000487c <rtems_filesystem_location_free>
40003ee4: 90 10 00 15 mov %l5, %o0
rtems_filesystem_location_clone( currentloc, &rootloc );
40003ee8: 92 07 be 48 add %fp, -440, %o1
40003eec: 40 00 01 96 call 40004544 <rtems_filesystem_location_clone>
40003ef0: 90 10 00 15 mov %l5, %o0
rtems_filesystem_eval_path_set_path(
40003ef4: 40 00 46 30 call 400157b4 <strlen>
40003ef8: 90 10 00 10 mov %l0, %o0
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
ctx->path = path;
40003efc: e0 27 be 60 st %l0, [ %fp + -416 ]
ctx->pathlen = pathlen;
40003f00: d0 27 be 64 st %o0, [ %fp + -412 ]
&ctx,
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
40003f04: 40 00 07 2c call 40005bb4 <rtems_filesystem_eval_path_continue>
40003f08: 90 07 be 60 add %fp, -416, %o0
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
40003f0c: c2 05 60 10 ld [ %l5 + 0x10 ], %g1
40003f10: 05 10 00 8c sethi %hi(0x40023000), %g2
40003f14: 84 10 a3 84 or %g2, 0x384, %g2 ! 40023384 <rtems_filesystem_null_handlers>
40003f18: 80 a0 40 02 cmp %g1, %g2
40003f1c: 02 80 00 10 be 40003f5c <rtems_tarfs_load+0x220> <== NEVER TAKEN
40003f20: d4 07 be 68 ld [ %fp + -408 ], %o2
size_t namelen,
mode_t mode,
const IMFS_types_union *info
)
{
const IMFS_fs_info_t *fs_info =
40003f24: c2 05 60 14 ld [ %l5 + 0x14 ], %g1
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
40003f28: c2 00 60 08 ld [ %g1 + 8 ], %g1
40003f2c: d6 07 be 6c ld [ %fp + -404 ], %o3
40003f30: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
40003f34: 03 00 00 20 sethi %hi(0x8000), %g1
node = IMFS_create_node(
currentloc,
IMFS_LINEAR_FILE,
rtems_filesystem_eval_path_get_token( &ctx ),
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
40003f38: 98 0d 21 ff and %l4, 0x1ff, %o4
40003f3c: 90 10 00 15 mov %l5, %o0
40003f40: 98 13 00 01 or %o4, %g1, %o4
40003f44: 40 00 25 9e call 4000d5bc <IMFS_create_node_with_control>
40003f48: 9a 10 20 00 clr %o5
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
40003f4c: 82 06 40 11 add %i1, %l1, %g1
rtems_filesystem_eval_path_get_token( &ctx ),
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
40003f50: c0 22 20 50 clr [ %o0 + 0x50 ]
40003f54: e4 22 20 54 st %l2, [ %o0 + 0x54 ]
node->info.linearfile.direct = &tar_image[offset];
40003f58: c2 22 20 58 st %g1, [ %o0 + 0x58 ]
}
nblocks = (((file_size) + 511) & ~511) / 512;
40003f5c: ba 04 a1 ff add %l2, 0x1ff, %i5
offset += 512 * nblocks;
40003f60: ba 0f 7e 00 and %i5, -512, %i5
40003f64: 10 bf ff 9b b 40003dd0 <rtems_tarfs_load+0x94>
40003f68: ba 07 40 11 add %i5, %l1, %i5
}
}
rtems_filesystem_location_free( &rootloc );
40003f6c: 40 00 02 44 call 4000487c <rtems_filesystem_location_free>
40003f70: 90 07 be 48 add %fp, -440, %o0
if (
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
) {
rv = -1;
40003f74: b0 10 3f ff mov -1, %i0
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
rtems_filesystem_eval_path_cleanup( &ctx );
40003f78: 40 00 07 cc call 40005ea8 <rtems_filesystem_eval_path_cleanup>
40003f7c: 90 07 be 60 add %fp, -416, %o0
40003f80: 81 c7 e0 08 ret
40003f84: 81 e8 00 00 restore
4001298c <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
4001298c: 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 )
40012990: 80 a6 a0 00 cmp %i2, 0
40012994: 02 80 00 3b be 40012a80 <rtems_task_mode+0xf4>
40012998: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
4001299c: 21 10 00 73 sethi %hi(0x4001cc00), %l0
400129a0: a0 14 23 b0 or %l0, 0x3b0, %l0 ! 4001cfb0 <_Per_CPU_Information>
400129a4: fa 04 20 10 ld [ %l0 + 0x10 ], %i5
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
400129a8: c4 0f 60 70 ldub [ %i5 + 0x70 ], %g2
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
400129ac: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
400129b0: 80 a0 00 02 cmp %g0, %g2
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
400129b4: f8 07 61 4c ld [ %i5 + 0x14c ], %i4
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
400129b8: b6 60 3f ff subx %g0, -1, %i3
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
400129bc: 80 a0 60 00 cmp %g1, 0
400129c0: 12 80 00 40 bne 40012ac0 <rtems_task_mode+0x134>
400129c4: b7 2e e0 08 sll %i3, 8, %i3
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
400129c8: c2 0f 20 08 ldub [ %i4 + 8 ], %g1
400129cc: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
400129d0: 7f ff eb e1 call 4000d954 <_CPU_ISR_Get_level>
400129d4: a2 60 3f ff subx %g0, -1, %l1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
400129d8: a3 2c 60 0a sll %l1, 0xa, %l1
400129dc: 90 14 40 08 or %l1, %o0, %o0
old_mode |= _ISR_Get_level();
400129e0: b6 12 00 1b or %o0, %i3, %i3
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
400129e4: 80 8e 61 00 btst 0x100, %i1
400129e8: 02 80 00 06 be 40012a00 <rtems_task_mode+0x74>
400129ec: 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;
400129f0: 83 36 20 08 srl %i0, 8, %g1
400129f4: 82 18 60 01 xor %g1, 1, %g1
400129f8: 82 08 60 01 and %g1, 1, %g1
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
400129fc: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ]
if ( mask & RTEMS_TIMESLICE_MASK ) {
40012a00: 80 8e 62 00 btst 0x200, %i1
40012a04: 12 80 00 21 bne 40012a88 <rtems_task_mode+0xfc>
40012a08: 80 8e 22 00 btst 0x200, %i0
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
40012a0c: 80 8e 60 0f btst 0xf, %i1
40012a10: 12 80 00 27 bne 40012aac <rtems_task_mode+0x120>
40012a14: 01 00 00 00 nop
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
40012a18: 80 8e 64 00 btst 0x400, %i1
40012a1c: 02 80 00 14 be 40012a6c <rtems_task_mode+0xe0>
40012a20: 86 10 20 00 clr %g3
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
40012a24: c2 0f 20 08 ldub [ %i4 + 8 ], %g1
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
40012a28: b1 36 20 0a srl %i0, 0xa, %i0
40012a2c: b0 1e 20 01 xor %i0, 1, %i0
40012a30: b0 0e 20 01 and %i0, 1, %i0
if ( is_asr_enabled != asr->is_enabled ) {
40012a34: 80 a6 00 01 cmp %i0, %g1
40012a38: 22 80 00 0e be,a 40012a70 <rtems_task_mode+0xe4>
40012a3c: 03 10 00 73 sethi %hi(0x4001cc00), %g1
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
40012a40: 7f ff c0 5e call 40002bb8 <sparc_disable_interrupts>
40012a44: f0 2f 20 08 stb %i0, [ %i4 + 8 ]
_signals = information->signals_pending;
40012a48: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
information->signals_pending = information->signals_posted;
40012a4c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
information->signals_posted = _signals;
40012a50: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
40012a54: c2 27 20 18 st %g1, [ %i4 + 0x18 ]
information->signals_posted = _signals;
_ISR_Enable( _level );
40012a58: 7f ff c0 5c call 40002bc8 <sparc_enable_interrupts>
40012a5c: 01 00 00 00 nop
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
40012a60: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40012a64: 80 a0 00 01 cmp %g0, %g1
40012a68: 86 40 20 00 addx %g0, 0, %g3
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
40012a6c: 03 10 00 73 sethi %hi(0x4001cc00), %g1
40012a70: c4 00 63 a8 ld [ %g1 + 0x3a8 ], %g2 ! 4001cfa8 <_System_state_Current>
40012a74: 80 a0 a0 03 cmp %g2, 3
40012a78: 02 80 00 1f be 40012af4 <rtems_task_mode+0x168>
40012a7c: 82 10 20 00 clr %g1
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
40012a80: 81 c7 e0 08 ret
40012a84: 91 e8 00 01 restore %g0, %g1, %o0
*/
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
40012a88: 22 bf ff e1 be,a 40012a0c <rtems_task_mode+0x80>
40012a8c: c0 27 60 78 clr [ %i5 + 0x78 ]
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
40012a90: 03 10 00 72 sethi %hi(0x4001c800), %g1
40012a94: c2 00 62 00 ld [ %g1 + 0x200 ], %g1 ! 4001ca00 <_Thread_Ticks_per_timeslice>
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
40012a98: 80 8e 60 0f btst 0xf, %i1
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
40012a9c: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
40012aa0: 82 10 20 01 mov 1, %g1
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
40012aa4: 02 bf ff dd be 40012a18 <rtems_task_mode+0x8c>
40012aa8: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
40012aac: 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 ) );
40012ab0: 7f ff c0 46 call 40002bc8 <sparc_enable_interrupts>
40012ab4: 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 ) {
40012ab8: 10 bf ff d9 b 40012a1c <rtems_task_mode+0x90>
40012abc: 80 8e 64 00 btst 0x400, %i1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
40012ac0: c2 0f 20 08 ldub [ %i4 + 8 ], %g1
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
40012ac4: b6 16 e2 00 or %i3, 0x200, %i3
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
40012ac8: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
40012acc: 7f ff eb a2 call 4000d954 <_CPU_ISR_Get_level>
40012ad0: a2 60 3f ff subx %g0, -1, %l1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
40012ad4: a3 2c 60 0a sll %l1, 0xa, %l1
40012ad8: 90 14 40 08 or %l1, %o0, %o0
old_mode |= _ISR_Get_level();
40012adc: b6 12 00 1b or %o0, %i3, %i3
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
40012ae0: 80 8e 61 00 btst 0x100, %i1
40012ae4: 02 bf ff c7 be 40012a00 <rtems_task_mode+0x74>
40012ae8: 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;
40012aec: 10 bf ff c2 b 400129f4 <rtems_task_mode+0x68>
40012af0: 83 36 20 08 srl %i0, 8, %g1
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
40012af4: 80 88 e0 ff btst 0xff, %g3
40012af8: 12 80 00 0a bne 40012b20 <rtems_task_mode+0x194>
40012afc: c4 04 20 10 ld [ %l0 + 0x10 ], %g2
40012b00: c6 04 20 14 ld [ %l0 + 0x14 ], %g3
40012b04: 80 a0 80 03 cmp %g2, %g3
40012b08: 02 bf ff de be 40012a80 <rtems_task_mode+0xf4>
40012b0c: 01 00 00 00 nop
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
40012b10: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
40012b14: 80 a0 a0 00 cmp %g2, 0
40012b18: 02 bf ff da be 40012a80 <rtems_task_mode+0xf4> <== NEVER TAKEN
40012b1c: 01 00 00 00 nop
_Thread_Dispatch_necessary = true;
40012b20: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1>
40012b24: c2 2c 20 0c stb %g1, [ %l0 + 0xc ]
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
40012b28: 7f ff e6 66 call 4000c4c0 <_Thread_Dispatch>
40012b2c: 01 00 00 00 nop
}
return RTEMS_SUCCESSFUL;
40012b30: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
40012b34: 81 c7 e0 08 ret
40012b38: 91 e8 00 01 restore %g0, %g1, %o0
4000cf44 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
4000cf44: 9d e3 bf 98 save %sp, -104, %sp
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
4000cf48: 80 a6 60 00 cmp %i1, 0
4000cf4c: 02 80 00 08 be 4000cf6c <rtems_task_set_priority+0x28>
4000cf50: 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 ) );
4000cf54: 03 10 00 6e sethi %hi(0x4001b800), %g1
4000cf58: c4 08 63 8c ldub [ %g1 + 0x38c ], %g2 ! 4001bb8c <rtems_maximum_priority>
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
4000cf5c: 80 a6 40 02 cmp %i1, %g2
4000cf60: 18 80 00 1e bgu 4000cfd8 <rtems_task_set_priority+0x94>
4000cf64: 82 10 20 13 mov 0x13, %g1
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
4000cf68: 80 a6 a0 00 cmp %i2, 0
4000cf6c: 02 80 00 1b be 4000cfd8 <rtems_task_set_priority+0x94>
4000cf70: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
4000cf74: 90 10 00 18 mov %i0, %o0
4000cf78: 40 00 0a 22 call 4000f800 <_Thread_Get>
4000cf7c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
4000cf80: c2 07 bf fc ld [ %fp + -4 ], %g1
4000cf84: 80 a0 60 00 cmp %g1, 0
4000cf88: 12 80 00 16 bne 4000cfe0 <rtems_task_set_priority+0x9c>
4000cf8c: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
4000cf90: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
4000cf94: 80 a6 60 00 cmp %i1, 0
4000cf98: 02 80 00 0d be 4000cfcc <rtems_task_set_priority+0x88>
4000cf9c: c2 26 80 00 st %g1, [ %i2 ]
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
4000cfa0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4000cfa4: 80 a0 60 00 cmp %g1, 0
4000cfa8: 02 80 00 06 be 4000cfc0 <rtems_task_set_priority+0x7c>
4000cfac: f2 22 20 18 st %i1, [ %o0 + 0x18 ]
4000cfb0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000cfb4: 80 a6 40 01 cmp %i1, %g1
4000cfb8: 1a 80 00 05 bcc 4000cfcc <rtems_task_set_priority+0x88> <== ALWAYS TAKEN
4000cfbc: 01 00 00 00 nop
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
4000cfc0: 92 10 00 19 mov %i1, %o1
4000cfc4: 40 00 08 c9 call 4000f2e8 <_Thread_Change_priority>
4000cfc8: 94 10 20 00 clr %o2
}
_Thread_Enable_dispatch();
4000cfcc: 40 00 0a 01 call 4000f7d0 <_Thread_Enable_dispatch>
4000cfd0: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
4000cfd4: 82 10 20 00 clr %g1 ! 0 <PROM_START>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000cfd8: 81 c7 e0 08 ret
4000cfdc: 91 e8 00 01 restore %g0, %g1, %o0
4000cfe0: 81 c7 e0 08 ret
4000cfe4: 91 e8 00 01 restore %g0, %g1, %o0
4000716c <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
4000716c: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
40007170: 80 a6 60 00 cmp %i1, 0
40007174: 02 80 00 1e be 400071ec <rtems_task_variable_delete+0x80>
40007178: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
4000717c: 90 10 00 18 mov %i0, %o0
40007180: 40 00 08 b1 call 40009444 <_Thread_Get>
40007184: 92 07 bf fc add %fp, -4, %o1
switch (location) {
40007188: c2 07 bf fc ld [ %fp + -4 ], %g1
4000718c: 80 a0 60 00 cmp %g1, 0
40007190: 12 80 00 19 bne 400071f4 <rtems_task_variable_delete+0x88>
40007194: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
40007198: c2 02 21 58 ld [ %o0 + 0x158 ], %g1
while (tvp) {
4000719c: 80 a0 60 00 cmp %g1, 0
400071a0: 02 80 00 10 be 400071e0 <rtems_task_variable_delete+0x74>
400071a4: 01 00 00 00 nop
if (tvp->ptr == ptr) {
400071a8: c4 00 60 04 ld [ %g1 + 4 ], %g2
400071ac: 80 a0 80 19 cmp %g2, %i1
400071b0: 32 80 00 09 bne,a 400071d4 <rtems_task_variable_delete+0x68>
400071b4: d2 00 40 00 ld [ %g1 ], %o1
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
400071b8: 10 80 00 18 b 40007218 <rtems_task_variable_delete+0xac>
400071bc: c4 00 40 00 ld [ %g1 ], %g2
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
400071c0: 80 a0 80 19 cmp %g2, %i1
400071c4: 22 80 00 0e be,a 400071fc <rtems_task_variable_delete+0x90>
400071c8: c4 02 40 00 ld [ %o1 ], %g2
400071cc: 82 10 00 09 mov %o1, %g1
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
400071d0: d2 00 40 00 ld [ %g1 ], %o1
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
400071d4: 80 a2 60 00 cmp %o1, 0
400071d8: 32 bf ff fa bne,a 400071c0 <rtems_task_variable_delete+0x54><== ALWAYS TAKEN
400071dc: c4 02 60 04 ld [ %o1 + 4 ], %g2
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
400071e0: 40 00 08 8d call 40009414 <_Thread_Enable_dispatch>
400071e4: 01 00 00 00 nop
return RTEMS_INVALID_ADDRESS;
400071e8: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400071ec: 81 c7 e0 08 ret
400071f0: 91 e8 00 01 restore %g0, %g1, %o0
400071f4: 81 c7 e0 08 ret
400071f8: 91 e8 00 01 restore %g0, %g1, %o0
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
400071fc: c4 20 40 00 st %g2, [ %g1 ]
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
40007200: 40 00 00 2e call 400072b8 <_RTEMS_Tasks_Invoke_task_variable_dtor>
40007204: 01 00 00 00 nop
_Thread_Enable_dispatch();
40007208: 40 00 08 83 call 40009414 <_Thread_Enable_dispatch>
4000720c: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
40007210: 10 bf ff f7 b 400071ec <rtems_task_variable_delete+0x80>
40007214: 82 10 20 00 clr %g1 ! 0 <PROM_START>
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
40007218: 92 10 00 01 mov %g1, %o1
4000721c: 10 bf ff f9 b 40007200 <rtems_task_variable_delete+0x94>
40007220: c4 22 21 58 st %g2, [ %o0 + 0x158 ]
40007224 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
40007224: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
40007228: 80 a6 60 00 cmp %i1, 0
4000722c: 02 80 00 1b be 40007298 <rtems_task_variable_get+0x74>
40007230: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !result )
40007234: 80 a6 a0 00 cmp %i2, 0
40007238: 02 80 00 18 be 40007298 <rtems_task_variable_get+0x74>
4000723c: 90 10 00 18 mov %i0, %o0
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
40007240: 40 00 08 81 call 40009444 <_Thread_Get>
40007244: 92 07 bf fc add %fp, -4, %o1
switch (location) {
40007248: c2 07 bf fc ld [ %fp + -4 ], %g1
4000724c: 80 a0 60 00 cmp %g1, 0
40007250: 12 80 00 14 bne 400072a0 <rtems_task_variable_get+0x7c>
40007254: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
40007258: c2 02 21 58 ld [ %o0 + 0x158 ], %g1
while (tvp) {
4000725c: 80 a0 60 00 cmp %g1, 0
40007260: 32 80 00 07 bne,a 4000727c <rtems_task_variable_get+0x58>
40007264: c4 00 60 04 ld [ %g1 + 4 ], %g2
40007268: 30 80 00 10 b,a 400072a8 <rtems_task_variable_get+0x84>
4000726c: 80 a0 60 00 cmp %g1, 0
40007270: 02 80 00 0e be 400072a8 <rtems_task_variable_get+0x84> <== NEVER TAKEN
40007274: 01 00 00 00 nop
if (tvp->ptr == ptr) {
40007278: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000727c: 80 a0 80 19 cmp %g2, %i1
40007280: 32 bf ff fb bne,a 4000726c <rtems_task_variable_get+0x48>
40007284: c2 00 40 00 ld [ %g1 ], %g1
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
40007288: c2 00 60 0c ld [ %g1 + 0xc ], %g1
_Thread_Enable_dispatch();
4000728c: 40 00 08 62 call 40009414 <_Thread_Enable_dispatch>
40007290: c2 26 80 00 st %g1, [ %i2 ]
return RTEMS_SUCCESSFUL;
40007294: 82 10 20 00 clr %g1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40007298: 81 c7 e0 08 ret
4000729c: 91 e8 00 01 restore %g0, %g1, %o0
400072a0: 81 c7 e0 08 ret
400072a4: 91 e8 00 01 restore %g0, %g1, %o0
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
400072a8: 40 00 08 5b call 40009414 <_Thread_Enable_dispatch>
400072ac: 01 00 00 00 nop
return RTEMS_INVALID_ADDRESS;
400072b0: 10 bf ff fa b 40007298 <rtems_task_variable_get+0x74>
400072b4: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
40006ed0 <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
40006ed0: 80 a2 20 09 cmp %o0, 9
40006ed4: 02 80 00 1c be 40006f44 <rtems_termios_baud_to_index+0x74>
40006ed8: 82 10 20 09 mov 9, %g1
40006edc: 80 a2 20 09 cmp %o0, 9
40006ee0: 08 80 00 1b bleu 40006f4c <rtems_termios_baud_to_index+0x7c>
40006ee4: 80 a2 20 04 cmp %o0, 4
40006ee8: 80 a2 20 0e cmp %o0, 0xe
40006eec: 02 80 00 16 be 40006f44 <rtems_termios_baud_to_index+0x74>
40006ef0: 82 10 20 0e mov 0xe, %g1
40006ef4: 80 a2 20 0e cmp %o0, 0xe
40006ef8: 08 80 00 28 bleu 40006f98 <rtems_termios_baud_to_index+0xc8>
40006efc: 80 a2 20 0b cmp %o0, 0xb
40006f00: 05 00 00 04 sethi %hi(0x1000), %g2
40006f04: 86 10 a0 02 or %g2, 2, %g3 ! 1002 <PROM_START+0x1002>
40006f08: 80 a2 00 03 cmp %o0, %g3
40006f0c: 02 80 00 0e be 40006f44 <rtems_termios_baud_to_index+0x74>
40006f10: 82 10 20 11 mov 0x11, %g1
40006f14: 80 a2 00 03 cmp %o0, %g3
40006f18: 08 80 00 3a bleu 40007000 <rtems_termios_baud_to_index+0x130>
40006f1c: 80 a2 20 0f cmp %o0, 0xf
40006f20: 86 10 a0 03 or %g2, 3, %g3
40006f24: 80 a2 00 03 cmp %o0, %g3
40006f28: 02 80 00 07 be 40006f44 <rtems_termios_baud_to_index+0x74>
40006f2c: 82 10 20 12 mov 0x12, %g1
40006f30: 84 10 a0 04 or %g2, 4, %g2
40006f34: 80 a2 00 02 cmp %o0, %g2
40006f38: 02 80 00 03 be 40006f44 <rtems_termios_baud_to_index+0x74>
40006f3c: 82 10 20 13 mov 0x13, %g1
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
40006f40: 82 10 3f ff mov -1, %g1
}
return baud_index;
}
40006f44: 81 c3 e0 08 retl
40006f48: 90 10 00 01 mov %g1, %o0
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
40006f4c: 02 bf ff fe be 40006f44 <rtems_termios_baud_to_index+0x74>
40006f50: 82 10 20 04 mov 4, %g1
40006f54: 80 a2 20 04 cmp %o0, 4
40006f58: 08 80 00 1d bleu 40006fcc <rtems_termios_baud_to_index+0xfc>
40006f5c: 80 a2 20 01 cmp %o0, 1
40006f60: 80 a2 20 06 cmp %o0, 6
40006f64: 02 bf ff f8 be 40006f44 <rtems_termios_baud_to_index+0x74>
40006f68: 82 10 20 06 mov 6, %g1
40006f6c: 80 a2 20 06 cmp %o0, 6
40006f70: 0a bf ff f5 bcs 40006f44 <rtems_termios_baud_to_index+0x74>
40006f74: 82 10 20 05 mov 5, %g1
40006f78: 80 a2 20 07 cmp %o0, 7
40006f7c: 02 bf ff f2 be 40006f44 <rtems_termios_baud_to_index+0x74>
40006f80: 82 10 20 07 mov 7, %g1
40006f84: 80 a2 20 08 cmp %o0, 8
40006f88: 02 bf ff ef be 40006f44 <rtems_termios_baud_to_index+0x74><== ALWAYS TAKEN
40006f8c: 82 10 20 08 mov 8, %g1
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
40006f90: 10 bf ff ed b 40006f44 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
40006f94: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
40006f98: 02 bf ff eb be 40006f44 <rtems_termios_baud_to_index+0x74>
40006f9c: 82 10 20 0b mov 0xb, %g1
40006fa0: 80 a2 20 0b cmp %o0, 0xb
40006fa4: 0a bf ff e8 bcs 40006f44 <rtems_termios_baud_to_index+0x74>
40006fa8: 82 10 20 0a mov 0xa, %g1
40006fac: 80 a2 20 0c cmp %o0, 0xc
40006fb0: 02 bf ff e5 be 40006f44 <rtems_termios_baud_to_index+0x74>
40006fb4: 82 10 20 0c mov 0xc, %g1
40006fb8: 80 a2 20 0d cmp %o0, 0xd
40006fbc: 02 bf ff e2 be 40006f44 <rtems_termios_baud_to_index+0x74><== ALWAYS TAKEN
40006fc0: 82 10 20 0d mov 0xd, %g1
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
40006fc4: 10 bf ff e0 b 40006f44 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
40006fc8: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
40006fcc: 02 bf ff de be 40006f44 <rtems_termios_baud_to_index+0x74>
40006fd0: 82 10 20 01 mov 1, %g1
40006fd4: 80 a2 20 01 cmp %o0, 1
40006fd8: 0a bf ff db bcs 40006f44 <rtems_termios_baud_to_index+0x74>
40006fdc: 82 10 20 00 clr %g1
40006fe0: 80 a2 20 02 cmp %o0, 2
40006fe4: 02 bf ff d8 be 40006f44 <rtems_termios_baud_to_index+0x74>
40006fe8: 82 10 20 02 mov 2, %g1
40006fec: 80 a2 20 03 cmp %o0, 3
40006ff0: 02 bf ff d5 be 40006f44 <rtems_termios_baud_to_index+0x74><== ALWAYS TAKEN
40006ff4: 82 10 20 03 mov 3, %g1
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
40006ff8: 10 bf ff d3 b 40006f44 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
40006ffc: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
40007000: 02 bf ff d1 be 40006f44 <rtems_termios_baud_to_index+0x74>
40007004: 82 10 20 0f mov 0xf, %g1
40007008: 84 10 a0 01 or %g2, 1, %g2
4000700c: 80 a2 00 02 cmp %o0, %g2
40007010: 12 bf ff cc bne 40006f40 <rtems_termios_baud_to_index+0x70><== NEVER TAKEN
40007014: 82 10 20 10 mov 0x10, %g1
40007018: 30 bf ff cb b,a 40006f44 <rtems_termios_baud_to_index+0x74>
40006274 <rtems_termios_close>:
rtems_interrupt_enable (level);
}
rtems_status_code
rtems_termios_close (void *arg)
{
40006274: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
40006278: 39 10 00 80 sethi %hi(0x40020000), %i4
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4000627c: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain(
40006280: d0 07 21 60 ld [ %i4 + 0x160 ], %o0
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40006284: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain(
40006288: 92 10 20 00 clr %o1
4000628c: 40 00 08 c0 call 4000858c <rtems_semaphore_obtain>
40006290: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40006294: 80 a2 20 00 cmp %o0, 0
40006298: 12 80 00 6e bne 40006450 <rtems_termios_close+0x1dc> <== NEVER TAKEN
4000629c: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
400062a0: c2 07 60 08 ld [ %i5 + 8 ], %g1
400062a4: 82 00 7f ff add %g1, -1, %g1
400062a8: 80 a0 60 00 cmp %g1, 0
400062ac: 12 80 00 39 bne 40006390 <rtems_termios_close+0x11c>
400062b0: c2 27 60 08 st %g1, [ %i5 + 8 ]
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
400062b4: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
400062b8: 03 10 00 7f sethi %hi(0x4001fc00), %g1
400062bc: 85 28 a0 05 sll %g2, 5, %g2
400062c0: 82 10 61 34 or %g1, 0x134, %g1
400062c4: 82 00 40 02 add %g1, %g2, %g1
400062c8: c2 00 60 04 ld [ %g1 + 4 ], %g1
400062cc: 80 a0 60 00 cmp %g1, 0
400062d0: 22 80 00 42 be,a 400063d8 <rtems_termios_close+0x164>
400062d4: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
400062d8: 9f c0 40 00 call %g1
400062dc: 90 10 00 1d mov %i5, %o0
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
400062e0: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
400062e4: 80 a0 60 02 cmp %g1, 2
400062e8: 22 80 00 4f be,a 40006424 <rtems_termios_close+0x1b0> <== NEVER TAKEN
400062ec: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
400062f0: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
400062f4: 80 a0 60 00 cmp %g1, 0
400062f8: 22 80 00 07 be,a 40006314 <rtems_termios_close+0xa0> <== ALWAYS TAKEN
400062fc: c2 07 40 00 ld [ %i5 ], %g1
(*tty->device.lastClose)(tty->major, tty->minor, arg);
40006300: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
40006304: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
40006308: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000630c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
if (tty->forw == NULL) {
40006310: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
40006314: 80 a0 60 00 cmp %g1, 0
40006318: 02 80 00 29 be 400063bc <rtems_termios_close+0x148>
4000631c: c4 07 60 04 ld [ %i5 + 4 ], %g2
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
} else {
tty->forw->back = tty->back;
40006320: c4 20 60 04 st %g2, [ %g1 + 4 ]
40006324: c4 07 60 04 ld [ %i5 + 4 ], %g2
}
if (tty->back == NULL) {
40006328: 80 a0 a0 00 cmp %g2, 0
4000632c: 22 80 00 21 be,a 400063b0 <rtems_termios_close+0x13c> <== ALWAYS TAKEN
40006330: 05 10 00 80 sethi %hi(0x40020000), %g2
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
40006334: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
40006338: 40 00 08 5e call 400084b0 <rtems_semaphore_delete>
4000633c: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
rtems_semaphore_delete (tty->osem);
40006340: 40 00 08 5c call 400084b0 <rtems_semaphore_delete>
40006344: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
40006348: 40 00 08 5a call 400084b0 <rtems_semaphore_delete>
4000634c: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if ((tty->device.pollRead == NULL) ||
40006350: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40006354: 80 a0 60 00 cmp %g1, 0
40006358: 02 80 00 13 be 400063a4 <rtems_termios_close+0x130>
4000635c: 01 00 00 00 nop
40006360: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40006364: 80 a0 60 02 cmp %g1, 2
40006368: 02 80 00 0f be 400063a4 <rtems_termios_close+0x130>
4000636c: 01 00 00 00 nop
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
40006370: 7f ff f7 a6 call 40004208 <free>
40006374: d0 07 60 58 ld [ %i5 + 0x58 ], %o0
free (tty->rawOutBuf.theBuf);
40006378: 7f ff f7 a4 call 40004208 <free>
4000637c: d0 07 60 7c ld [ %i5 + 0x7c ], %o0
free (tty->cbuf);
40006380: 7f ff f7 a2 call 40004208 <free>
40006384: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
free (tty);
40006388: 7f ff f7 a0 call 40004208 <free>
4000638c: 90 10 00 1d mov %i5, %o0
}
rtems_semaphore_release (rtems_termios_ttyMutex);
40006390: d0 07 21 60 ld [ %i4 + 0x160 ], %o0
40006394: 40 00 08 cd call 400086c8 <rtems_semaphore_release>
40006398: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
4000639c: 81 c7 e0 08 ret
400063a0: 81 e8 00 00 restore
rtems_semaphore_delete (tty->isem);
rtems_semaphore_delete (tty->osem);
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
400063a4: 40 00 08 43 call 400084b0 <rtems_semaphore_delete>
400063a8: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
400063ac: 30 bf ff f1 b,a 40006370 <rtems_termios_close+0xfc>
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
400063b0: c0 20 60 04 clr [ %g1 + 4 ]
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
400063b4: 10 bf ff e1 b 40006338 <rtems_termios_close+0xc4>
400063b8: c2 20 a1 68 st %g1, [ %g2 + 0x168 ]
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
400063bc: 03 10 00 80 sethi %hi(0x40020000), %g1
if ( rtems_termios_ttyTail != NULL ) {
400063c0: 80 a0 a0 00 cmp %g2, 0
400063c4: 02 80 00 25 be 40006458 <rtems_termios_close+0x1e4> <== ALWAYS TAKEN
400063c8: c4 20 61 64 st %g2, [ %g1 + 0x164 ]
rtems_termios_ttyTail->forw = NULL;
400063cc: c0 20 80 00 clr [ %g2 ] <== NOT EXECUTED
400063d0: 10 bf ff d9 b 40006334 <rtems_termios_close+0xc0> <== NOT EXECUTED
400063d4: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400063d8: 92 10 20 00 clr %o1
400063dc: 40 00 08 6c call 4000858c <rtems_semaphore_obtain>
400063e0: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
400063e4: 80 a2 20 00 cmp %o0, 0
400063e8: 12 80 00 1a bne 40006450 <rtems_termios_close+0x1dc> <== NEVER TAKEN
400063ec: 01 00 00 00 nop
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
400063f0: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
400063f4: 80 a0 60 00 cmp %g1, 0
400063f8: 02 80 00 04 be 40006408 <rtems_termios_close+0x194>
400063fc: 01 00 00 00 nop
40006400: 7f ff fe 72 call 40005dc8 <drainOutput.part.0>
40006404: 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);
40006408: 40 00 08 b0 call 400086c8 <rtems_semaphore_release>
4000640c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40006410: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40006414: 80 a0 60 02 cmp %g1, 2
40006418: 32 bf ff b7 bne,a 400062f4 <rtems_termios_close+0x80>
4000641c: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
40006420: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
40006424: 40 00 07 21 call 400080a8 <rtems_event_send>
40006428: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
4000642c: 80 a2 20 00 cmp %o0, 0
40006430: 12 80 00 08 bne 40006450 <rtems_termios_close+0x1dc> <== NEVER TAKEN
40006434: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
40006438: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
4000643c: 40 00 07 1b call 400080a8 <rtems_event_send>
40006440: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
40006444: 80 a2 20 00 cmp %o0, 0
40006448: 22 bf ff ab be,a 400062f4 <rtems_termios_close+0x80> <== ALWAYS TAKEN
4000644c: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
rtems_fatal_error_occurred (sc);
40006450: 40 00 0a 34 call 40008d20 <rtems_fatal_error_occurred> <== NOT EXECUTED
40006454: 01 00 00 00 nop <== NOT EXECUTED
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
40006458: 03 10 00 80 sethi %hi(0x40020000), %g1
4000645c: 10 bf ff b7 b 40006338 <rtems_termios_close+0xc4>
40006460: c0 20 61 68 clr [ %g1 + 0x168 ] ! 40020168 <rtems_termios_ttyHead>
4000795c <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)
{
4000795c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
40007960: c4 06 20 90 ld [ %i0 + 0x90 ], %g2
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40007964: c2 06 20 b4 ld [ %i0 + 0xb4 ], %g1
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
40007968: b2 00 80 19 add %g2, %i1, %i1
4000796c: f2 26 20 90 st %i1, [ %i0 + 0x90 ]
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40007970: 80 a0 60 02 cmp %g1, 2
40007974: 02 80 00 10 be 400079b4 <rtems_termios_dequeue_characters+0x58>
40007978: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
4000797c: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
40007980: 80 a0 60 05 cmp %g1, 5
40007984: 02 80 00 04 be 40007994 <rtems_termios_dequeue_characters+0x38>
40007988: 03 10 00 7f sethi %hi(0x4001fc00), %g1
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
4000798c: 7f ff f8 73 call 40005b58 <rtems_termios_refill_transmitter>
40007990: 81 e8 00 00 restore
if (tty->t_line == PPPDISC ) {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
40007994: c2 00 61 e8 ld [ %g1 + 0x1e8 ], %g1
40007998: 80 a0 60 00 cmp %g1, 0
4000799c: 02 80 00 04 be 400079ac <rtems_termios_dequeue_characters+0x50><== NEVER TAKEN
400079a0: 01 00 00 00 nop
rtems_termios_linesw[tty->t_line].l_start(tty);
400079a4: 9f c0 40 00 call %g1
400079a8: 01 00 00 00 nop
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
400079ac: 81 c7 e0 08 ret
400079b0: 91 e8 20 00 restore %g0, 0, %o0
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
400079b4: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0
400079b8: 40 00 01 bc call 400080a8 <rtems_event_send>
400079bc: 92 10 20 02 mov 2, %o1
if (sc != RTEMS_SUCCESSFUL)
400079c0: 80 a2 20 00 cmp %o0, 0
400079c4: 02 bf ff fa be 400079ac <rtems_termios_dequeue_characters+0x50><== ALWAYS TAKEN
400079c8: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
400079cc: 40 00 04 d5 call 40008d20 <rtems_fatal_error_occurred> <== NOT EXECUTED
400075b4 <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)
{
400075b4: 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) {
400075b8: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
400075bc: 37 10 00 7f sethi %hi(0x4001fc00), %i3
400075c0: 83 28 60 05 sll %g1, 5, %g1
400075c4: b6 16 e1 34 or %i3, 0x134, %i3
400075c8: 82 06 c0 01 add %i3, %g1, %g1
400075cc: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
400075d0: 80 a0 60 00 cmp %g1, 0
400075d4: 02 80 00 23 be 40007660 <rtems_termios_enqueue_raw_characters+0xac>
400075d8: b8 10 00 18 mov %i0, %i4
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
400075dc: b0 06 bf ff add %i2, -1, %i0
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
400075e0: 80 a6 a0 00 cmp %i2, 0
400075e4: 12 80 00 08 bne 40007604 <rtems_termios_enqueue_raw_characters+0x50><== ALWAYS TAKEN
400075e8: ba 10 20 00 clr %i5
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
400075ec: 10 80 00 0d b 40007620 <rtems_termios_enqueue_raw_characters+0x6c><== NOT EXECUTED
400075f0: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1 <== NOT EXECUTED
400075f4: ba 07 60 01 inc %i5
400075f8: 83 28 60 05 sll %g1, 5, %g1
400075fc: 82 06 c0 01 add %i3, %g1, %g1
40007600: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
40007604: d0 4e 40 1d ldsb [ %i1 + %i5 ], %o0
40007608: 9f c0 40 00 call %g1
4000760c: 92 10 00 1c mov %i4, %o1
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
40007610: 80 a7 40 18 cmp %i5, %i0
40007614: 32 bf ff f8 bne,a 400075f4 <rtems_termios_enqueue_raw_characters+0x40>
40007618: c2 07 20 cc ld [ %i4 + 0xcc ], %g1
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
4000761c: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1
40007620: 80 a0 60 00 cmp %g1, 0
40007624: 12 80 00 0d bne 40007658 <rtems_termios_enqueue_raw_characters+0xa4><== NEVER TAKEN
40007628: 01 00 00 00 nop
4000762c: c2 07 20 dc ld [ %i4 + 0xdc ], %g1
40007630: 80 a0 60 00 cmp %g1, 0
40007634: 02 80 00 07 be 40007650 <rtems_termios_enqueue_raw_characters+0x9c>
40007638: b0 10 20 00 clr %i0
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
4000763c: d2 07 20 e0 ld [ %i4 + 0xe0 ], %o1
40007640: 9f c0 40 00 call %g1
40007644: 90 07 20 30 add %i4, 0x30, %o0
tty->tty_rcvwakeup = 1;
40007648: 82 10 20 01 mov 1, %g1
4000764c: c2 27 20 e4 st %g1, [ %i4 + 0xe4 ]
40007650: 81 c7 e0 08 ret
40007654: 81 e8 00 00 restore
}
return 0;
40007658: 81 c7 e0 08 ret <== NOT EXECUTED
4000765c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
40007660: b4 06 40 1a add %i1, %i2, %i2
40007664: a0 10 20 00 clr %l0
40007668: 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);
4000766c: a2 07 20 30 add %i4, 0x30, %l1
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
40007670: a4 07 20 4a add %i4, 0x4a, %l2
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
40007674: 80 a6 40 1a cmp %i1, %i2
40007678: 22 80 00 28 be,a 40007718 <rtems_termios_enqueue_raw_characters+0x164>
4000767c: c2 07 20 78 ld [ %i4 + 0x78 ], %g1
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
40007680: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1
}
return 0;
}
while (len--) {
c = *buf++;
40007684: fa 0e 40 00 ldub [ %i1 ], %i5
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
40007688: 80 88 62 00 btst 0x200, %g1
4000768c: 02 80 00 0b be 400076b8 <rtems_termios_enqueue_raw_characters+0x104>
40007690: 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]) {
40007694: c4 0f 20 4a ldub [ %i4 + 0x4a ], %g2
40007698: 83 2f 60 18 sll %i5, 0x18, %g1
4000769c: 83 38 60 18 sra %g1, 0x18, %g1
400076a0: 80 a0 40 02 cmp %g1, %g2
400076a4: 02 80 00 5c be 40007814 <rtems_termios_enqueue_raw_characters+0x260>
400076a8: c4 0f 20 49 ldub [ %i4 + 0x49 ], %g2
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
400076ac: 80 a0 40 02 cmp %g1, %g2
400076b0: 02 80 00 61 be 40007834 <rtems_termios_enqueue_raw_characters+0x280><== NEVER TAKEN
400076b4: 01 00 00 00 nop
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
400076b8: 80 8c 20 ff btst 0xff, %l0
400076bc: 02 80 00 1d be 40007730 <rtems_termios_enqueue_raw_characters+0x17c><== ALWAYS TAKEN
400076c0: 01 00 00 00 nop
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
400076c4: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1
400076c8: 82 08 60 30 and %g1, 0x30, %g1
400076cc: 80 a0 60 20 cmp %g1, 0x20
400076d0: 12 bf ff ea bne 40007678 <rtems_termios_enqueue_raw_characters+0xc4><== ALWAYS TAKEN
400076d4: 80 a6 40 1a cmp %i1, %i2
/* disable interrupts */
rtems_interrupt_disable(level);
400076d8: 7f ff eb 7e call 400024d0 <sparc_disable_interrupts> <== NOT EXECUTED
400076dc: 01 00 00 00 nop <== NOT EXECUTED
400076e0: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
400076e4: c4 07 20 b8 ld [ %i4 + 0xb8 ], %g2 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400076e8: c2 07 20 94 ld [ %i4 + 0x94 ], %g1 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
400076ec: 84 08 bf df and %g2, -33, %g2 <== NOT EXECUTED
400076f0: c4 27 20 b8 st %g2, [ %i4 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400076f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400076f8: 12 80 00 57 bne 40007854 <rtems_termios_enqueue_raw_characters+0x2a0><== NOT EXECUTED
400076fc: 01 00 00 00 nop <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
40007700: 7f ff eb 78 call 400024e0 <sparc_enable_interrupts> <== NOT EXECUTED
40007704: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
40007708: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
4000770c: 12 bf ff dd bne 40007680 <rtems_termios_enqueue_raw_characters+0xcc><== NOT EXECUTED
40007710: 01 00 00 00 nop <== NOT EXECUTED
}
}
}
}
tty->rawInBufDropped += dropped;
40007714: c2 07 20 78 ld [ %i4 + 0x78 ], %g1 <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
40007718: d0 07 20 68 ld [ %i4 + 0x68 ], %o0
}
}
}
}
tty->rawInBufDropped += dropped;
4000771c: 82 00 40 18 add %g1, %i0, %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
40007720: 40 00 03 ea call 400086c8 <rtems_semaphore_release>
40007724: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
return dropped;
40007728: 81 c7 e0 08 ret
4000772c: 81 e8 00 00 restore
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
40007730: d0 07 20 60 ld [ %i4 + 0x60 ], %o0
40007734: d2 07 20 64 ld [ %i4 + 0x64 ], %o1
40007738: 40 00 49 7b call 40019d24 <.urem>
4000773c: 90 02 20 01 inc %o0
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
40007740: 7f ff eb 64 call 400024d0 <sparc_disable_interrupts>
40007744: b6 10 00 08 mov %o0, %i3
40007748: a6 10 00 08 mov %o0, %l3
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
4000774c: c2 07 20 5c ld [ %i4 + 0x5c ], %g1
40007750: d0 07 20 64 ld [ %i4 + 0x64 ], %o0
% tty->rawInBuf.Size) > tty->highwater) &&
40007754: d2 07 20 64 ld [ %i4 + 0x64 ], %o1
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
40007758: 90 22 00 01 sub %o0, %g1, %o0
% tty->rawInBuf.Size) > tty->highwater) &&
4000775c: 40 00 49 72 call 40019d24 <.urem>
40007760: 90 02 00 1b add %o0, %i3, %o0
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
40007764: c2 07 20 c0 ld [ %i4 + 0xc0 ], %g1
40007768: 80 a2 00 01 cmp %o0, %g1
4000776c: 08 80 00 13 bleu 400077b8 <rtems_termios_enqueue_raw_characters+0x204><== ALWAYS TAKEN
40007770: 01 00 00 00 nop
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
40007774: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1 <== NOT EXECUTED
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
40007778: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
4000777c: 12 80 00 0f bne 400077b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
40007780: 01 00 00 00 nop <== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
40007784: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1 <== NOT EXECUTED
40007788: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
4000778c: c2 27 20 b8 st %g1, [ %i4 + 0xb8 ] <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
40007790: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1 <== NOT EXECUTED
40007794: 82 08 64 02 and %g1, 0x402, %g1 <== NOT EXECUTED
40007798: 80 a0 64 00 cmp %g1, 0x400 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
4000779c: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1 <== NOT EXECUTED
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
400077a0: 02 80 00 35 be 40007874 <rtems_termios_enqueue_raw_characters+0x2c0><== NOT EXECUTED
400077a4: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
400077a8: 82 08 61 04 and %g1, 0x104, %g1 <== NOT EXECUTED
400077ac: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED
400077b0: 02 80 00 40 be 400078b0 <rtems_termios_enqueue_raw_characters+0x2fc><== NOT EXECUTED
400077b4: 01 00 00 00 nop <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
400077b8: 7f ff eb 4a call 400024e0 <sparc_enable_interrupts>
400077bc: 90 10 00 13 mov %l3, %o0
if (newTail == tty->rawInBuf.Head) {
400077c0: c2 07 20 5c ld [ %i4 + 0x5c ], %g1
400077c4: 80 a0 40 1b cmp %g1, %i3
400077c8: 22 bf ff ab be,a 40007674 <rtems_termios_enqueue_raw_characters+0xc0><== NEVER TAKEN
400077cc: b0 06 20 01 inc %i0 <== NOT EXECUTED
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
400077d0: c2 07 20 58 ld [ %i4 + 0x58 ], %g1
400077d4: fa 28 40 1b stb %i5, [ %g1 + %i3 ]
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
400077d8: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
400077dc: f6 27 20 60 st %i3, [ %i4 + 0x60 ]
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
400077e0: 80 a0 60 00 cmp %g1, 0
400077e4: 12 bf ff a5 bne 40007678 <rtems_termios_enqueue_raw_characters+0xc4><== NEVER TAKEN
400077e8: 80 a6 40 1a cmp %i1, %i2
400077ec: c2 07 20 dc ld [ %i4 + 0xdc ], %g1
400077f0: 80 a0 60 00 cmp %g1, 0
400077f4: 02 bf ff a1 be 40007678 <rtems_termios_enqueue_raw_characters+0xc4><== ALWAYS TAKEN
400077f8: 80 a6 40 1a cmp %i1, %i2
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
400077fc: d2 07 20 e0 ld [ %i4 + 0xe0 ], %o1 <== NOT EXECUTED
40007800: 9f c0 40 00 call %g1 <== NOT EXECUTED
40007804: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
40007808: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4000780c: 10 bf ff 9a b 40007674 <rtems_termios_enqueue_raw_characters+0xc0><== NOT EXECUTED
40007810: c2 27 20 e4 st %g1, [ %i4 + 0xe4 ] <== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
40007814: 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;
40007818: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
4000781c: 22 80 00 0b be,a 40007848 <rtems_termios_enqueue_raw_characters+0x294><== NEVER TAKEN
40007820: 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;
40007824: 82 10 60 10 or %g1, 0x10, %g1
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
40007828: a0 10 20 01 mov 1, %l0
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
4000782c: c2 27 20 b8 st %g1, [ %i4 + 0xb8 ]
40007830: 30 bf ff a5 b,a 400076c4 <rtems_termios_enqueue_raw_characters+0x110>
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
40007834: c2 07 20 b8 ld [ %i4 + 0xb8 ], %g1 <== NOT EXECUTED
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
40007838: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
4000783c: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED
40007840: c2 27 20 b8 st %g1, [ %i4 + 0xb8 ] <== NOT EXECUTED
40007844: 30 bf ff a0 b,a 400076c4 <rtems_termios_enqueue_raw_characters+0x110><== NOT EXECUTED
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
40007848: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
4000784c: c2 27 20 b8 st %g1, [ %i4 + 0xb8 ] <== NOT EXECUTED
40007850: 30 bf ff 9d b,a 400076c4 <rtems_termios_enqueue_raw_characters+0x110><== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
40007854: c4 07 20 84 ld [ %i4 + 0x84 ], %g2 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
40007858: d2 07 20 7c ld [ %i4 + 0x7c ], %o1 <== NOT EXECUTED
4000785c: c2 07 20 a4 ld [ %i4 + 0xa4 ], %g1 <== NOT EXECUTED
40007860: d0 07 20 10 ld [ %i4 + 0x10 ], %o0 <== NOT EXECUTED
40007864: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
40007868: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000786c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40007870: 30 bf ff a4 b,a 40007700 <rtems_termios_enqueue_raw_characters+0x14c><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
40007874: 12 80 00 06 bne 4000788c <rtems_termios_enqueue_raw_characters+0x2d8><== NOT EXECUTED
40007878: 01 00 00 00 nop <== NOT EXECUTED
4000787c: c2 07 20 94 ld [ %i4 + 0x94 ], %g1 <== NOT EXECUTED
40007880: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40007884: 12 bf ff cd bne 400077b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
40007888: 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;
4000788c: c4 07 20 b8 ld [ %i4 + 0xb8 ], %g2 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
40007890: c2 07 20 a4 ld [ %i4 + 0xa4 ], %g1 <== NOT EXECUTED
40007894: d0 07 20 10 ld [ %i4 + 0x10 ], %o0 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
40007898: 84 10 a0 02 or %g2, 2, %g2 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
4000789c: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
400078a0: c4 27 20 b8 st %g2, [ %i4 + 0xb8 ] <== NOT EXECUTED
(*tty->device.write)(tty->minor,
400078a4: 9f c0 40 00 call %g1 <== NOT EXECUTED
400078a8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
400078ac: 30 bf ff c3 b,a 400077b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
400078b0: c4 07 20 b8 ld [ %i4 + 0xb8 ], %g2 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
400078b4: c2 07 20 ac ld [ %i4 + 0xac ], %g1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
400078b8: 84 10 a0 04 or %g2, 4, %g2 <== NOT EXECUTED
400078bc: c4 27 20 b8 st %g2, [ %i4 + 0xb8 ] <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
400078c0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400078c4: 02 bf ff bd be 400077b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
400078c8: 01 00 00 00 nop <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
400078cc: 9f c0 40 00 call %g1 <== NOT EXECUTED
400078d0: d0 07 20 10 ld [ %i4 + 0x10 ], %o0 <== NOT EXECUTED
400078d4: 30 bf ff b9 b,a 400077b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
40006484 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
40006484: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40006488: c2 06 00 00 ld [ %i0 ], %g1
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
4000648c: 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;
40006490: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
40006494: 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);
40006498: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
4000649c: 92 10 20 00 clr %o1
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
400064a0: c0 26 20 0c clr [ %i0 + 0xc ]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400064a4: 40 00 08 3a call 4000858c <rtems_semaphore_obtain>
400064a8: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
400064ac: b0 92 20 00 orcc %o0, 0, %i0
400064b0: 12 80 00 23 bne 4000653c <rtems_termios_ioctl+0xb8> <== NEVER TAKEN
400064b4: 01 00 00 00 nop
return sc;
}
switch (args->command) {
400064b8: c2 07 20 04 ld [ %i4 + 4 ], %g1
400064bc: 80 a0 60 05 cmp %g1, 5
400064c0: 22 80 00 1a be,a 40006528 <rtems_termios_ioctl+0xa4>
400064c4: c2 06 c0 00 ld [ %i3 ], %g1
400064c8: 18 80 00 1f bgu 40006544 <rtems_termios_ioctl+0xc0>
400064cc: 05 10 01 19 sethi %hi(0x40046400), %g2
400064d0: 80 a0 60 02 cmp %g1, 2
400064d4: 22 80 00 2f be,a 40006590 <rtems_termios_ioctl+0x10c>
400064d8: d2 07 20 08 ld [ %i4 + 8 ], %o1
400064dc: 18 80 00 bf bgu 400067d8 <rtems_termios_ioctl+0x354>
400064e0: 80 a0 60 03 cmp %g1, 3
400064e4: 80 a0 60 01 cmp %g1, 1
400064e8: 22 80 00 d0 be,a 40006828 <rtems_termios_ioctl+0x3a4> <== ALWAYS TAKEN
400064ec: d0 07 20 08 ld [ %i4 + 8 ], %o0
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
400064f0: c4 07 60 cc ld [ %i5 + 0xcc ], %g2 <== NOT EXECUTED
400064f4: 03 10 00 7f sethi %hi(0x4001fc00), %g1
400064f8: 85 28 a0 05 sll %g2, 5, %g2
400064fc: 82 10 61 34 or %g1, 0x134, %g1
40006500: 82 00 40 02 add %g1, %g2, %g1
40006504: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40006508: 80 a0 60 00 cmp %g1, 0
4000650c: 02 80 00 0a be 40006534 <rtems_termios_ioctl+0xb0>
40006510: b0 10 20 0a mov 0xa, %i0
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
40006514: 90 10 00 1d mov %i5, %o0
40006518: 9f c0 40 00 call %g1
4000651c: 92 10 00 1c mov %i4, %o1
40006520: 10 80 00 05 b 40006534 <rtems_termios_ioctl+0xb0>
40006524: b0 10 00 08 mov %o0, %i0
break;
}
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
40006528: c2 27 60 d4 st %g1, [ %i5 + 0xd4 ]
4000652c: c2 06 e0 04 ld [ %i3 + 4 ], %g1
40006530: c2 27 60 d8 st %g1, [ %i5 + 0xd8 ]
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
40006534: 40 00 08 65 call 400086c8 <rtems_semaphore_release>
40006538: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
}
4000653c: 81 c7 e0 08 ret
40006540: 81 e8 00 00 restore
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
40006544: 84 10 a2 7f or %g2, 0x27f, %g2
40006548: 80 a0 40 02 cmp %g1, %g2
4000654c: 02 80 00 77 be 40006728 <rtems_termios_ioctl+0x2a4> <== NEVER TAKEN
40006550: 01 00 00 00 nop
40006554: 38 80 00 81 bgu,a 40006758 <rtems_termios_ioctl+0x2d4>
40006558: 05 10 01 1d sethi %hi(0x40047400), %g2
4000655c: 80 a0 60 06 cmp %g1, 6
40006560: 32 bf ff e5 bne,a 400064f4 <rtems_termios_ioctl+0x70>
40006564: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
40006568: c2 07 20 08 ld [ %i4 + 8 ], %g1
4000656c: 80 a0 60 01 cmp %g1, 1
40006570: 02 80 00 c3 be 4000687c <rtems_termios_ioctl+0x3f8>
40006574: 80 a0 60 02 cmp %g1, 2
40006578: 02 80 00 d1 be 400068bc <rtems_termios_ioctl+0x438>
4000657c: 80 a0 60 00 cmp %g1, 0
40006580: 02 80 00 d6 be 400068d8 <rtems_termios_ioctl+0x454>
40006584: 01 00 00 00 nop
case TCIOFLUSH:
flushOutput (tty);
flushInput (tty);
break;
default:
sc = RTEMS_INVALID_NAME;
40006588: 10 bf ff eb b 40006534 <rtems_termios_ioctl+0xb0>
4000658c: b0 10 20 03 mov 3, %i0 ! 3 <PROM_START+0x3>
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
40006590: 94 10 20 24 mov 0x24, %o2
40006594: b8 07 60 30 add %i5, 0x30, %i4
40006598: 40 00 2b 3b call 40011284 <memcpy>
4000659c: 90 10 00 1c mov %i4, %o0
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
400065a0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400065a4: 80 88 62 00 btst 0x200, %g1
400065a8: 02 80 00 19 be 4000660c <rtems_termios_ioctl+0x188>
400065ac: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
400065b0: 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) &&
400065b4: 80 88 64 00 btst 0x400, %g1
400065b8: 12 80 00 15 bne 4000660c <rtems_termios_ioctl+0x188>
400065bc: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
400065c0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400065c4: 82 08 7d ef and %g1, -529, %g1
400065c8: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
400065cc: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400065d0: 80 88 60 20 btst 0x20, %g1
400065d4: 02 80 00 0e be 4000660c <rtems_termios_ioctl+0x188> <== ALWAYS TAKEN
400065d8: 01 00 00 00 nop
/* disable interrupts */
rtems_interrupt_disable(level);
400065dc: 7f ff ef bd call 400024d0 <sparc_disable_interrupts> <== NOT EXECUTED
400065e0: 01 00 00 00 nop <== NOT EXECUTED
400065e4: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
400065e8: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400065ec: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
400065f0: 84 08 bf df and %g2, -33, %g2 <== NOT EXECUTED
400065f4: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400065f8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400065fc: 12 80 00 c4 bne 4000690c <rtems_termios_ioctl+0x488> <== NOT EXECUTED
40006600: 01 00 00 00 nop <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
40006604: 7f ff ef b7 call 400024e0 <sparc_enable_interrupts> <== NOT EXECUTED
40006608: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
4000660c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40006610: 80 88 64 00 btst 0x400, %g1
40006614: 02 80 00 0d be 40006648 <rtems_termios_ioctl+0x1c4>
40006618: 01 00 00 00 nop
4000661c: c4 07 60 30 ld [ %i5 + 0x30 ], %g2
40006620: 03 00 00 04 sethi %hi(0x1000), %g1
40006624: 80 88 80 01 btst %g2, %g1
40006628: 12 80 00 08 bne 40006648 <rtems_termios_ioctl+0x1c4> <== NEVER TAKEN
4000662c: 01 00 00 00 nop
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
40006630: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40006634: 82 08 7b ff and %g1, -1025, %g1
40006638: 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);
4000663c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40006640: 82 08 7f fd and %g1, -3, %g1
40006644: 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)) {
40006648: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
4000664c: 80 88 61 00 btst 0x100, %g1
40006650: 02 80 00 16 be 400066a8 <rtems_termios_ioctl+0x224> <== ALWAYS TAKEN
40006654: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
40006658: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000665c: 06 80 00 93 bl 400068a8 <rtems_termios_ioctl+0x424> <== NOT EXECUTED
40006660: 01 00 00 00 nop <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
40006664: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
40006668: 84 08 be ff and %g2, -257, %g2 <== NOT EXECUTED
4000666c: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
40006670: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
40006674: 80 88 a0 04 btst 4, %g2 <== NOT EXECUTED
40006678: 02 80 00 09 be 4000669c <rtems_termios_ioctl+0x218> <== NOT EXECUTED
4000667c: 01 00 00 00 nop <== NOT EXECUTED
40006680: c4 07 60 b0 ld [ %i5 + 0xb0 ], %g2 <== NOT EXECUTED
40006684: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40006688: 02 80 00 05 be 4000669c <rtems_termios_ioctl+0x218> <== NOT EXECUTED
4000668c: 01 00 00 00 nop <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
40006690: 9f c0 80 00 call %g2 <== NOT EXECUTED
40006694: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
40006698: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
4000669c: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
400066a0: 84 08 bf fb and %g2, -5, %g2 <== NOT EXECUTED
400066a4: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ] <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
400066a8: 80 a0 60 00 cmp %g1, 0
400066ac: 06 80 00 7f bl 400068a8 <rtems_termios_ioctl+0x424> <== NEVER TAKEN
400066b0: 01 00 00 00 nop
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
400066b4: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
400066b8: 05 00 00 04 sethi %hi(0x1000), %g2
400066bc: 80 88 40 02 btst %g1, %g2
400066c0: 02 80 00 06 be 400066d8 <rtems_termios_ioctl+0x254>
400066c4: 80 88 64 00 btst 0x400, %g1
tty->flow_ctrl |= FL_MDXOF;
400066c8: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2
400066cc: 84 10 a4 00 or %g2, 0x400, %g2
400066d0: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ]
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
400066d4: 80 88 64 00 btst 0x400, %g1
400066d8: 22 80 00 06 be,a 400066f0 <rtems_termios_ioctl+0x26c>
400066dc: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl |= FL_MDXON;
400066e0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
400066e4: 82 10 62 00 or %g1, 0x200, %g1
400066e8: 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) {
400066ec: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
400066f0: 80 88 60 02 btst 2, %g1
400066f4: 02 80 00 51 be 40006838 <rtems_termios_ioctl+0x3b4>
400066f8: 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;
400066fc: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
40006700: c0 27 60 70 clr [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
40006704: c0 27 60 74 clr [ %i5 + 0x74 ]
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
40006708: c2 07 60 a8 ld [ %i5 + 0xa8 ], %g1
4000670c: 80 a0 60 00 cmp %g1, 0
40006710: 02 bf ff 89 be 40006534 <rtems_termios_ioctl+0xb0> <== NEVER TAKEN
40006714: 01 00 00 00 nop
(*tty->device.setAttributes)(tty->minor, &tty->termios);
40006718: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
4000671c: 9f c0 40 00 call %g1
40006720: 92 10 00 1c mov %i4, %o1
40006724: 30 bf ff 84 b,a 40006534 <rtems_termios_ioctl+0xb0>
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
40006728: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
4000672c: c2 07 60 5c ld [ %i5 + 0x5c ], %g1 <== NOT EXECUTED
if ( rawnc < 0 )
40006730: 82 a0 80 01 subcc %g2, %g1, %g1 <== NOT EXECUTED
40006734: 0c 80 00 5a bneg 4000689c <rtems_termios_ioctl+0x418> <== NOT EXECUTED
40006738: 01 00 00 00 nop <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
4000673c: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
40006740: c4 07 60 24 ld [ %i5 + 0x24 ], %g2 <== NOT EXECUTED
40006744: c6 07 20 08 ld [ %i4 + 8 ], %g3 <== NOT EXECUTED
40006748: 84 21 00 02 sub %g4, %g2, %g2 <== NOT EXECUTED
4000674c: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
}
break;
40006750: 10 bf ff 79 b 40006534 <rtems_termios_ioctl+0xb0> <== NOT EXECUTED
40006754: c2 20 c0 00 st %g1, [ %g3 ] <== NOT EXECUTED
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
40006758: 84 10 a0 1a or %g2, 0x1a, %g2
4000675c: 80 a0 40 02 cmp %g1, %g2
40006760: 02 80 00 2e be 40006818 <rtems_termios_ioctl+0x394>
40006764: 05 20 01 1d sethi %hi(0x80047400), %g2
40006768: 84 10 a0 1b or %g2, 0x1b, %g2 ! 8004741b <LEON_REG+0x4741b>
4000676c: 80 a0 40 02 cmp %g1, %g2
40006770: 32 bf ff 61 bne,a 400064f4 <rtems_termios_ioctl+0x70> <== NEVER TAKEN
40006774: c4 07 60 cc ld [ %i5 + 0xcc ], %g2 <== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
40006778: c2 07 60 cc ld [ %i5 + 0xcc ], %g1
4000677c: 37 10 00 7f sethi %hi(0x4001fc00), %i3
40006780: 83 28 60 05 sll %g1, 5, %g1
40006784: b6 16 e1 34 or %i3, 0x134, %i3
40006788: 82 06 c0 01 add %i3, %g1, %g1
4000678c: c2 00 60 04 ld [ %g1 + 4 ], %g1
40006790: 80 a0 60 00 cmp %g1, 0
40006794: 22 80 00 06 be,a 400067ac <rtems_termios_ioctl+0x328>
40006798: c2 07 20 08 ld [ %i4 + 8 ], %g1
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
4000679c: 9f c0 40 00 call %g1
400067a0: 90 10 00 1d mov %i5, %o0
400067a4: b0 10 00 08 mov %o0, %i0
}
tty->t_line=*(int*)(args->buffer);
400067a8: c2 07 20 08 ld [ %i4 + 8 ], %g1
400067ac: c2 00 40 00 ld [ %g1 ], %g1
tty->t_sc = NULL; /* ensure that no more valid data */
400067b0: c0 27 60 d0 clr [ %i5 + 0xd0 ]
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
400067b4: 85 28 60 05 sll %g1, 5, %g2
400067b8: c4 06 c0 02 ld [ %i3 + %g2 ], %g2
400067bc: 80 a0 a0 00 cmp %g2, 0
400067c0: 02 bf ff 5d be 40006534 <rtems_termios_ioctl+0xb0>
400067c4: c2 27 60 cc st %g1, [ %i5 + 0xcc ]
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
400067c8: 9f c0 80 00 call %g2
400067cc: 90 10 00 1d mov %i5, %o0
400067d0: 10 bf ff 59 b 40006534 <rtems_termios_ioctl+0xb0>
400067d4: b0 10 00 08 mov %o0, %i0
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
400067d8: 02 80 00 09 be 400067fc <rtems_termios_ioctl+0x378>
400067dc: 80 a0 60 04 cmp %g1, 4
400067e0: 32 bf ff 45 bne,a 400064f4 <rtems_termios_ioctl+0x70> <== NEVER TAKEN
400067e4: 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;
400067e8: c2 06 c0 00 ld [ %i3 ], %g1
400067ec: c2 27 60 dc st %g1, [ %i5 + 0xdc ]
400067f0: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
400067f4: 10 bf ff 50 b 40006534 <rtems_termios_ioctl+0xb0>
400067f8: c2 27 60 e0 st %g1, [ %i5 + 0xe0 ]
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
400067fc: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40006800: 80 a0 60 00 cmp %g1, 0
40006804: 02 bf ff 4c be 40006534 <rtems_termios_ioctl+0xb0> <== ALWAYS TAKEN
40006808: 01 00 00 00 nop
4000680c: 7f ff fd 6f call 40005dc8 <drainOutput.part.0> <== NOT EXECUTED
40006810: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40006814: 30 bf ff 48 b,a 40006534 <rtems_termios_ioctl+0xb0> <== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
40006818: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
4000681c: c2 07 20 08 ld [ %i4 + 8 ], %g1
break;
40006820: 10 bf ff 45 b 40006534 <rtems_termios_ioctl+0xb0>
40006824: c4 20 40 00 st %g2, [ %g1 ]
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
40006828: 92 07 60 30 add %i5, 0x30, %o1
4000682c: 40 00 2a 96 call 40011284 <memcpy>
40006830: 94 10 20 24 mov 0x24, %o2
break;
40006834: 30 bf ff 40 b,a 40006534 <rtems_termios_ioctl+0xb0>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
40006838: 40 00 05 8d call 40007e6c <rtems_clock_get_ticks_per_second>
4000683c: f6 0f 60 46 ldub [ %i5 + 0x46 ], %i3
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
40006840: 40 00 4c 53 call 4001998c <.umul>
40006844: 92 10 00 1b mov %i3, %o1
rtems_clock_get_ticks_per_second() / 10;
40006848: 40 00 4c 8b call 40019a74 <.udiv>
4000684c: 92 10 20 0a mov 0xa, %o1
if (tty->termios.c_cc[VTIME]) {
40006850: 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] *
40006854: d0 27 60 54 st %o0, [ %i5 + 0x54 ]
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
40006858: 80 a0 60 00 cmp %g1, 0
4000685c: 02 80 00 26 be 400068f4 <rtems_termios_ioctl+0x470>
40006860: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
40006864: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
40006868: 80 a0 60 00 cmp %g1, 0
4000686c: 12 bf ff a6 bne 40006704 <rtems_termios_ioctl+0x280>
40006870: d0 27 60 70 st %o0, [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
40006874: 10 bf ff a5 b 40006708 <rtems_termios_ioctl+0x284>
40006878: d0 27 60 74 st %o0, [ %i5 + 0x74 ]
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
4000687c: 7f ff ef 15 call 400024d0 <sparc_disable_interrupts>
40006880: 01 00 00 00 nop
tty->rawOutBuf.Tail = 0;
40006884: c0 27 60 84 clr [ %i5 + 0x84 ]
tty->rawOutBuf.Head = 0;
40006888: c0 27 60 80 clr [ %i5 + 0x80 ]
tty->rawOutBufState = rob_idle;
4000688c: c0 27 60 94 clr [ %i5 + 0x94 ]
rtems_interrupt_enable (level);
40006890: 7f ff ef 14 call 400024e0 <sparc_enable_interrupts>
40006894: 01 00 00 00 nop
40006898: 30 bf ff 27 b,a 40006534 <rtems_termios_ioctl+0xb0>
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
4000689c: c4 07 60 64 ld [ %i5 + 0x64 ], %g2 <== NOT EXECUTED
400068a0: 10 bf ff a7 b 4000673c <rtems_termios_ioctl+0x2b8> <== NOT EXECUTED
400068a4: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
400068a8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
400068ac: 82 10 61 00 or %g1, 0x100, %g1 <== NOT EXECUTED
400068b0: 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) {
400068b4: 10 bf ff 81 b 400066b8 <rtems_termios_ioctl+0x234> <== NOT EXECUTED
400068b8: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
400068bc: 7f ff ef 05 call 400024d0 <sparc_disable_interrupts>
400068c0: 01 00 00 00 nop
tty->rawOutBuf.Tail = 0;
400068c4: c0 27 60 84 clr [ %i5 + 0x84 ]
tty->rawOutBuf.Head = 0;
400068c8: c0 27 60 80 clr [ %i5 + 0x80 ]
tty->rawOutBufState = rob_idle;
400068cc: c0 27 60 94 clr [ %i5 + 0x94 ]
rtems_interrupt_enable (level);
400068d0: 7f ff ef 04 call 400024e0 <sparc_enable_interrupts>
400068d4: 01 00 00 00 nop
static void
flushInput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
400068d8: 7f ff ee fe call 400024d0 <sparc_disable_interrupts>
400068dc: 01 00 00 00 nop
tty->rawInBuf.Tail = 0;
400068e0: c0 27 60 60 clr [ %i5 + 0x60 ]
tty->rawInBuf.Head = 0;
400068e4: c0 27 60 5c clr [ %i5 + 0x5c ]
rtems_interrupt_enable (level);
400068e8: 7f ff ee fe call 400024e0 <sparc_enable_interrupts>
400068ec: 01 00 00 00 nop
400068f0: 30 bf ff 11 b,a 40006534 <rtems_termios_ioctl+0xb0>
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
400068f4: 80 a0 60 00 cmp %g1, 0
400068f8: 32 bf ff 82 bne,a 40006700 <rtems_termios_ioctl+0x27c> <== NEVER TAKEN
400068fc: c0 27 60 6c clr [ %i5 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
40006900: 82 10 20 01 mov 1, %g1
40006904: 10 bf ff 81 b 40006708 <rtems_termios_ioctl+0x284>
40006908: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
4000690c: 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)(
40006910: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
40006914: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
40006918: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
4000691c: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
40006920: 9f c0 40 00 call %g1 <== NOT EXECUTED
40006924: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
40006928: 30 bf ff 37 b,a 40006604 <rtems_termios_ioctl+0x180> <== NOT EXECUTED
40005e44 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
40005e44: 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(
40005e48: 23 10 00 80 sethi %hi(0x40020000), %l1
40005e4c: d0 04 61 60 ld [ %l1 + 0x160 ], %o0 ! 40020160 <rtems_termios_ttyMutex>
40005e50: 92 10 20 00 clr %o1
40005e54: 94 10 20 00 clr %o2
40005e58: 40 00 09 cd call 4000858c <rtems_semaphore_obtain>
40005e5c: b8 10 00 18 mov %i0, %i4
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40005e60: 80 a2 20 00 cmp %o0, 0
40005e64: 12 80 00 28 bne 40005f04 <rtems_termios_open+0xc0> <== NEVER TAKEN
40005e68: a0 10 00 08 mov %o0, %l0
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
40005e6c: 25 10 00 80 sethi %hi(0x40020000), %l2
40005e70: f0 04 a1 68 ld [ %l2 + 0x168 ], %i0 ! 40020168 <rtems_termios_ttyHead>
40005e74: 80 a6 20 00 cmp %i0, 0
40005e78: 02 80 00 25 be 40005f0c <rtems_termios_open+0xc8>
40005e7c: ba 10 00 18 mov %i0, %i5
if ((tty->major == major) && (tty->minor == minor))
40005e80: 10 80 00 06 b 40005e98 <rtems_termios_open+0x54>
40005e84: c2 07 60 0c ld [ %i5 + 0xc ], %g1
sc = rtems_semaphore_obtain(
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
40005e88: 80 a7 60 00 cmp %i5, 0
40005e8c: 02 80 00 21 be 40005f10 <rtems_termios_open+0xcc> <== ALWAYS TAKEN
40005e90: 90 10 20 01 mov 1, %o0
if ((tty->major == major) && (tty->minor == minor))
40005e94: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
40005e98: 80 a0 40 1c cmp %g1, %i4
40005e9c: 32 bf ff fb bne,a 40005e88 <rtems_termios_open+0x44>
40005ea0: fa 07 40 00 ld [ %i5 ], %i5
40005ea4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40005ea8: 80 a0 40 19 cmp %g1, %i1
40005eac: 32 bf ff f7 bne,a 40005e88 <rtems_termios_open+0x44> <== NEVER TAKEN
40005eb0: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
40005eb4: c4 06 80 00 ld [ %i2 ], %g2
if (!tty->refcount++) {
40005eb8: c2 07 60 08 ld [ %i5 + 8 ], %g1
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
40005ebc: fa 20 a0 30 st %i5, [ %g2 + 0x30 ]
if (!tty->refcount++) {
40005ec0: 84 00 60 01 add %g1, 1, %g2
40005ec4: 80 a0 60 00 cmp %g1, 0
40005ec8: 12 80 00 0d bne 40005efc <rtems_termios_open+0xb8>
40005ecc: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (tty->device.firstOpen)
40005ed0: c2 07 60 98 ld [ %i5 + 0x98 ], %g1
40005ed4: 80 a0 60 00 cmp %g1, 0
40005ed8: 02 80 00 05 be 40005eec <rtems_termios_open+0xa8> <== ALWAYS TAKEN
40005edc: 90 10 00 1c mov %i4, %o0
(*tty->device.firstOpen)(major, minor, arg);
40005ee0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40005ee4: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005ee8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40005eec: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40005ef0: 80 a0 60 02 cmp %g1, 2
40005ef4: 22 80 00 9e be,a 4000616c <rtems_termios_open+0x328>
40005ef8: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
40005efc: 40 00 09 f3 call 400086c8 <rtems_semaphore_release>
40005f00: d0 04 61 60 ld [ %l1 + 0x160 ], %o0
return RTEMS_SUCCESSFUL;
}
40005f04: 81 c7 e0 08 ret
40005f08: 91 e8 00 10 restore %g0, %l0, %o0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
40005f0c: 90 10 20 01 mov 1, %o0
40005f10: 7f ff f8 0f call 40003f4c <calloc>
40005f14: 92 10 20 e8 mov 0xe8, %o1
if (tty == NULL) {
40005f18: ba 92 20 00 orcc %o0, 0, %i5
40005f1c: 02 80 00 a9 be 400061c0 <rtems_termios_open+0x37c>
40005f20: 03 10 00 7d sethi %hi(0x4001f400), %g1
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
40005f24: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 ! 4001f5e0 <rtems_termios_raw_input_size>
40005f28: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
40005f2c: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
40005f30: 7f ff f9 90 call 40004570 <malloc>
40005f34: 01 00 00 00 nop
40005f38: d0 27 60 58 st %o0, [ %i5 + 0x58 ]
if (tty->rawInBuf.theBuf == NULL) {
40005f3c: 80 a2 20 00 cmp %o0, 0
40005f40: 02 80 00 9e be 400061b8 <rtems_termios_open+0x374>
40005f44: a6 10 00 08 mov %o0, %l3
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
40005f48: 03 10 00 7d sethi %hi(0x4001f400), %g1
40005f4c: c2 00 61 e4 ld [ %g1 + 0x1e4 ], %g1 ! 4001f5e4 <rtems_termios_raw_output_size>
40005f50: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
40005f54: d0 07 60 88 ld [ %i5 + 0x88 ], %o0
40005f58: 7f ff f9 86 call 40004570 <malloc>
40005f5c: 01 00 00 00 nop
40005f60: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
if (tty->rawOutBuf.theBuf == NULL) {
40005f64: 80 a2 20 00 cmp %o0, 0
40005f68: 02 80 00 92 be 400061b0 <rtems_termios_open+0x36c>
40005f6c: a8 10 00 08 mov %o0, %l4
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
40005f70: 03 10 00 7d sethi %hi(0x4001f400), %g1
40005f74: 7f ff f9 7f call 40004570 <malloc>
40005f78: d0 00 61 e8 ld [ %g1 + 0x1e8 ], %o0 ! 4001f5e8 <rtems_termios_cbufsize>
if (tty->cbuf == NULL) {
40005f7c: 80 a2 20 00 cmp %o0, 0
40005f80: 02 80 00 8a be 400061a8 <rtems_termios_open+0x364>
40005f84: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
40005f88: c0 27 60 d4 clr [ %i5 + 0xd4 ]
tty->tty_snd.sw_arg = NULL;
40005f8c: c0 27 60 d8 clr [ %i5 + 0xd8 ]
tty->tty_rcv.sw_pfn = NULL;
40005f90: c0 27 60 dc clr [ %i5 + 0xdc ]
tty->tty_rcv.sw_arg = NULL;
40005f94: c0 27 60 e0 clr [ %i5 + 0xe0 ]
tty->tty_rcvwakeup = 0;
40005f98: c0 27 60 e4 clr [ %i5 + 0xe4 ]
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
40005f9c: f0 27 40 00 st %i0, [ %i5 ]
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
40005fa0: 80 a6 20 00 cmp %i0, 0
40005fa4: 02 80 00 03 be 40005fb0 <rtems_termios_open+0x16c>
40005fa8: c0 27 60 04 clr [ %i5 + 4 ]
rtems_termios_ttyHead->back = tty;
40005fac: fa 26 20 04 st %i5, [ %i0 + 4 ]
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
40005fb0: 03 10 00 80 sethi %hi(0x40020000), %g1
40005fb4: c4 00 61 64 ld [ %g1 + 0x164 ], %g2 ! 40020164 <rtems_termios_ttyTail>
40005fb8: 80 a0 a0 00 cmp %g2, 0
40005fbc: 02 80 00 ac be 4000626c <rtems_termios_open+0x428>
40005fc0: fa 24 a1 68 st %i5, [ %l2 + 0x168 ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
40005fc4: 31 10 00 7d sethi %hi(0x4001f400), %i0
40005fc8: d0 4e 21 ec ldsb [ %i0 + 0x1ec ], %o0 ! 4001f5ec <c.6875>
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
40005fcc: 03 15 14 9a sethi %hi(0x54526800), %g1
40005fd0: 82 10 61 00 or %g1, 0x100, %g1 ! 54526900 <RAM_END+0x14126900>
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
40005fd4: f2 27 60 10 st %i1, [ %i5 + 0x10 ]
tty->major = major;
40005fd8: f8 27 60 0c st %i4, [ %i5 + 0xc ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
40005fdc: 92 10 20 01 mov 1, %o1
40005fe0: 94 10 20 54 mov 0x54, %o2
40005fe4: 90 12 00 01 or %o0, %g1, %o0
40005fe8: 96 10 20 00 clr %o3
40005fec: 40 00 08 c0 call 400082ec <rtems_semaphore_create>
40005ff0: 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)
40005ff4: 80 a2 20 00 cmp %o0, 0
40005ff8: 12 80 00 84 bne 40006208 <rtems_termios_open+0x3c4>
40005ffc: 03 15 14 9b sethi %hi(0x54526c00), %g1
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'o', c),
40006000: d0 4e 21 ec ldsb [ %i0 + 0x1ec ], %o0
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
40006004: 82 10 63 00 or %g1, 0x300, %g1
40006008: 92 10 20 01 mov 1, %o1
4000600c: 94 10 20 54 mov 0x54, %o2
40006010: 90 12 00 01 or %o0, %g1, %o0
40006014: 96 10 20 00 clr %o3
40006018: 40 00 08 b5 call 400082ec <rtems_semaphore_create>
4000601c: 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)
40006020: 80 a2 20 00 cmp %o0, 0
40006024: 12 80 00 79 bne 40006208 <rtems_termios_open+0x3c4>
40006028: 03 15 14 9e sethi %hi(0x54527800), %g1
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'x', c),
4000602c: d0 4e 21 ec ldsb [ %i0 + 0x1ec ], %o0
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
40006030: 92 10 20 00 clr %o1
40006034: 90 12 00 01 or %o0, %g1, %o0
40006038: 94 10 20 20 mov 0x20, %o2
4000603c: 96 10 20 00 clr %o3
40006040: 40 00 08 ab call 400082ec <rtems_semaphore_create>
40006044: 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)
40006048: 80 a2 20 00 cmp %o0, 0
4000604c: 12 80 00 6f bne 40006208 <rtems_termios_open+0x3c4>
40006050: 92 10 00 1b mov %i3, %o1
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
40006054: c0 27 60 94 clr [ %i5 + 0x94 ]
/*
* Set callbacks
*/
tty->device = *callbacks;
40006058: 90 07 60 98 add %i5, 0x98, %o0
4000605c: 40 00 2c 8a call 40011284 <memcpy>
40006060: 94 10 20 20 mov 0x20, %o2
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40006064: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40006068: 80 a0 60 02 cmp %g1, 2
4000606c: 02 80 00 69 be 40006210 <rtems_termios_open+0x3cc>
40006070: d0 4e 21 ec ldsb [ %i0 + 0x1ec ], %o0
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
40006074: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40006078: 80 a0 60 00 cmp %g1, 0
4000607c: 02 80 00 58 be 400061dc <rtems_termios_open+0x398>
40006080: d0 4e 21 ec ldsb [ %i0 + 0x1ec ], %o0
40006084: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
40006088: 80 a0 60 02 cmp %g1, 2
4000608c: 02 80 00 55 be 400061e0 <rtems_termios_open+0x39c>
40006090: 03 15 14 9c sethi %hi(0x54527000), %g1
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
40006094: c0 27 60 b8 clr [ %i5 + 0xb8 ]
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
40006098: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
tty->highwater = tty->rawInBuf.Size * 3/4;
4000609c: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
/*
* Bump name characer
*/
if (c++ == 'z')
400060a0: c6 4e 21 ec ldsb [ %i0 + 0x1ec ], %g3
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
400060a4: 89 28 60 01 sll %g1, 1, %g4
400060a8: 82 01 00 01 add %g4, %g1, %g1
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
400060ac: 09 00 00 06 sethi %hi(0x1800), %g4
400060b0: 88 11 20 05 or %g4, 5, %g4 ! 1805 <PROM_START+0x1805>
400060b4: c8 27 60 34 st %g4, [ %i5 + 0x34 ]
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
400060b8: 88 10 28 bd mov 0x8bd, %g4
400060bc: c8 27 60 38 st %g4, [ %i5 + 0x38 ]
tty->termios.c_lflag =
400060c0: 09 00 00 20 sethi %hi(0x8000), %g4
400060c4: 88 11 22 3b or %g4, 0x23b, %g4 ! 823b <PROM_START+0x823b>
400060c8: c8 27 60 3c st %g4, [ %i5 + 0x3c ]
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
400060cc: 88 10 20 03 mov 3, %g4
400060d0: c8 2f 60 41 stb %g4, [ %i5 + 0x41 ]
tty->termios.c_cc[VQUIT] = '\034';
400060d4: 88 10 20 1c mov 0x1c, %g4
400060d8: c8 2f 60 42 stb %g4, [ %i5 + 0x42 ]
tty->termios.c_cc[VERASE] = '\177';
400060dc: 88 10 20 7f mov 0x7f, %g4
400060e0: c8 2f 60 43 stb %g4, [ %i5 + 0x43 ]
tty->termios.c_cc[VKILL] = '\025';
400060e4: 88 10 20 15 mov 0x15, %g4
400060e8: c8 2f 60 44 stb %g4, [ %i5 + 0x44 ]
tty->termios.c_cc[VEOF] = '\004';
400060ec: 88 10 20 04 mov 4, %g4
400060f0: c8 2f 60 45 stb %g4, [ %i5 + 0x45 ]
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
400060f4: 88 10 20 11 mov 0x11, %g4
400060f8: c8 2f 60 49 stb %g4, [ %i5 + 0x49 ]
tty->termios.c_cc[VSTOP] = '\023';
400060fc: 88 10 20 13 mov 0x13, %g4
40006100: c8 2f 60 4a stb %g4, [ %i5 + 0x4a ]
tty->termios.c_cc[VSUSP] = '\032';
40006104: 88 10 20 1a mov 0x1a, %g4
40006108: c8 2f 60 4b stb %g4, [ %i5 + 0x4b ]
tty->termios.c_cc[VREPRINT] = '\022';
4000610c: 88 10 20 12 mov 0x12, %g4
40006110: c8 2f 60 4d stb %g4, [ %i5 + 0x4d ]
tty->termios.c_cc[VDISCARD] = '\017';
40006114: 88 10 20 0f mov 0xf, %g4
40006118: c8 2f 60 4e stb %g4, [ %i5 + 0x4e ]
tty->termios.c_cc[VWERASE] = '\027';
4000611c: 88 10 20 17 mov 0x17, %g4
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
40006120: 85 30 a0 01 srl %g2, 1, %g2
tty->highwater = tty->rawInBuf.Size * 3/4;
40006124: 83 30 60 02 srl %g1, 2, %g1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
40006128: 37 00 00 09 sethi %hi(0x2400), %i3
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
4000612c: c8 2f 60 4f stb %g4, [ %i5 + 0x4f ]
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
40006130: b6 16 e1 02 or %i3, 0x102, %i3
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
40006134: 88 10 20 16 mov 0x16, %g4
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
40006138: c4 27 60 bc st %g2, [ %i5 + 0xbc ]
tty->highwater = tty->rawInBuf.Size * 3/4;
4000613c: c2 27 60 c0 st %g1, [ %i5 + 0xc0 ]
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
40006140: f6 27 60 30 st %i3, [ %i5 + 0x30 ]
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
40006144: c0 2f 60 4c clrb [ %i5 + 0x4c ]
tty->termios.c_cc[VEOL2] = '\000';
40006148: c0 2f 60 51 clrb [ %i5 + 0x51 ]
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
4000614c: c8 2f 60 50 stb %g4, [ %i5 + 0x50 ]
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
40006150: 03 10 00 7d sethi %hi(0x4001f400), %g1
40006154: 80 a0 e0 7a cmp %g3, 0x7a
40006158: 02 80 00 1e be 400061d0 <rtems_termios_open+0x38c>
4000615c: c4 0e 21 ec ldub [ %i0 + 0x1ec ], %g2
40006160: 84 00 a0 01 inc %g2
40006164: 10 bf ff 54 b 40005eb4 <rtems_termios_open+0x70>
40006168: c4 28 61 ec stb %g2, [ %g1 + 0x1ec ]
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(
4000616c: 94 10 00 1d mov %i5, %o2
40006170: 13 10 00 1e sethi %hi(0x40007800), %o1
40006174: 40 00 0a 39 call 40008a58 <rtems_task_start>
40006178: 92 12 60 d8 or %o1, 0xd8, %o1 ! 400078d8 <rtems_termios_rxdaemon>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
4000617c: 80 a2 20 00 cmp %o0, 0
40006180: 12 80 00 22 bne 40006208 <rtems_termios_open+0x3c4> <== NEVER TAKEN
40006184: 94 10 00 1d mov %i5, %o2
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
40006188: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
4000618c: 13 10 00 17 sethi %hi(0x40005c00), %o1
40006190: 40 00 0a 32 call 40008a58 <rtems_task_start>
40006194: 92 12 61 58 or %o1, 0x158, %o1 ! 40005d58 <rtems_termios_txdaemon>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
40006198: 80 a2 20 00 cmp %o0, 0
4000619c: 02 bf ff 58 be 40005efc <rtems_termios_open+0xb8> <== ALWAYS TAKEN
400061a0: 01 00 00 00 nop
400061a4: 30 80 00 19 b,a 40006208 <rtems_termios_open+0x3c4> <== NOT EXECUTED
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
400061a8: 7f ff f8 18 call 40004208 <free>
400061ac: 90 10 00 14 mov %l4, %o0
free((void *)(tty->rawInBuf.theBuf));
400061b0: 7f ff f8 16 call 40004208 <free>
400061b4: 90 10 00 13 mov %l3, %o0
free(tty);
400061b8: 7f ff f8 14 call 40004208 <free>
400061bc: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release (rtems_termios_ttyMutex);
400061c0: d0 04 61 60 ld [ %l1 + 0x160 ], %o0
400061c4: 40 00 09 41 call 400086c8 <rtems_semaphore_release>
400061c8: a0 10 20 1a mov 0x1a, %l0
return RTEMS_NO_MEMORY;
400061cc: 30 bf ff 4e b,a 40005f04 <rtems_termios_open+0xc0>
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
400061d0: 84 10 20 61 mov 0x61, %g2
400061d4: 10 bf ff 38 b 40005eb4 <rtems_termios_open+0x70>
400061d8: c4 28 61 ec stb %g2, [ %g1 + 0x1ec ]
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
400061dc: 03 15 14 9c sethi %hi(0x54527000), %g1
400061e0: 82 10 62 00 or %g1, 0x200, %g1 ! 54527200 <RAM_END+0x14127200>
400061e4: 92 10 20 00 clr %o1
400061e8: 94 10 20 24 mov 0x24, %o2
400061ec: 90 12 00 01 or %o0, %g1, %o0
400061f0: 96 10 20 00 clr %o3
400061f4: 40 00 08 3e call 400082ec <rtems_semaphore_create>
400061f8: 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)
400061fc: 80 a2 20 00 cmp %o0, 0
40006200: 02 bf ff a5 be 40006094 <rtems_termios_open+0x250> <== ALWAYS TAKEN
40006204: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
40006208: 40 00 0a c6 call 40008d20 <rtems_fatal_error_occurred>
4000620c: 01 00 00 00 nop
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
40006210: 03 15 1e 15 sethi %hi(0x54785400), %g1
40006214: 92 10 20 0a mov 0xa, %o1
40006218: 90 12 00 01 or %o0, %g1, %o0
4000621c: 94 10 24 00 mov 0x400, %o2
40006220: 96 10 25 00 mov 0x500, %o3
40006224: 98 10 20 00 clr %o4
40006228: 40 00 09 68 call 400087c8 <rtems_task_create>
4000622c: 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)
40006230: 80 a2 20 00 cmp %o0, 0
40006234: 12 bf ff f5 bne 40006208 <rtems_termios_open+0x3c4> <== NEVER TAKEN
40006238: 03 14 9e 15 sethi %hi(0x52785400), %g1
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
4000623c: d0 4e 21 ec ldsb [ %i0 + 0x1ec ], %o0
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
40006240: 92 10 20 09 mov 9, %o1
40006244: 90 12 00 01 or %o0, %g1, %o0
40006248: 94 10 24 00 mov 0x400, %o2
4000624c: 96 10 25 00 mov 0x500, %o3
40006250: 98 10 20 00 clr %o4
40006254: 40 00 09 5d call 400087c8 <rtems_task_create>
40006258: 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)
4000625c: 80 a2 20 00 cmp %o0, 0
40006260: 22 bf ff 86 be,a 40006078 <rtems_termios_open+0x234> <== ALWAYS TAKEN
40006264: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40006268: 30 bf ff e8 b,a 40006208 <rtems_termios_open+0x3c4> <== NOT EXECUTED
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
4000626c: 10 bf ff 56 b 40005fc4 <rtems_termios_open+0x180>
40006270: fa 20 61 64 st %i5, [ %g1 + 0x164 ]
4000692c <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, size_t len, struct rtems_termios_tty *tty)
{
4000692c: 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) {
40006930: c2 06 a0 b4 ld [ %i2 + 0xb4 ], %g1
40006934: 80 a0 60 00 cmp %g1, 0
40006938: 22 80 00 44 be,a 40006a48 <rtems_termios_puts+0x11c>
4000693c: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
40006940: e0 06 a0 80 ld [ %i2 + 0x80 ], %l0
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
40006944: 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) {
40006948: 80 a6 60 00 cmp %i1, 0
4000694c: 02 80 00 34 be 40006a1c <rtems_termios_puts+0xf0> <== NEVER TAKEN
40006950: a2 10 20 01 mov 1, %l1
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
40006954: d2 06 a0 88 ld [ %i2 + 0x88 ], %o1
40006958: 40 00 4c f3 call 40019d24 <.urem>
4000695c: 90 04 20 01 add %l0, 1, %o0
rtems_interrupt_disable (level);
40006960: 7f ff ee dc call 400024d0 <sparc_disable_interrupts>
40006964: a0 10 00 08 mov %o0, %l0
40006968: ba 10 00 08 mov %o0, %i5
while (newHead == tty->rawOutBuf.Tail) {
4000696c: f8 06 a0 84 ld [ %i2 + 0x84 ], %i4
40006970: 80 a7 00 10 cmp %i4, %l0
40006974: 32 80 00 14 bne,a 400069c4 <rtems_termios_puts+0x98>
40006978: c6 0e 00 00 ldub [ %i0 ], %g3
tty->rawOutBufState = rob_wait;
4000697c: f6 26 a0 94 st %i3, [ %i2 + 0x94 ]
rtems_interrupt_enable (level);
40006980: 7f ff ee d8 call 400024e0 <sparc_enable_interrupts>
40006984: 90 10 00 1d mov %i5, %o0
sc = rtems_semaphore_obtain(
40006988: d0 06 a0 8c ld [ %i2 + 0x8c ], %o0
4000698c: 92 10 20 00 clr %o1
40006990: 40 00 06 ff call 4000858c <rtems_semaphore_obtain>
40006994: 94 10 20 00 clr %o2
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40006998: 80 a2 20 00 cmp %o0, 0
4000699c: 12 80 00 31 bne 40006a60 <rtems_termios_puts+0x134> <== NEVER TAKEN
400069a0: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
400069a4: 7f ff ee cb call 400024d0 <sparc_disable_interrupts>
400069a8: 01 00 00 00 nop
400069ac: ba 10 00 08 mov %o0, %i5
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
400069b0: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1
400069b4: 80 a0 40 1c cmp %g1, %i4
400069b8: 22 bf ff f2 be,a 40006980 <rtems_termios_puts+0x54> <== NEVER TAKEN
400069bc: f6 26 a0 94 st %i3, [ %i2 + 0x94 ] <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
400069c0: c6 0e 00 00 ldub [ %i0 ], %g3
400069c4: c2 06 a0 80 ld [ %i2 + 0x80 ], %g1
400069c8: c4 06 a0 7c ld [ %i2 + 0x7c ], %g2
400069cc: b0 06 20 01 inc %i0
400069d0: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
400069d4: 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;
400069d8: e0 26 a0 80 st %l0, [ %i2 + 0x80 ]
if (tty->rawOutBufState == rob_idle) {
400069dc: 80 a0 60 00 cmp %g1, 0
400069e0: 12 80 00 0a bne 40006a08 <rtems_termios_puts+0xdc>
400069e4: 01 00 00 00 nop
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
400069e8: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1
400069ec: 80 88 60 10 btst 0x10, %g1
400069f0: 02 80 00 0d be 40006a24 <rtems_termios_puts+0xf8> <== ALWAYS TAKEN
400069f4: 01 00 00 00 nop
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
400069f8: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED
400069fc: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
40006a00: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ] <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
40006a04: e2 26 a0 94 st %l1, [ %i2 + 0x94 ] <== NOT EXECUTED
}
rtems_interrupt_enable (level);
40006a08: 7f ff ee b6 call 400024e0 <sparc_enable_interrupts>
40006a0c: 90 10 00 1d mov %i5, %o0
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
40006a10: b2 86 7f ff addcc %i1, -1, %i1
40006a14: 12 bf ff d0 bne 40006954 <rtems_termios_puts+0x28>
40006a18: 01 00 00 00 nop
40006a1c: 81 c7 e0 08 ret
40006a20: 81 e8 00 00 restore
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
40006a24: 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)(
40006a28: d2 06 a0 7c ld [ %i2 + 0x7c ], %o1
40006a2c: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
40006a30: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
40006a34: 92 02 40 02 add %o1, %g2, %o1
40006a38: 9f c0 40 00 call %g1
40006a3c: 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;
40006a40: 10 bf ff f2 b 40006a08 <rtems_termios_puts+0xdc>
40006a44: e2 26 a0 94 st %l1, [ %i2 + 0x94 ]
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
40006a48: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
40006a4c: 92 10 00 18 mov %i0, %o1
40006a50: 9f c0 40 00 call %g1
40006a54: 94 10 00 19 mov %i1, %o2
return;
40006a58: 81 c7 e0 08 ret
40006a5c: 81 e8 00 00 restore
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
40006a60: 40 00 08 b0 call 40008d20 <rtems_fatal_error_occurred> <== NOT EXECUTED
400071bc <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
400071bc: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
400071c0: c2 06 00 00 ld [ %i0 ], %g1
uint32_t count = args->count;
400071c4: f6 06 20 14 ld [ %i0 + 0x14 ], %i3
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
400071c8: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
uint32_t count = args->count;
char *buffer = args->buffer;
400071cc: e4 06 20 10 ld [ %i0 + 0x10 ], %l2
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400071d0: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
400071d4: 92 10 20 00 clr %o1
400071d8: 40 00 04 ed call 4000858c <rtems_semaphore_obtain>
400071dc: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
400071e0: a0 92 20 00 orcc %o0, 0, %l0
400071e4: 12 80 00 10 bne 40007224 <rtems_termios_read+0x68> <== NEVER TAKEN
400071e8: 03 10 00 7f sethi %hi(0x4001fc00), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
400071ec: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
400071f0: 85 28 a0 05 sll %g2, 5, %g2
400071f4: 82 10 61 34 or %g1, 0x134, %g1
400071f8: 82 00 40 02 add %g1, %g2, %g1
400071fc: c2 00 60 08 ld [ %g1 + 8 ], %g1
40007200: 80 a0 60 00 cmp %g1, 0
40007204: 02 80 00 0a be 4000722c <rtems_termios_read+0x70>
40007208: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
4000720c: 9f c0 40 00 call %g1
40007210: 92 10 00 18 mov %i0, %o1
40007214: a0 10 00 08 mov %o0, %l0
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
40007218: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
4000721c: 40 00 05 2b call 400086c8 <rtems_semaphore_release>
40007220: c0 27 60 e4 clr [ %i5 + 0xe4 ]
}
args->bytes_moved = args->count - count;
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
40007224: 81 c7 e0 08 ret
40007228: 91 e8 00 10 restore %g0, %l0, %o0
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
4000722c: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
40007230: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40007234: 80 a0 80 01 cmp %g2, %g1
40007238: 22 80 00 21 be,a 400072bc <rtems_termios_read+0x100> <== ALWAYS TAKEN
4000723c: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
40007240: 80 a6 e0 00 cmp %i3, 0
40007244: 22 80 00 15 be,a 40007298 <rtems_termios_read+0xdc> <== NEVER TAKEN
40007248: b6 10 20 00 clr %i3 <== NOT EXECUTED
4000724c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
40007250: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40007254: 80 a0 40 02 cmp %g1, %g2
40007258: 36 80 00 11 bge,a 4000729c <rtems_termios_read+0xe0>
4000725c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40007260: 10 80 00 06 b 40007278 <rtems_termios_read+0xbc>
40007264: a4 24 80 01 sub %l2, %g1, %l2
40007268: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
4000726c: 80 a0 80 01 cmp %g2, %g1
40007270: 24 80 00 0b ble,a 4000729c <rtems_termios_read+0xe0>
40007274: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
*buffer++ = tty->cbuf[tty->cindex++];
40007278: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
4000727c: b6 86 ff ff addcc %i3, -1, %i3
*buffer++ = tty->cbuf[tty->cindex++];
40007280: c4 08 80 01 ldub [ %g2 + %g1 ], %g2
40007284: c4 2c 80 01 stb %g2, [ %l2 + %g1 ]
40007288: 82 00 60 01 inc %g1
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
4000728c: 12 bf ff f7 bne 40007268 <rtems_termios_read+0xac>
40007290: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
40007294: b6 10 20 00 clr %i3
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
40007298: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
4000729c: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
400072a0: b6 20 40 1b sub %g1, %i3, %i3
400072a4: f6 26 20 1c st %i3, [ %i0 + 0x1c ]
tty->tty_rcvwakeup = 0;
400072a8: c0 27 60 e4 clr [ %i5 + 0xe4 ]
rtems_semaphore_release (tty->isem);
400072ac: 40 00 05 07 call 400086c8 <rtems_semaphore_release>
400072b0: b0 10 00 10 mov %l0, %i0
return sc;
}
400072b4: 81 c7 e0 08 ret
400072b8: 81 e8 00 00 restore
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
400072bc: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
400072c0: c0 27 60 20 clr [ %i5 + 0x20 ]
400072c4: c0 27 60 24 clr [ %i5 + 0x24 ]
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
400072c8: 80 a0 60 00 cmp %g1, 0
400072cc: 02 80 00 06 be 400072e4 <rtems_termios_read+0x128>
400072d0: c4 27 60 2c st %g2, [ %i5 + 0x2c ]
400072d4: c4 07 60 b4 ld [ %i5 + 0xb4 ], %g2
400072d8: 80 a0 a0 00 cmp %g2, 0
400072dc: 22 80 00 6d be,a 40007490 <rtems_termios_read+0x2d4>
400072e0: c4 07 60 3c ld [ %i5 + 0x3c ], %g2
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
400072e4: f8 07 60 74 ld [ %i5 + 0x74 ], %i4
rtems_status_code sc;
int wait = 1;
400072e8: 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))) {
400072ec: 23 10 00 7d sethi %hi(0x4001f400), %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);
400072f0: a6 07 60 49 add %i5, 0x49, %l3
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
400072f4: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
400072f8: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
400072fc: 80 a0 80 01 cmp %g2, %g1
40007300: 02 80 00 42 be 40007408 <rtems_termios_read+0x24c>
40007304: c4 04 61 e8 ld [ %l1 + 0x1e8 ], %g2
40007308: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
(tty->ccount < (CBUFSIZE-1))) {
4000730c: 84 00 bf ff add %g2, -1, %g2
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
40007310: 80 a0 80 01 cmp %g2, %g1
40007314: 08 80 00 3d bleu 40007408 <rtems_termios_read+0x24c> <== NEVER TAKEN
40007318: b4 14 61 e8 or %l1, 0x1e8, %i2
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
4000731c: d0 07 60 5c ld [ %i5 + 0x5c ], %o0
40007320: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
40007324: 40 00 4a 80 call 40019d24 <.urem>
40007328: 90 02 20 01 inc %o0
c = tty->rawInBuf.theBuf[newHead];
4000732c: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
40007330: f8 08 40 08 ldub [ %g1 + %o0 ], %i4
tty->rawInBuf.Head = newHead;
40007334: d0 27 60 5c st %o0, [ %i5 + 0x5c ]
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
40007338: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
4000733c: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
% tty->rawInBuf.Size)
40007340: 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)
40007344: 82 00 80 01 add %g2, %g1, %g1
% tty->rawInBuf.Size)
40007348: 40 00 4a 77 call 40019d24 <.urem>
4000734c: 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)
40007350: c2 07 60 bc ld [ %i5 + 0xbc ], %g1
40007354: 80 a2 00 01 cmp %o0, %g1
40007358: 3a 80 00 18 bcc,a 400073b8 <rtems_termios_read+0x1fc> <== NEVER TAKEN
4000735c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
40007360: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40007364: 82 08 7f fe and %g1, -2, %g1
40007368: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
4000736c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40007370: 82 08 62 02 and %g1, 0x202, %g1
40007374: 80 a0 62 02 cmp %g1, 0x202
40007378: 22 80 00 38 be,a 40007458 <rtems_termios_read+0x29c> <== NEVER TAKEN
4000737c: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
40007380: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40007384: 80 88 61 00 btst 0x100, %g1
40007388: 22 80 00 0c be,a 400073b8 <rtems_termios_read+0x1fc> <== ALWAYS TAKEN
4000738c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl &= ~FL_IRTSOFF;
40007390: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
40007394: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
40007398: 84 08 bf fb and %g2, -5, %g2 <== NOT EXECUTED
4000739c: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
400073a0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400073a4: 22 80 00 05 be,a 400073b8 <rtems_termios_read+0x1fc> <== NOT EXECUTED
400073a8: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
400073ac: 9f c0 40 00 call %g1 <== NOT EXECUTED
400073b0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
400073b4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
if (siproc (c, tty))
400073b8: 90 0f 20 ff and %i4, 0xff, %o0
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
400073bc: 80 88 60 02 btst 2, %g1
400073c0: 02 80 00 1d be 40007434 <rtems_termios_read+0x278> <== NEVER TAKEN
400073c4: 92 10 00 1d mov %i5, %o1
if (siproc (c, tty))
400073c8: 7f ff ff 36 call 400070a0 <siproc>
400073cc: 01 00 00 00 nop
400073d0: 80 a2 20 00 cmp %o0, 0
400073d4: 32 80 00 02 bne,a 400073dc <rtems_termios_read+0x220>
400073d8: b2 10 20 00 clr %i1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
400073dc: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
400073e0: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
400073e4: 80 a0 80 01 cmp %g2, %g1
400073e8: 02 80 00 08 be 40007408 <rtems_termios_read+0x24c>
400073ec: f8 07 60 70 ld [ %i5 + 0x70 ], %i4
(tty->ccount < (CBUFSIZE-1))) {
400073f0: c2 06 80 00 ld [ %i2 ], %g1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
400073f4: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
(tty->ccount < (CBUFSIZE-1))) {
400073f8: 82 00 7f ff add %g1, -1, %g1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
400073fc: 80 a0 80 01 cmp %g2, %g1
40007400: 0a bf ff c7 bcs 4000731c <rtems_termios_read+0x160> <== ALWAYS TAKEN
40007404: 01 00 00 00 nop
}
/*
* Wait for characters
*/
if ( wait ) {
40007408: 80 a6 60 00 cmp %i1, 0
4000740c: 02 bf ff 8e be 40007244 <rtems_termios_read+0x88>
40007410: 80 a6 e0 00 cmp %i3, 0
sc = rtems_semaphore_obtain(
40007414: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
40007418: d2 07 60 6c ld [ %i5 + 0x6c ], %o1
4000741c: 40 00 04 5c call 4000858c <rtems_semaphore_obtain>
40007420: 94 10 00 1c mov %i4, %o2
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
40007424: 80 a2 20 00 cmp %o0, 0
40007428: 02 bf ff b3 be 400072f4 <rtems_termios_read+0x138> <== ALWAYS TAKEN
4000742c: 80 a6 e0 00 cmp %i3, 0
40007430: 30 bf ff 85 b,a 40007244 <rtems_termios_read+0x88> <== NOT EXECUTED
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
40007434: 7f ff ff 1b call 400070a0 <siproc> <== NOT EXECUTED
40007438: 01 00 00 00 nop <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
4000743c: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1 <== NOT EXECUTED
40007440: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
40007444: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40007448: 06 bf ff e5 bl 400073dc <rtems_termios_read+0x220> <== NOT EXECUTED
4000744c: 01 00 00 00 nop <== NOT EXECUTED
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
40007450: 10 bf ff e3 b 400073dc <rtems_termios_read+0x220> <== NOT EXECUTED
40007454: b2 10 20 00 clr %i1 ! 0 <PROM_START> <== NOT EXECUTED
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
40007458: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000745c: 22 80 00 07 be,a 40007478 <rtems_termios_read+0x2bc> <== NOT EXECUTED
40007460: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
40007464: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
40007468: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
4000746c: 02 bf ff c5 be 40007380 <rtems_termios_read+0x1c4> <== NOT EXECUTED
40007470: 01 00 00 00 nop <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
40007474: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
40007478: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
4000747c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
40007480: 9f c0 40 00 call %g1 <== NOT EXECUTED
40007484: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
40007488: 10 bf ff cc b 400073b8 <rtems_termios_read+0x1fc> <== NOT EXECUTED
4000748c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
40007490: 80 88 a0 02 btst 2, %g2
40007494: 02 80 00 0e be 400074cc <rtems_termios_read+0x310>
40007498: 01 00 00 00 nop
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
4000749c: 9f c0 40 00 call %g1
400074a0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
400074a4: 80 a2 20 00 cmp %o0, 0
400074a8: 06 80 00 3a bl 40007590 <rtems_termios_read+0x3d4>
400074ac: 90 0a 20 ff and %o0, 0xff, %o0
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
400074b0: 7f ff fe fc call 400070a0 <siproc>
400074b4: 92 10 00 1d mov %i5, %o1
400074b8: 80 a2 20 00 cmp %o0, 0
400074bc: 12 bf ff 62 bne 40007244 <rtems_termios_read+0x88>
400074c0: 80 a6 e0 00 cmp %i3, 0
400074c4: 10 bf ff f6 b 4000749c <rtems_termios_read+0x2e0>
400074c8: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
400074cc: 40 00 02 70 call 40007e8c <rtems_clock_get_ticks_since_boot>
400074d0: 01 00 00 00 nop
400074d4: b8 10 00 08 mov %o0, %i4
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
400074d8: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
400074dc: 9f c0 40 00 call %g1
400074e0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
400074e4: 80 a2 20 00 cmp %o0, 0
400074e8: 06 80 00 10 bl 40007528 <rtems_termios_read+0x36c>
400074ec: 90 0a 20 ff and %o0, 0xff, %o0
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
400074f0: 7f ff fe ec call 400070a0 <siproc>
400074f4: 92 10 00 1d mov %i5, %o1
if (tty->ccount >= tty->termios.c_cc[VMIN])
400074f8: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
400074fc: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
40007500: 80 a0 80 01 cmp %g2, %g1
40007504: 16 bf ff 4f bge 40007240 <rtems_termios_read+0x84>
40007508: 80 a0 60 00 cmp %g1, 0
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
4000750c: 22 bf ff f4 be,a 400074dc <rtems_termios_read+0x320> <== NEVER TAKEN
40007510: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
40007514: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
40007518: 80 a0 60 00 cmp %g1, 0
4000751c: 22 bf ff f0 be,a 400074dc <rtems_termios_read+0x320> <== NEVER TAKEN
40007520: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
40007524: 30 bf ff ea b,a 400074cc <rtems_termios_read+0x310>
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
40007528: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
4000752c: 80 a0 60 00 cmp %g1, 0
40007530: 02 80 00 0d be 40007564 <rtems_termios_read+0x3a8>
40007534: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
if (tty->termios.c_cc[VTIME] && tty->ccount) {
40007538: 80 a0 60 00 cmp %g1, 0
4000753c: 02 80 00 06 be 40007554 <rtems_termios_read+0x398> <== NEVER TAKEN
40007540: 01 00 00 00 nop
40007544: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40007548: 80 a0 60 00 cmp %g1, 0
4000754c: 12 80 00 09 bne 40007570 <rtems_termios_read+0x3b4>
40007550: 01 00 00 00 nop
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
40007554: 40 00 05 5f call 40008ad0 <rtems_task_wake_after>
40007558: 90 10 20 01 mov 1, %o0 ! 1 <PROM_START+0x1>
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
4000755c: 10 bf ff e0 b 400074dc <rtems_termios_read+0x320>
40007560: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
40007564: 80 a0 60 00 cmp %g1, 0
40007568: 02 bf ff 37 be 40007244 <rtems_termios_read+0x88> <== NEVER TAKEN
4000756c: 80 a6 e0 00 cmp %i3, 0
break;
now = rtems_clock_get_ticks_since_boot();
40007570: 40 00 02 47 call 40007e8c <rtems_clock_get_ticks_since_boot>
40007574: 01 00 00 00 nop
if ((now - then) > tty->vtimeTicks) {
40007578: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
4000757c: 90 22 00 1c sub %o0, %i4, %o0
40007580: 80 a2 00 01 cmp %o0, %g1
40007584: 08 bf ff f4 bleu 40007554 <rtems_termios_read+0x398>
40007588: 80 a6 e0 00 cmp %i3, 0
4000758c: 30 bf ff 2e b,a 40007244 <rtems_termios_read+0x88>
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
40007590: 40 00 05 50 call 40008ad0 <rtems_task_wake_after>
40007594: 90 10 20 01 mov 1, %o0
40007598: 10 bf ff c1 b 4000749c <rtems_termios_read+0x2e0>
4000759c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
40005b58 <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)
{
40005b58: 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))
40005b5c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
40005b60: 82 08 64 03 and %g1, 0x403, %g1
40005b64: 80 a0 64 01 cmp %g1, 0x401
40005b68: 02 80 00 44 be 40005c78 <rtems_termios_refill_transmitter+0x120><== NEVER TAKEN
40005b6c: ba 10 00 18 mov %i0, %i5
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
40005b70: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
40005b74: 82 08 60 03 and %g1, 3, %g1
40005b78: 80 a0 60 02 cmp %g1, 2
40005b7c: 22 80 00 50 be,a 40005cbc <rtems_termios_refill_transmitter+0x164><== NEVER TAKEN
40005b80: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
40005b84: c4 06 20 80 ld [ %i0 + 0x80 ], %g2
40005b88: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
40005b8c: 80 a0 80 01 cmp %g2, %g1
40005b90: 22 80 00 30 be,a 40005c50 <rtems_termios_refill_transmitter+0xf8>
40005b94: c2 06 20 94 ld [ %i0 + 0x94 ], %g1
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
}
rtems_interrupt_disable(level);
40005b98: 7f ff f2 4e call 400024d0 <sparc_disable_interrupts>
40005b9c: 01 00 00 00 nop
len = tty->t_dqlen;
40005ba0: f8 06 20 90 ld [ %i0 + 0x90 ], %i4
tty->t_dqlen = 0;
40005ba4: c0 26 20 90 clr [ %i0 + 0x90 ]
rtems_interrupt_enable(level);
40005ba8: 7f ff f2 4e call 400024e0 <sparc_enable_interrupts>
40005bac: 01 00 00 00 nop
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
40005bb0: d0 06 20 84 ld [ %i0 + 0x84 ], %o0
40005bb4: d2 06 20 88 ld [ %i0 + 0x88 ], %o1
40005bb8: 40 00 50 5b call 40019d24 <.urem>
40005bbc: 90 07 00 08 add %i4, %o0, %o0
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
40005bc0: 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;
40005bc4: d0 27 60 84 st %o0, [ %i5 + 0x84 ]
if (tty->rawOutBufState == rob_wait) {
40005bc8: 80 a0 60 02 cmp %g1, 2
40005bcc: 02 80 00 55 be 40005d20 <rtems_termios_refill_transmitter+0x1c8>
40005bd0: b8 10 00 08 mov %o0, %i4
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
40005bd4: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
40005bd8: 80 a0 40 1c cmp %g1, %i4
40005bdc: 22 80 00 48 be,a 40005cfc <rtems_termios_refill_transmitter+0x1a4>
40005be0: c2 07 60 d4 ld [ %i5 + 0xd4 ], %g1
if ( tty->tty_snd.sw_pfn != NULL) {
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
40005be4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005be8: 82 08 62 10 and %g1, 0x210, %g1
40005bec: 80 a0 62 10 cmp %g1, 0x210
40005bf0: 02 80 00 4f be 40005d2c <rtems_termios_refill_transmitter+0x1d4><== NEVER TAKEN
40005bf4: 01 00 00 00 nop
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
40005bf8: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
40005bfc: 80 a7 00 01 cmp %i4, %g1
40005c00: 18 80 00 1b bgu 40005c6c <rtems_termios_refill_transmitter+0x114>
40005c04: 01 00 00 00 nop
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
40005c08: f0 07 60 80 ld [ %i5 + 0x80 ], %i0
40005c0c: b0 26 00 1c sub %i0, %i4, %i0
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
40005c10: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
40005c14: 80 88 66 00 btst 0x600, %g1
40005c18: 02 80 00 04 be 40005c28 <rtems_termios_refill_transmitter+0xd0>
40005c1c: 94 10 00 18 mov %i0, %o2
40005c20: 94 10 20 01 mov 1, %o2
nToSend = 1;
40005c24: b0 10 20 01 mov 1, %i0
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
40005c28: d2 07 60 7c ld [ %i5 + 0x7c ], %o1
40005c2c: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
40005c30: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
40005c34: 84 10 20 01 mov 1, %g2
(*tty->device.write)(
40005c38: 92 02 40 1c add %o1, %i4, %o1
40005c3c: 9f c0 40 00 call %g1
40005c40: c4 27 60 94 st %g2, [ %i5 + 0x94 ]
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
40005c44: f8 27 60 84 st %i4, [ %i5 + 0x84 ]
}
return nToSend;
}
40005c48: 81 c7 e0 08 ret
40005c4c: 81 e8 00 00 restore
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
40005c50: 80 a0 60 02 cmp %g1, 2
40005c54: 12 bf ff fd bne 40005c48 <rtems_termios_refill_transmitter+0xf0><== ALWAYS TAKEN
40005c58: b0 10 20 00 clr %i0
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
40005c5c: 40 00 0a 9b call 400086c8 <rtems_semaphore_release> <== NOT EXECUTED
40005c60: d0 07 60 8c ld [ %i5 + 0x8c ], %o0 <== NOT EXECUTED
40005c64: 81 c7 e0 08 ret <== NOT EXECUTED
40005c68: 81 e8 00 00 restore <== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
40005c6c: f0 07 60 88 ld [ %i5 + 0x88 ], %i0
40005c70: 10 bf ff e8 b 40005c10 <rtems_termios_refill_transmitter+0xb8>
40005c74: b0 26 00 1c sub %i0, %i4, %i0
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
40005c78: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
40005c7c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
40005c80: 92 06 20 4a add %i0, 0x4a, %o1 <== NOT EXECUTED
40005c84: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005c88: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
40005c8c: 7f ff f2 11 call 400024d0 <sparc_disable_interrupts> <== NOT EXECUTED
40005c90: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
40005c94: c4 06 20 90 ld [ %i0 + 0x90 ], %g2 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
40005c98: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
40005c9c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
40005ca0: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
40005ca4: c4 27 60 90 st %g2, [ %i5 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
40005ca8: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
40005cac: 7f ff f2 0d call 400024e0 <sparc_enable_interrupts> <== NOT EXECUTED
40005cb0: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
40005cb4: 81 c7 e0 08 ret <== NOT EXECUTED
40005cb8: 81 e8 00 00 restore <== NOT EXECUTED
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
40005cbc: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
40005cc0: 92 06 20 49 add %i0, 0x49, %o1 <== NOT EXECUTED
40005cc4: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005cc8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
40005ccc: 7f ff f2 01 call 400024d0 <sparc_disable_interrupts> <== NOT EXECUTED
40005cd0: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
40005cd4: c4 06 20 90 ld [ %i0 + 0x90 ], %g2 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
40005cd8: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
40005cdc: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
40005ce0: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
40005ce4: c4 27 60 90 st %g2, [ %i5 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
40005ce8: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
40005cec: 7f ff f1 fd call 400024e0 <sparc_enable_interrupts> <== NOT EXECUTED
40005cf0: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
40005cf4: 81 c7 e0 08 ret <== NOT EXECUTED
40005cf8: 81 e8 00 00 restore <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
40005cfc: 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) {
40005d00: 80 a0 60 00 cmp %g1, 0
40005d04: 02 bf ff d0 be 40005c44 <rtems_termios_refill_transmitter+0xec><== ALWAYS TAKEN
40005d08: b0 10 20 00 clr %i0
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
40005d0c: d2 07 60 d8 ld [ %i5 + 0xd8 ], %o1 <== NOT EXECUTED
40005d10: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005d14: 90 07 60 30 add %i5, 0x30, %o0 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
40005d18: f8 27 60 84 st %i4, [ %i5 + 0x84 ] <== NOT EXECUTED
40005d1c: 30 bf ff f6 b,a 40005cf4 <rtems_termios_refill_transmitter+0x19c><== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
40005d20: 40 00 0a 6a call 400086c8 <rtems_semaphore_release>
40005d24: d0 06 20 8c ld [ %i0 + 0x8c ], %o0
40005d28: 30 bf ff ab b,a 40005bd4 <rtems_termios_refill_transmitter+0x7c>
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
40005d2c: 7f ff f1 e9 call 400024d0 <sparc_disable_interrupts> <== NOT EXECUTED
40005d30: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
40005d34: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
40005d38: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
tty->flow_ctrl |= FL_OSTOP;
40005d3c: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
40005d40: c4 27 60 94 st %g2, [ %i5 + 0x94 ] <== NOT EXECUTED
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
tty->flow_ctrl |= FL_OSTOP;
40005d44: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
rtems_interrupt_enable(level);
40005d48: 7f ff f1 e6 call 400024e0 <sparc_enable_interrupts> <== NOT EXECUTED
40005d4c: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
40005d50: f8 27 60 84 st %i4, [ %i5 + 0x84 ] <== NOT EXECUTED
40005d54: 30 bf ff e8 b,a 40005cf4 <rtems_termios_refill_transmitter+0x19c><== NOT EXECUTED
400078d8 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
400078d8: 9d e3 bf 98 save %sp, -104, %sp
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
400078dc: 10 80 00 08 b 400078fc <rtems_termios_rxdaemon+0x24>
400078e0: 96 07 bf fc add %fp, -4, %o3
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
400078e4: 9f c0 40 00 call %g1
400078e8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
if (c != EOF) {
400078ec: 80 a2 3f ff cmp %o0, -1
400078f0: 32 80 00 15 bne,a 40007944 <rtems_termios_rxdaemon+0x6c>
400078f4: d0 2f bf fb stb %o0, [ %fp + -5 ]
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
400078f8: 96 07 bf fc add %fp, -4, %o3
400078fc: 92 10 20 02 mov 2, %o1
40007900: 94 10 20 00 clr %o2
40007904: 40 00 01 85 call 40007f18 <rtems_event_receive>
40007908: 90 10 20 03 mov 3, %o0
(TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
4000790c: c2 07 bf fc ld [ %fp + -4 ], %g1
40007910: 80 88 60 01 btst 1, %g1
40007914: 22 bf ff f4 be,a 400078e4 <rtems_termios_rxdaemon+0xc> <== ALWAYS TAKEN
40007918: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1
tty->rxTaskId = 0;
4000791c: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
40007920: 40 00 03 f3 call 400088ec <rtems_task_delete> <== NOT EXECUTED
40007924: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
40007928: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED
4000792c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40007930: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
if (c != EOF) {
40007934: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
40007938: 22 bf ff f1 be,a 400078fc <rtems_termios_rxdaemon+0x24> <== NOT EXECUTED
4000793c: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
40007940: d0 2f bf fb stb %o0, [ %fp + -5 ] <== NOT EXECUTED
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
40007944: 92 07 bf fb add %fp, -5, %o1
40007948: 90 10 00 18 mov %i0, %o0
4000794c: 7f ff ff 1a call 400075b4 <rtems_termios_enqueue_raw_characters>
40007950: 94 10 20 01 mov 1, %o2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
40007954: 10 bf ff ea b 400078fc <rtems_termios_rxdaemon+0x24>
40007958: 96 07 bf fc add %fp, -4, %o3
40005d58 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
40005d58: 9d e3 bf 98 save %sp, -104, %sp
40005d5c: 3b 10 00 7f sethi %hi(0x4001fc00), %i5
40005d60: 10 80 00 0c b 40005d90 <rtems_termios_txdaemon+0x38>
40005d64: ba 17 61 34 or %i5, 0x134, %i5 ! 4001fd34 <rtems_termios_linesw>
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
40005d68: 83 28 60 05 sll %g1, 5, %g1
40005d6c: 82 07 40 01 add %i5, %g1, %g1
40005d70: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40005d74: 80 a0 60 00 cmp %g1, 0
40005d78: 02 80 00 04 be 40005d88 <rtems_termios_txdaemon+0x30> <== ALWAYS TAKEN
40005d7c: 90 10 00 18 mov %i0, %o0
rtems_termios_linesw[tty->t_line].l_start(tty);
40005d80: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005d84: 01 00 00 00 nop <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
40005d88: 7f ff ff 74 call 40005b58 <rtems_termios_refill_transmitter>
40005d8c: 90 10 00 18 mov %i0, %o0
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
40005d90: 92 10 20 02 mov 2, %o1
40005d94: 94 10 20 00 clr %o2
40005d98: 96 07 bf fc add %fp, -4, %o3
40005d9c: 40 00 08 5f call 40007f18 <rtems_event_receive>
40005da0: 90 10 20 03 mov 3, %o0
(TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
40005da4: c2 07 bf fc ld [ %fp + -4 ], %g1
40005da8: 80 88 60 01 btst 1, %g1
40005dac: 22 bf ff ef be,a 40005d68 <rtems_termios_txdaemon+0x10> <== ALWAYS TAKEN
40005db0: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
tty->txTaskId = 0;
40005db4: c0 26 20 c8 clr [ %i0 + 0xc8 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
40005db8: 40 00 0a cd call 400088ec <rtems_task_delete> <== NOT EXECUTED
40005dbc: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
40005dc0: 10 bf ff ea b 40005d68 <rtems_termios_txdaemon+0x10> <== NOT EXECUTED
40005dc4: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
400070e8 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
400070e8: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
400070ec: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400070f0: 92 10 20 00 clr %o1
rtems_status_code
rtems_termios_write (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
400070f4: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400070f8: 94 10 20 00 clr %o2
400070fc: 40 00 05 24 call 4000858c <rtems_semaphore_obtain>
40007100: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40007104: b4 92 20 00 orcc %o0, 0, %i2
40007108: 12 80 00 0f bne 40007144 <rtems_termios_write+0x5c> <== NEVER TAKEN
4000710c: 03 10 00 7f sethi %hi(0x4001fc00), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
40007110: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
40007114: 85 28 a0 05 sll %g2, 5, %g2
40007118: 82 10 61 34 or %g1, 0x134, %g1
4000711c: 82 00 40 02 add %g1, %g2, %g1
40007120: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40007124: 80 a0 60 00 cmp %g1, 0
40007128: 02 80 00 09 be 4000714c <rtems_termios_write+0x64>
4000712c: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
40007130: 9f c0 40 00 call %g1
40007134: 92 10 00 18 mov %i0, %o1
40007138: b4 10 00 08 mov %o0, %i2
rtems_semaphore_release (tty->osem);
4000713c: 40 00 05 63 call 400086c8 <rtems_semaphore_release>
40007140: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
return sc;
}
40007144: 81 c7 e0 08 ret
40007148: 91 e8 00 1a restore %g0, %i2, %o0
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
4000714c: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
40007150: 80 88 60 01 btst 1, %g1
40007154: 22 80 00 14 be,a 400071a4 <rtems_termios_write+0xbc> <== NEVER TAKEN
40007158: d0 1e 20 10 ldd [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
uint32_t count = args->count;
4000715c: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
char *buffer = args->buffer;
while (count--)
40007160: 80 a7 20 00 cmp %i4, 0
40007164: 02 80 00 14 be 400071b4 <rtems_termios_write+0xcc> <== NEVER TAKEN
40007168: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
oproc (*buffer++, tty);
4000716c: d0 0e c0 00 ldub [ %i3 ], %o0
40007170: 92 10 00 1d mov %i5, %o1
40007174: 7f ff fe 3e call 40006a6c <oproc>
40007178: 90 0a 20 ff and %o0, 0xff, %o0
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
4000717c: b8 87 3f ff addcc %i4, -1, %i4
40007180: 12 bf ff fb bne 4000716c <rtems_termios_write+0x84>
40007184: b6 06 e0 01 inc %i3
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
40007188: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
}
rtems_semaphore_release (tty->osem);
4000718c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
40007190: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
}
rtems_semaphore_release (tty->osem);
40007194: 40 00 05 4d call 400086c8 <rtems_semaphore_release>
40007198: b0 10 00 1a mov %i2, %i0
return sc;
}
4000719c: 81 c7 e0 08 ret
400071a0: 81 e8 00 00 restore
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
400071a4: 7f ff fd e2 call 4000692c <rtems_termios_puts> <== NOT EXECUTED
400071a8: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
args->bytes_moved = args->count;
400071ac: 10 bf ff f8 b 4000718c <rtems_termios_write+0xa4> <== NOT EXECUTED
400071b0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
400071b4: 10 bf ff f6 b 4000718c <rtems_termios_write+0xa4> <== NOT EXECUTED
400071b8: 82 10 20 00 clr %g1 <== NOT EXECUTED
4001827c <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
4001827c: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
40018280: 11 10 00 fc sethi %hi(0x4003f000), %o0
40018284: 92 10 00 18 mov %i0, %o1
40018288: 90 12 21 c8 or %o0, 0x1c8, %o0
4001828c: 40 00 0c fe call 4001b684 <_Objects_Get>
40018290: 94 07 bf fc add %fp, -4, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
40018294: c2 07 bf fc ld [ %fp + -4 ], %g1
40018298: 80 a0 60 00 cmp %g1, 0
4001829c: 12 80 00 0c bne 400182cc <rtems_timer_cancel+0x50>
400182a0: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
400182a4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
400182a8: 80 a0 60 04 cmp %g1, 4
400182ac: 02 80 00 04 be 400182bc <rtems_timer_cancel+0x40> <== NEVER TAKEN
400182b0: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_timer->Ticker );
400182b4: 40 00 14 ec call 4001d664 <_Watchdog_Remove>
400182b8: 90 02 20 10 add %o0, 0x10, %o0
_Thread_Enable_dispatch();
400182bc: 40 00 10 d5 call 4001c610 <_Thread_Enable_dispatch>
400182c0: b0 10 20 00 clr %i0
400182c4: 81 c7 e0 08 ret
400182c8: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400182cc: 81 c7 e0 08 ret
400182d0: 91 e8 20 04 restore %g0, 4, %o0
400187d4 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
400187d4: 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;
400187d8: 03 10 00 fc sethi %hi(0x4003f000), %g1
400187dc: fa 00 62 08 ld [ %g1 + 0x208 ], %i5 ! 4003f208 <_Timer_server>
if ( !timer_server )
400187e0: 80 a7 60 00 cmp %i5, 0
400187e4: 02 80 00 08 be 40018804 <rtems_timer_server_fire_when+0x30>
400187e8: 82 10 20 0e mov 0xe, %g1
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
400187ec: 39 10 00 f9 sethi %hi(0x4003e400), %i4
400187f0: 82 17 23 a8 or %i4, 0x3a8, %g1 ! 4003e7a8 <_TOD>
400187f4: c4 08 60 14 ldub [ %g1 + 0x14 ], %g2
400187f8: 80 a0 a0 00 cmp %g2, 0
400187fc: 12 80 00 04 bne 4001880c <rtems_timer_server_fire_when+0x38><== ALWAYS TAKEN
40018800: 82 10 20 0b mov 0xb, %g1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40018804: 81 c7 e0 08 ret
40018808: 91 e8 00 01 restore %g0, %g1, %o0
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
4001880c: 80 a6 a0 00 cmp %i2, 0
40018810: 02 bf ff fd be 40018804 <rtems_timer_server_fire_when+0x30>
40018814: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
40018818: 7f ff f3 1e call 40015490 <_TOD_Validate>
4001881c: 90 10 00 19 mov %i1, %o0
40018820: 80 8a 20 ff btst 0xff, %o0
40018824: 12 80 00 04 bne 40018834 <rtems_timer_server_fire_when+0x60>
40018828: 82 10 20 14 mov 0x14, %g1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4001882c: 81 c7 e0 08 ret
40018830: 91 e8 00 01 restore %g0, %g1, %o0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
40018834: 7f ff f2 dd call 400153a8 <_TOD_To_seconds>
40018838: 90 10 00 19 mov %i1, %o0
4001883c: b2 10 00 08 mov %o0, %i1
40018840: d0 1f 23 a8 ldd [ %i4 + 0x3a8 ], %o0
40018844: 94 10 20 00 clr %o2
40018848: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
4001884c: 40 00 52 36 call 4002d124 <__divdi3>
40018850: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
if ( seconds <= _TOD_Seconds_since_epoch() )
40018854: 80 a6 40 09 cmp %i1, %o1
40018858: 08 bf ff f5 bleu 4001882c <rtems_timer_server_fire_when+0x58>
4001885c: 82 10 20 14 mov 0x14, %g1
40018860: 92 10 00 18 mov %i0, %o1
40018864: 11 10 00 fc sethi %hi(0x4003f000), %o0
40018868: 94 07 bf fc add %fp, -4, %o2
4001886c: 40 00 0b 86 call 4001b684 <_Objects_Get>
40018870: 90 12 21 c8 or %o0, 0x1c8, %o0
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
40018874: c2 07 bf fc ld [ %fp + -4 ], %g1
40018878: 80 a0 60 00 cmp %g1, 0
4001887c: 12 80 00 19 bne 400188e0 <rtems_timer_server_fire_when+0x10c>
40018880: a0 10 00 08 mov %o0, %l0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
40018884: 40 00 13 78 call 4001d664 <_Watchdog_Remove>
40018888: 90 02 20 10 add %o0, 0x10, %o0
4001888c: d0 1f 23 a8 ldd [ %i4 + 0x3a8 ], %o0
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
40018890: 82 10 20 03 mov 3, %g1
40018894: 94 10 20 00 clr %o2
40018898: c2 24 20 38 st %g1, [ %l0 + 0x38 ]
4001889c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
400188a0: c0 24 20 18 clr [ %l0 + 0x18 ]
400188a4: 96 12 e2 00 or %o3, 0x200, %o3
the_watchdog->routine = routine;
400188a8: f4 24 20 2c st %i2, [ %l0 + 0x2c ]
the_watchdog->id = id;
400188ac: f0 24 20 30 st %i0, [ %l0 + 0x30 ]
400188b0: 40 00 52 1d call 4002d124 <__divdi3>
400188b4: f6 24 20 34 st %i3, [ %l0 + 0x34 ]
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
(*timer_server->schedule_operation)( timer_server, the_timer );
400188b8: c2 07 60 04 ld [ %i5 + 4 ], %g1
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
400188bc: b2 26 40 09 sub %i1, %o1, %i1
(*timer_server->schedule_operation)( timer_server, the_timer );
400188c0: 90 10 00 1d mov %i5, %o0
400188c4: 92 10 00 10 mov %l0, %o1
400188c8: 9f c0 40 00 call %g1
400188cc: f2 24 20 1c st %i1, [ %l0 + 0x1c ]
_Thread_Enable_dispatch();
400188d0: 40 00 0f 50 call 4001c610 <_Thread_Enable_dispatch>
400188d4: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
400188d8: 10 bf ff cb b 40018804 <rtems_timer_server_fire_when+0x30>
400188dc: 82 10 20 00 clr %g1 ! 0 <PROM_START>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
400188e0: 10 bf ff c9 b 40018804 <rtems_timer_server_fire_when+0x30>
400188e4: 82 10 20 04 mov 4, %g1
40003fb8 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
40003fb8: 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) {
40003fbc: 03 08 00 00 sethi %hi(0x20000000), %g1
40003fc0: 80 8e 00 01 btst %i0, %g1
40003fc4: 02 80 00 10 be 40004004 <rtems_verror+0x4c>
40003fc8: b8 10 00 18 mov %i0, %i4
if (rtems_panic_in_progress++)
40003fcc: 05 10 00 80 sethi %hi(0x40020000), %g2
40003fd0: c6 00 a1 20 ld [ %g2 + 0x120 ], %g3 ! 40020120 <rtems_panic_in_progress>
40003fd4: 82 00 e0 01 add %g3, 1, %g1
40003fd8: 80 a0 e0 00 cmp %g3, 0
40003fdc: 02 80 00 07 be 40003ff8 <rtems_verror+0x40> <== ALWAYS TAKEN
40003fe0: c2 20 a1 20 st %g1, [ %g2 + 0x120 ]
*
* 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;
40003fe4: 03 10 00 80 sethi %hi(0x40020000), %g1 <== NOT EXECUTED
40003fe8: c6 00 62 b0 ld [ %g1 + 0x2b0 ], %g3 ! 400202b0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
++level;
40003fec: 86 00 e0 01 inc %g3 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
40003ff0: c6 20 62 b0 st %g3, [ %g1 + 0x2b0 ] <== NOT EXECUTED
void _Thread_Disable_dispatch( void );
#else
RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void )
{
_Thread_Dispatch_increment_disable_level();
RTEMS_COMPILER_MEMORY_BARRIER();
40003ff4: c2 00 a1 20 ld [ %g2 + 0x120 ], %g1 <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
40003ff8: 80 a0 60 02 cmp %g1, 2
40003ffc: 14 80 00 30 bg 400040bc <rtems_verror+0x104> <== NEVER TAKEN
40004000: b0 10 20 00 clr %i0
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
40004004: 3b 10 00 7d sethi %hi(0x4001f400), %i5
40004008: c2 07 63 68 ld [ %i5 + 0x368 ], %g1 ! 4001f768 <_impure_ptr>
status = error_flag & ~RTEMS_ERROR_MASK;
4000400c: 37 1c 00 00 sethi %hi(0x70000000), %i3
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
40004010: d0 00 60 08 ld [ %g1 + 8 ], %o0
40004014: 40 00 33 4e call 40010d4c <fflush>
40004018: b6 2f 00 1b andn %i4, %i3, %i3
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
4000401c: 03 10 00 00 sethi %hi(0x40000000), %g1
40004020: 80 8f 00 01 btst %i4, %g1
40004024: 12 80 00 34 bne 400040f4 <rtems_verror+0x13c>
40004028: 01 00 00 00 nop
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
4000402c: b8 10 20 00 clr %i4 ! 0 <PROM_START>
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
40004030: c2 07 63 68 ld [ %i5 + 0x368 ], %g1
40004034: 92 10 00 19 mov %i1, %o1
40004038: d0 00 60 0c ld [ %g1 + 0xc ], %o0
4000403c: 40 00 47 ba call 40015f24 <vfprintf>
40004040: 94 10 00 1a mov %i2, %o2
if (status)
40004044: 80 a6 e0 00 cmp %i3, 0
40004048: 12 80 00 1f bne 400040c4 <rtems_verror+0x10c>
4000404c: b0 10 00 08 mov %o0, %i0
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
40004050: 80 a7 20 00 cmp %i4, 0
40004054: 02 80 00 12 be 4000409c <rtems_verror+0xe4>
40004058: c2 07 63 68 ld [ %i5 + 0x368 ], %g1
if ((local_errno > 0) && *strerror(local_errno))
4000405c: 80 a7 20 00 cmp %i4, 0
40004060: 04 80 00 09 ble 40004084 <rtems_verror+0xcc>
40004064: 13 10 00 76 sethi %hi(0x4001d800), %o1
40004068: 40 00 37 93 call 40011eb4 <strerror>
4000406c: 90 10 00 1c mov %i4, %o0
40004070: c2 4a 00 00 ldsb [ %o0 ], %g1
40004074: 80 a0 60 00 cmp %g1, 0
40004078: 12 80 00 23 bne 40004104 <rtems_verror+0x14c> <== ALWAYS TAKEN
4000407c: c2 07 63 68 ld [ %i5 + 0x368 ], %g1
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
40004080: 13 10 00 76 sethi %hi(0x4001d800), %o1 <== NOT EXECUTED
40004084: d0 00 60 0c ld [ %g1 + 0xc ], %o0
40004088: 92 12 62 48 or %o1, 0x248, %o1
4000408c: 40 00 34 2c call 4001113c <fprintf>
40004090: 94 10 00 1c mov %i4, %o2
40004094: b0 06 00 08 add %i0, %o0, %i0
}
chars_written += fprintf(stderr, "\n");
40004098: c2 07 63 68 ld [ %i5 + 0x368 ], %g1
4000409c: 13 10 00 76 sethi %hi(0x4001d800), %o1
400040a0: d0 00 60 0c ld [ %g1 + 0xc ], %o0
400040a4: 40 00 34 26 call 4001113c <fprintf>
400040a8: 92 12 62 60 or %o1, 0x260, %o1
(void) fflush(stderr);
400040ac: c2 07 63 68 ld [ %i5 + 0x368 ], %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");
400040b0: b0 02 00 18 add %o0, %i0, %i0
(void) fflush(stderr);
400040b4: 40 00 33 26 call 40010d4c <fflush>
400040b8: d0 00 60 0c ld [ %g1 + 0xc ], %o0
return chars_written;
}
400040bc: 81 c7 e0 08 ret
400040c0: 81 e8 00 00 restore
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
400040c4: 03 10 00 7d sethi %hi(0x4001f400), %g1
400040c8: c2 00 63 68 ld [ %g1 + 0x368 ], %g1 ! 4001f768 <_impure_ptr>
400040cc: 90 10 00 1b mov %i3, %o0
400040d0: 7f ff ff b4 call 40003fa0 <rtems_status_text>
400040d4: f6 00 60 0c ld [ %g1 + 0xc ], %i3
400040d8: 13 10 00 76 sethi %hi(0x4001d800), %o1
400040dc: 94 10 00 08 mov %o0, %o2
400040e0: 92 12 62 28 or %o1, 0x228, %o1
400040e4: 40 00 34 16 call 4001113c <fprintf>
400040e8: 90 10 00 1b mov %i3, %o0
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
400040ec: 10 bf ff d9 b 40004050 <rtems_verror+0x98>
400040f0: b0 06 00 08 add %i0, %o0, %i0
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
400040f4: 40 00 32 13 call 40010940 <__errno>
400040f8: 01 00 00 00 nop
400040fc: 10 bf ff cd b 40004030 <rtems_verror+0x78>
40004100: f8 02 00 00 ld [ %o0 ], %i4
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
if ((local_errno > 0) && *strerror(local_errno))
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
40004104: 90 10 00 1c mov %i4, %o0
40004108: 40 00 37 6b call 40011eb4 <strerror>
4000410c: f8 00 60 0c ld [ %g1 + 0xc ], %i4
40004110: 13 10 00 76 sethi %hi(0x4001d800), %o1
40004114: 94 10 00 08 mov %o0, %o2
40004118: 92 12 62 38 or %o1, 0x238, %o1
4000411c: 40 00 34 08 call 4001113c <fprintf>
40004120: 90 10 00 1c mov %i4, %o0
40004124: 10 bf ff dd b 40004098 <rtems_verror+0xe0>
40004128: b0 06 00 08 add %i0, %o0, %i0
40027efc <scanInt>:
/**
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
40027efc: 9d e3 bf a0 save %sp, -96, %sp
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
40027f00: 35 1f ff ff sethi %hi(0x7ffffc00), %i2
int sign = 0;
40027f04: b6 10 20 00 clr %i3
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
40027f08: b4 16 a3 ff or %i2, 0x3ff, %i2
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
40027f0c: ba 10 20 00 clr %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
40027f10: 23 10 01 97 sethi %hi(0x40065c00), %l1
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
40027f14: 21 10 01 97 sethi %hi(0x40065c00), %l0
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
40027f18: c2 06 20 04 ld [ %i0 + 4 ], %g1
40027f1c: 82 00 7f ff add %g1, -1, %g1
40027f20: 80 a0 60 00 cmp %g1, 0
40027f24: 06 80 00 26 bl 40027fbc <scanInt+0xc0> <== NEVER TAKEN
40027f28: c2 26 20 04 st %g1, [ %i0 + 4 ]
40027f2c: c4 06 00 00 ld [ %i0 ], %g2
40027f30: d0 08 80 00 ldub [ %g2 ], %o0
40027f34: 84 00 a0 01 inc %g2
if (c == ':')
40027f38: 80 a2 20 3a cmp %o0, 0x3a
40027f3c: 02 80 00 26 be 40027fd4 <scanInt+0xd8>
40027f40: c4 26 00 00 st %g2, [ %i0 ]
break;
if (sign == 0) {
40027f44: 80 a6 e0 00 cmp %i3, 0
40027f48: 32 80 00 06 bne,a 40027f60 <scanInt+0x64>
40027f4c: c4 04 21 b0 ld [ %l0 + 0x1b0 ], %g2
if (c == '-') {
40027f50: 80 a2 20 2d cmp %o0, 0x2d
40027f54: 02 80 00 32 be 4002801c <scanInt+0x120>
40027f58: b6 10 20 01 mov 1, %i3
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
40027f5c: c4 04 21 b0 ld [ %l0 + 0x1b0 ], %g2
40027f60: 84 00 80 08 add %g2, %o0, %g2
40027f64: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
40027f68: 80 88 a0 04 btst 4, %g2
40027f6c: 22 80 00 22 be,a 40027ff4 <scanInt+0xf8>
40027f70: b0 10 20 00 clr %i0
return 0;
d = c - '0';
40027f74: b8 02 3f d0 add %o0, -48, %i4
if ((i > (limit / 10))
40027f78: 92 10 20 0a mov 0xa, %o1
40027f7c: 40 00 b8 b0 call 4005623c <.udiv>
40027f80: 90 10 00 1a mov %i2, %o0
40027f84: 80 a7 40 08 cmp %i5, %o0
40027f88: 38 80 00 1b bgu,a 40027ff4 <scanInt+0xf8>
40027f8c: b0 10 20 00 clr %i0
|| ((i == (limit / 10)) && (d > (limit % 10))))
40027f90: 02 80 00 1b be 40027ffc <scanInt+0x100>
40027f94: 90 10 00 1a mov %i2, %o0
return 0;
i = i * 10 + d;
40027f98: 83 2f 60 01 sll %i5, 1, %g1
40027f9c: bb 2f 60 03 sll %i5, 3, %i5
40027fa0: ba 00 40 1d add %g1, %i5, %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
40027fa4: c2 06 20 04 ld [ %i0 + 4 ], %g1
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
40027fa8: ba 07 00 1d add %i4, %i5, %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
40027fac: 82 00 7f ff add %g1, -1, %g1
40027fb0: 80 a0 60 00 cmp %g1, 0
40027fb4: 16 bf ff de bge 40027f2c <scanInt+0x30> <== ALWAYS TAKEN
40027fb8: c2 26 20 04 st %g1, [ %i0 + 4 ]
40027fbc: d0 04 61 c0 ld [ %l1 + 0x1c0 ], %o0 <== NOT EXECUTED
40027fc0: 40 00 68 60 call 40042140 <__srget_r> <== NOT EXECUTED
40027fc4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (c == ':')
40027fc8: 80 a2 20 3a cmp %o0, 0x3a <== NOT EXECUTED
40027fcc: 12 bf ff df bne 40027f48 <scanInt+0x4c> <== NOT EXECUTED
40027fd0: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
40027fd4: 80 a6 e0 00 cmp %i3, 0
40027fd8: 02 80 00 07 be 40027ff4 <scanInt+0xf8> <== NEVER TAKEN
40027fdc: b0 10 20 00 clr %i0
return 0;
*val = i * sign;
40027fe0: 90 10 00 1b mov %i3, %o0
40027fe4: 92 10 00 1d mov %i5, %o1
40027fe8: 40 00 b8 5b call 40056154 <.umul>
40027fec: b0 10 20 01 mov 1, %i0
40027ff0: d0 26 40 00 st %o0, [ %i1 ]
return 1;
40027ff4: 81 c7 e0 08 ret
40027ff8: 81 e8 00 00 restore
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
40027ffc: 40 00 b9 3c call 400564ec <.urem>
40028000: 92 10 20 0a mov 0xa, %o1
40028004: 80 a7 00 08 cmp %i4, %o0
40028008: 08 bf ff e5 bleu 40027f9c <scanInt+0xa0> <== NEVER TAKEN
4002800c: 83 2f 60 01 sll %i5, 1, %g1
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
40028010: b0 10 20 00 clr %i0
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
40028014: 81 c7 e0 08 ret
40028018: 81 e8 00 00 restore
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
limit++;
4002801c: b4 06 a0 01 inc %i2
continue;
40028020: 10 bf ff be b 40027f18 <scanInt+0x1c>
40028024: b6 10 3f ff mov -1, %i3
40028028 <scanString>:
/**
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
40028028: 9d e3 bf a0 save %sp, -96, %sp
int c;
*name = *bufp;
4002802c: c2 06 80 00 ld [ %i2 ], %g1
for (;;) {
c = getc(fp);
40028030: 3b 10 01 97 sethi %hi(0x40065c00), %i5
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
int c;
*name = *bufp;
40028034: 10 80 00 19 b 40028098 <scanString+0x70>
40028038: c2 26 40 00 st %g1, [ %i1 ]
for (;;) {
c = getc(fp);
4002803c: c2 06 00 00 ld [ %i0 ], %g1
40028040: d0 08 40 00 ldub [ %g1 ], %o0
40028044: 82 00 60 01 inc %g1
if (c == ':') {
40028048: 80 a2 20 3a cmp %o0, 0x3a
4002804c: 02 80 00 1e be 400280c4 <scanString+0x9c>
40028050: c2 26 00 00 st %g1, [ %i0 ]
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
40028054: 80 a2 20 0a cmp %o0, 0xa
40028058: 02 80 00 2a be 40028100 <scanString+0xd8>
4002805c: 80 a2 3f ff cmp %o0, -1
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
40028060: 02 80 00 26 be 400280f8 <scanString+0xd0>
40028064: 01 00 00 00 nop
return 0;
if (*nleft < 2)
40028068: c2 06 c0 00 ld [ %i3 ], %g1
4002806c: 80 a0 60 01 cmp %g1, 1
40028070: 08 80 00 22 bleu 400280f8 <scanString+0xd0>
40028074: 01 00 00 00 nop
return 0;
**bufp = c;
40028078: c2 06 80 00 ld [ %i2 ], %g1
4002807c: d0 28 40 00 stb %o0, [ %g1 ]
++(*bufp);
40028080: c4 06 80 00 ld [ %i2 ], %g2
--(*nleft);
40028084: c2 06 c0 00 ld [ %i3 ], %g1
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
40028088: 84 00 a0 01 inc %g2
4002808c: c4 26 80 00 st %g2, [ %i2 ]
--(*nleft);
40028090: 82 00 7f ff add %g1, -1, %g1
40028094: c2 26 c0 00 st %g1, [ %i3 ]
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
40028098: c2 06 20 04 ld [ %i0 + 4 ], %g1
4002809c: 82 00 7f ff add %g1, -1, %g1
400280a0: 80 a0 60 00 cmp %g1, 0
400280a4: 16 bf ff e6 bge 4002803c <scanString+0x14>
400280a8: c2 26 20 04 st %g1, [ %i0 + 4 ]
400280ac: d0 07 61 c0 ld [ %i5 + 0x1c0 ], %o0
400280b0: 40 00 68 24 call 40042140 <__srget_r>
400280b4: 92 10 00 18 mov %i0, %o1
if (c == ':') {
400280b8: 80 a2 20 3a cmp %o0, 0x3a
400280bc: 12 bf ff e7 bne 40028058 <scanString+0x30> <== ALWAYS TAKEN
400280c0: 80 a2 20 0a cmp %o0, 0xa
if (nlFlag)
400280c4: 80 a7 20 00 cmp %i4, 0
400280c8: 12 80 00 11 bne 4002810c <scanString+0xe4>
400280cc: b0 10 20 00 clr %i0
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
400280d0: c2 06 80 00 ld [ %i2 ], %g1
400280d4: c0 28 40 00 clrb [ %g1 ]
++(*bufp);
400280d8: c4 06 80 00 ld [ %i2 ], %g2
--(*nleft);
400280dc: c2 06 c0 00 ld [ %i3 ], %g1
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
400280e0: 84 00 a0 01 inc %g2
400280e4: c4 26 80 00 st %g2, [ %i2 ]
--(*nleft);
400280e8: 82 00 7f ff add %g1, -1, %g1
400280ec: c2 26 c0 00 st %g1, [ %i3 ]
return 1;
400280f0: 81 c7 e0 08 ret
400280f4: 91 e8 20 01 restore %g0, 1, %o0
}
400280f8: 81 c7 e0 08 ret
400280fc: 91 e8 20 00 restore %g0, 0, %o0
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
40028100: 80 a7 20 00 cmp %i4, 0
40028104: 12 bf ff f3 bne 400280d0 <scanString+0xa8>
40028108: b0 10 20 00 clr %i0
4002810c: 81 c7 e0 08 ret
40028110: 81 e8 00 00 restore
40028114 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
40028114: 9d e3 bf 98 save %sp, -104, %sp
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
40028118: 98 10 20 00 clr %o4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
4002811c: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40028120: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
40028124: 90 10 00 18 mov %i0, %o0
40028128: 92 10 00 19 mov %i1, %o1
4002812c: 94 07 a0 4c add %fp, 0x4c, %o2
40028130: 7f ff ff be call 40028028 <scanString>
40028134: 96 07 a0 50 add %fp, 0x50, %o3
40028138: 80 a2 20 00 cmp %o0, 0
4002813c: 12 80 00 04 bne 4002814c <scangr+0x38>
40028140: 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;
40028144: 81 c7 e0 08 ret
40028148: 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)
4002814c: 92 06 60 04 add %i1, 4, %o1
40028150: 94 07 a0 4c add %fp, 0x4c, %o2
40028154: 96 07 a0 50 add %fp, 0x50, %o3
40028158: 7f ff ff b4 call 40028028 <scanString>
4002815c: 98 10 20 00 clr %o4
40028160: 80 a2 20 00 cmp %o0, 0
40028164: 02 bf ff f8 be 40028144 <scangr+0x30> <== NEVER TAKEN
40028168: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &grgid)
4002816c: 7f ff ff 64 call 40027efc <scanInt>
40028170: 92 07 bf f8 add %fp, -8, %o1
40028174: 80 a2 20 00 cmp %o0, 0
40028178: 02 bf ff f3 be 40028144 <scangr+0x30> <== NEVER TAKEN
4002817c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
40028180: 92 07 bf fc add %fp, -4, %o1
40028184: 94 07 a0 4c add %fp, 0x4c, %o2
40028188: 96 07 a0 50 add %fp, 0x50, %o3
4002818c: 7f ff ff a7 call 40028028 <scanString>
40028190: 98 10 20 01 mov 1, %o4
40028194: 80 a2 20 00 cmp %o0, 0
40028198: 02 bf ff eb be 40028144 <scangr+0x30> <== NEVER TAKEN
4002819c: c2 07 bf f8 ld [ %fp + -8 ], %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
400281a0: fa 07 bf fc ld [ %fp + -4 ], %i5
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
grp->gr_gid = grgid;
400281a4: c2 36 60 08 sth %g1, [ %i1 + 8 ]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
400281a8: c6 0f 40 00 ldub [ %i5 ], %g3
400281ac: 83 28 e0 18 sll %g3, 0x18, %g1
400281b0: 80 a0 60 00 cmp %g1, 0
400281b4: 02 80 00 10 be 400281f4 <scangr+0xe0> <== NEVER TAKEN
400281b8: 88 10 20 17 mov 0x17, %g4
400281bc: 84 10 00 1d mov %i5, %g2
400281c0: 88 10 20 01 mov 1, %g4
400281c4: 84 00 a0 01 inc %g2
400281c8: c6 08 80 00 ldub [ %g2 ], %g3
if(*cp == ',')
400281cc: 83 38 60 18 sra %g1, 0x18, %g1
memcount++;
400281d0: 82 18 60 2c xor %g1, 0x2c, %g1
400281d4: 80 a0 00 01 cmp %g0, %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
400281d8: 83 28 e0 18 sll %g3, 0x18, %g1
if(*cp == ',')
memcount++;
400281dc: 88 61 3f ff subx %g4, -1, %g4
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
400281e0: 80 a0 60 00 cmp %g1, 0
400281e4: 32 bf ff f9 bne,a 400281c8 <scangr+0xb4>
400281e8: 84 00 a0 01 inc %g2
400281ec: 89 29 20 02 sll %g4, 2, %g4
400281f0: 88 01 20 13 add %g4, 0x13, %g4
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
400281f4: c2 07 a0 50 ld [ %fp + 0x50 ], %g1
400281f8: 80 a0 40 04 cmp %g1, %g4
400281fc: 0a bf ff d2 bcs 40028144 <scangr+0x30> <== NEVER TAKEN
40028200: c2 07 a0 4c ld [ %fp + 0x4c ], %g1
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
40028204: 82 00 60 0f add %g1, 0xf, %g1
40028208: 82 08 7f f0 and %g1, -16, %g1
4002820c: c2 26 60 0c st %g1, [ %i1 + 0xc ]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
40028210: fa 20 40 00 st %i5, [ %g1 ]
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40028214: c2 07 bf fc ld [ %fp + -4 ], %g1
40028218: c4 08 40 00 ldub [ %g1 ], %g2
4002821c: 85 28 a0 18 sll %g2, 0x18, %g2
40028220: 80 a0 a0 00 cmp %g2, 0
40028224: 02 80 00 18 be 40028284 <scangr+0x170> <== NEVER TAKEN
40028228: 82 00 60 01 inc %g1
4002822c: 10 80 00 07 b 40028248 <scangr+0x134>
40028230: 86 10 20 01 mov 1, %g3
40028234: c4 08 40 00 ldub [ %g1 ], %g2
40028238: 85 28 a0 18 sll %g2, 0x18, %g2
4002823c: 80 a0 a0 00 cmp %g2, 0
40028240: 02 80 00 0c be 40028270 <scangr+0x15c>
40028244: 82 00 60 01 inc %g1
if(*cp == ',') {
40028248: 85 38 a0 18 sra %g2, 0x18, %g2
4002824c: 80 a0 a0 2c cmp %g2, 0x2c
40028250: 32 bf ff fa bne,a 40028238 <scangr+0x124>
40028254: c4 08 40 00 ldub [ %g1 ], %g2
*cp = '\0';
40028258: c0 28 7f ff clrb [ %g1 + -1 ]
grp->gr_mem[memcount++] = cp + 1;
4002825c: c8 06 60 0c ld [ %i1 + 0xc ], %g4
40028260: 85 28 e0 02 sll %g3, 2, %g2
40028264: 86 00 e0 01 inc %g3
40028268: 10 bf ff f3 b 40028234 <scangr+0x120>
4002826c: c2 21 00 02 st %g1, [ %g4 + %g2 ]
40028270: 87 28 e0 02 sll %g3, 2, %g3
}
}
grp->gr_mem[memcount] = NULL;
40028274: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40028278: c0 20 40 03 clr [ %g1 + %g3 ]
return 1;
}
4002827c: 81 c7 e0 08 ret
40028280: 91 e8 20 01 restore %g0, 1, %o0
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40028284: 10 bf ff fc b 40028274 <scangr+0x160> <== NOT EXECUTED
40028288: 86 10 20 04 mov 4, %g3 <== NOT EXECUTED
4002828c <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
4002828c: 9d e3 bf 98 save %sp, -104, %sp
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
40028290: 98 10 20 00 clr %o4
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
40028294: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40028298: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
4002829c: 90 10 00 18 mov %i0, %o0
400282a0: 92 10 00 19 mov %i1, %o1
400282a4: 94 07 a0 4c add %fp, 0x4c, %o2
400282a8: 7f ff ff 60 call 40028028 <scanString>
400282ac: 96 07 a0 50 add %fp, 0x50, %o3
400282b0: 80 a2 20 00 cmp %o0, 0
400282b4: 12 80 00 04 bne 400282c4 <scanpw+0x38>
400282b8: 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;
400282bc: 81 c7 e0 08 ret
400282c0: 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)
400282c4: 92 06 60 04 add %i1, 4, %o1
400282c8: 94 07 a0 4c add %fp, 0x4c, %o2
400282cc: 96 07 a0 50 add %fp, 0x50, %o3
400282d0: 7f ff ff 56 call 40028028 <scanString>
400282d4: 98 10 20 00 clr %o4
400282d8: 80 a2 20 00 cmp %o0, 0
400282dc: 02 bf ff f8 be 400282bc <scanpw+0x30> <== NEVER TAKEN
400282e0: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwuid)
400282e4: 7f ff ff 06 call 40027efc <scanInt>
400282e8: 92 07 bf f8 add %fp, -8, %o1
400282ec: 80 a2 20 00 cmp %o0, 0
400282f0: 02 bf ff f3 be 400282bc <scanpw+0x30>
400282f4: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwgid)
400282f8: 7f ff ff 01 call 40027efc <scanInt>
400282fc: 92 07 bf fc add %fp, -4, %o1
40028300: 80 a2 20 00 cmp %o0, 0
40028304: 02 bf ff ee be 400282bc <scanpw+0x30>
40028308: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
4002830c: 92 06 60 0c add %i1, 0xc, %o1
40028310: 94 07 a0 4c add %fp, 0x4c, %o2
40028314: 96 07 a0 50 add %fp, 0x50, %o3
40028318: 7f ff ff 44 call 40028028 <scanString>
4002831c: 98 10 20 00 clr %o4
40028320: 80 a2 20 00 cmp %o0, 0
40028324: 02 bf ff e6 be 400282bc <scanpw+0x30> <== NEVER TAKEN
40028328: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
4002832c: 92 06 60 10 add %i1, 0x10, %o1
40028330: 94 07 a0 4c add %fp, 0x4c, %o2
40028334: 96 07 a0 50 add %fp, 0x50, %o3
40028338: 7f ff ff 3c call 40028028 <scanString>
4002833c: 98 10 20 00 clr %o4
40028340: 80 a2 20 00 cmp %o0, 0
40028344: 02 bf ff de be 400282bc <scanpw+0x30> <== NEVER TAKEN
40028348: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
4002834c: 92 06 60 14 add %i1, 0x14, %o1
40028350: 94 07 a0 4c add %fp, 0x4c, %o2
40028354: 96 07 a0 50 add %fp, 0x50, %o3
40028358: 7f ff ff 34 call 40028028 <scanString>
4002835c: 98 10 20 00 clr %o4
40028360: 80 a2 20 00 cmp %o0, 0
40028364: 02 bf ff d6 be 400282bc <scanpw+0x30> <== NEVER TAKEN
40028368: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
4002836c: 92 06 60 18 add %i1, 0x18, %o1
40028370: 94 07 a0 4c add %fp, 0x4c, %o2
40028374: 96 07 a0 50 add %fp, 0x50, %o3
40028378: 7f ff ff 2c call 40028028 <scanString>
4002837c: 98 10 20 01 mov 1, %o4
40028380: 80 a2 20 00 cmp %o0, 0
40028384: 02 bf ff ce be 400282bc <scanpw+0x30>
40028388: c2 07 bf f8 ld [ %fp + -8 ], %g1
return 0;
pwd->pw_uid = pwuid;
4002838c: c2 36 60 08 sth %g1, [ %i1 + 8 ]
pwd->pw_gid = pwgid;
40028390: c2 07 bf fc ld [ %fp + -4 ], %g1
40028394: c2 36 60 0a sth %g1, [ %i1 + 0xa ]
return 1;
}
40028398: 81 c7 e0 08 ret
4002839c: 91 e8 20 01 restore %g0, 1, %o0
400089dc <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
400089dc: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
400089e0: 80 a6 20 04 cmp %i0, 4
400089e4: 08 80 00 08 bleu 40008a04 <sched_get_priority_max+0x28>
400089e8: 82 10 20 01 mov 1, %g1
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
400089ec: 40 00 22 40 call 400112ec <__errno>
400089f0: b0 10 3f ff mov -1, %i0
400089f4: 82 10 20 16 mov 0x16, %g1
400089f8: c2 22 00 00 st %g1, [ %o0 ]
400089fc: 81 c7 e0 08 ret
40008a00: 81 e8 00 00 restore
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
40008a04: b1 28 40 18 sll %g1, %i0, %i0
40008a08: 80 8e 20 17 btst 0x17, %i0
40008a0c: 02 bf ff f8 be 400089ec <sched_get_priority_max+0x10> <== NEVER TAKEN
40008a10: 03 10 00 7f sethi %hi(0x4001fc00), %g1
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
40008a14: f0 08 63 fc ldub [ %g1 + 0x3fc ], %i0 ! 4001fffc <rtems_maximum_priority>
}
40008a18: 81 c7 e0 08 ret
40008a1c: 91 ee 3f ff restore %i0, -1, %o0
40008a20 <sched_get_priority_min>:
* 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258
*/
int sched_get_priority_min(
int policy
)
{
40008a20: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
40008a24: 80 a6 20 04 cmp %i0, 4
40008a28: 08 80 00 08 bleu 40008a48 <sched_get_priority_min+0x28>
40008a2c: 82 10 00 18 mov %i0, %g1
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
40008a30: 40 00 22 2f call 400112ec <__errno>
40008a34: b0 10 3f ff mov -1, %i0
40008a38: 82 10 20 16 mov 0x16, %g1
40008a3c: c2 22 00 00 st %g1, [ %o0 ]
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
40008a40: 81 c7 e0 08 ret
40008a44: 81 e8 00 00 restore
*/
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
40008a48: 84 10 20 01 mov 1, %g2
40008a4c: 83 28 80 01 sll %g2, %g1, %g1
40008a50: 80 88 60 17 btst 0x17, %g1
40008a54: 02 bf ff f7 be 40008a30 <sched_get_priority_min+0x10> <== NEVER TAKEN
40008a58: b0 10 20 01 mov 1, %i0
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
40008a5c: 81 c7 e0 08 ret
40008a60: 81 e8 00 00 restore
40008a64 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
40008a64: 9d e3 bf a0 save %sp, -96, %sp
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
40008a68: 80 a6 20 00 cmp %i0, 0
40008a6c: 12 80 00 0a bne 40008a94 <sched_rr_get_interval+0x30> <== ALWAYS TAKEN
40008a70: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
40008a74: 02 80 00 13 be 40008ac0 <sched_rr_get_interval+0x5c>
40008a78: 03 10 00 83 sethi %hi(0x40020c00), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
40008a7c: d0 00 61 00 ld [ %g1 + 0x100 ], %o0 ! 40020d00 <_Thread_Ticks_per_timeslice>
40008a80: 92 10 00 19 mov %i1, %o1
40008a84: 40 00 0f 59 call 4000c7e8 <_Timespec_From_ticks>
40008a88: b0 10 20 00 clr %i0
return 0;
}
40008a8c: 81 c7 e0 08 ret
40008a90: 81 e8 00 00 restore
{
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
40008a94: 7f ff ee e5 call 40004628 <getpid>
40008a98: 01 00 00 00 nop
40008a9c: 80 a2 00 18 cmp %o0, %i0
40008aa0: 02 bf ff f5 be 40008a74 <sched_rr_get_interval+0x10>
40008aa4: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
40008aa8: 40 00 22 11 call 400112ec <__errno>
40008aac: b0 10 3f ff mov -1, %i0
40008ab0: 82 10 20 03 mov 3, %g1
40008ab4: c2 22 00 00 st %g1, [ %o0 ]
40008ab8: 81 c7 e0 08 ret
40008abc: 81 e8 00 00 restore
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
40008ac0: 40 00 22 0b call 400112ec <__errno>
40008ac4: b0 10 3f ff mov -1, %i0
40008ac8: 82 10 20 16 mov 0x16, %g1
40008acc: c2 22 00 00 st %g1, [ %o0 ]
40008ad0: 81 c7 e0 08 ret
40008ad4: 81 e8 00 00 restore
4000932c <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
4000932c: 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;
40009330: 03 10 00 93 sethi %hi(0x40024c00), %g1
40009334: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 40024cb0 <_Thread_Dispatch_disable_level>
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
40009338: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
++level;
4000933c: 84 00 a0 01 inc %g2
40009340: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40009344: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40009348: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
_Thread_Dispatch_disable_level = level;
4000934c: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ]
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
40009350: b4 8e 62 00 andcc %i1, 0x200, %i2
40009354: 12 80 00 27 bne 400093f0 <sem_open+0xc4>
40009358: b6 10 20 00 clr %i3
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len );
4000935c: 39 10 00 93 sethi %hi(0x40024c00), %i4
40009360: 92 10 00 18 mov %i0, %o1
40009364: 90 17 23 74 or %i4, 0x374, %o0
40009368: 94 07 bf f0 add %fp, -16, %o2
4000936c: 7f ff fe 5c call 40008cdc <_POSIX_Name_to_id>
40009370: 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 ) {
40009374: ba 92 20 00 orcc %o0, 0, %i5
40009378: 22 80 00 0e be,a 400093b0 <sem_open+0x84>
4000937c: 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) ) ) {
40009380: 80 a7 60 02 cmp %i5, 2
40009384: 12 80 00 04 bne 40009394 <sem_open+0x68>
40009388: 80 a6 a0 00 cmp %i2, 0
4000938c: 12 80 00 1d bne 40009400 <sem_open+0xd4>
40009390: d2 07 bf fc ld [ %fp + -4 ], %o1
_Thread_Enable_dispatch();
40009394: 40 00 0e 73 call 4000cd60 <_Thread_Enable_dispatch>
40009398: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
4000939c: 40 00 25 30 call 4001285c <__errno>
400093a0: 01 00 00 00 nop
400093a4: fa 22 00 00 st %i5, [ %o0 ]
400093a8: 81 c7 e0 08 ret
400093ac: 81 e8 00 00 restore
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
400093b0: 80 a6 6a 00 cmp %i1, 0xa00
400093b4: 02 80 00 1f be 40009430 <sem_open+0x104>
400093b8: d2 07 bf f0 ld [ %fp + -16 ], %o1
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
400093bc: 94 07 bf f8 add %fp, -8, %o2
400093c0: 40 00 0a 7a call 4000bda8 <_Objects_Get>
400093c4: 90 17 23 74 or %i4, 0x374, %o0
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
the_semaphore->open_count += 1;
400093c8: 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 );
400093cc: d0 27 bf f4 st %o0, [ %fp + -12 ]
the_semaphore->open_count += 1;
400093d0: 82 00 60 01 inc %g1
_Thread_Enable_dispatch();
400093d4: 40 00 0e 63 call 4000cd60 <_Thread_Enable_dispatch>
400093d8: c2 22 20 18 st %g1, [ %o0 + 0x18 ]
_Thread_Enable_dispatch();
400093dc: 40 00 0e 61 call 4000cd60 <_Thread_Enable_dispatch>
400093e0: 01 00 00 00 nop
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
return &the_semaphore->Semaphore_id;
#else
return (sem_t *)&the_semaphore->Object.id;
400093e4: f0 07 bf f4 ld [ %fp + -12 ], %i0
400093e8: 81 c7 e0 08 ret
400093ec: 91 ee 20 08 restore %i0, 8, %o0
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
400093f0: 82 07 a0 4c add %fp, 0x4c, %g1
mode = va_arg( arg, mode_t );
value = va_arg( arg, unsigned int );
400093f4: f6 07 a0 50 ld [ %fp + 0x50 ], %i3
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
400093f8: 10 bf ff d9 b 4000935c <sem_open+0x30>
400093fc: c2 27 bf ec st %g1, [ %fp + -20 ]
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
40009400: 94 10 20 00 clr %o2
40009404: 96 10 00 1b mov %i3, %o3
40009408: 98 07 bf f4 add %fp, -12, %o4
4000940c: 40 00 1a e9 call 4000ffb0 <_POSIX_Semaphore_Create_support>
40009410: 90 10 00 18 mov %i0, %o0
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
40009414: 40 00 0e 53 call 4000cd60 <_Thread_Enable_dispatch>
40009418: ba 10 00 08 mov %o0, %i5
if ( status == -1 )
4000941c: 80 a7 7f ff cmp %i5, -1
40009420: 32 bf ff f2 bne,a 400093e8 <sem_open+0xbc> <== ALWAYS TAKEN
40009424: f0 07 bf f4 ld [ %fp + -12 ], %i0
the_semaphore->Semaphore_id = the_semaphore->Object.id;
return &the_semaphore->Semaphore_id;
#else
return (sem_t *)&the_semaphore->Object.id;
#endif
}
40009428: 81 c7 e0 08 ret <== NOT EXECUTED
4000942c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
40009430: 40 00 0e 4c call 4000cd60 <_Thread_Enable_dispatch>
40009434: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
40009438: 40 00 25 09 call 4001285c <__errno>
4000943c: 01 00 00 00 nop
40009440: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
40009444: c2 22 00 00 st %g1, [ %o0 ]
40009448: 81 c7 e0 08 ret
4000944c: 81 e8 00 00 restore
4000b484 <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
4000b484: 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 );
4000b488: 90 10 00 19 mov %i1, %o0
4000b48c: 40 00 16 9f call 40010f08 <_POSIX_Absolute_timeout_to_ticks>
4000b490: 92 07 bf fc add %fp, -4, %o1
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
4000b494: 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 )
4000b498: 80 a2 20 03 cmp %o0, 3
4000b49c: 02 80 00 06 be 4000b4b4 <sem_timedwait+0x30> <== ALWAYS TAKEN
4000b4a0: 90 10 00 18 mov %i0, %o0
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
4000b4a4: 40 00 19 99 call 40011b08 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
4000b4a8: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000b4ac: 81 c7 e0 08 ret <== NOT EXECUTED
4000b4b0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4000b4b4: 40 00 19 95 call 40011b08 <_POSIX_Semaphore_Wait_support>
4000b4b8: 92 10 20 01 mov 1, %o1
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
4000b4bc: 81 c7 e0 08 ret
4000b4c0: 91 e8 00 08 restore %g0, %o0, %o0
40008990 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
40008990: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
if ( oact )
40008994: 80 a6 a0 00 cmp %i2, 0
40008998: 02 80 00 0d be 400089cc <sigaction+0x3c>
4000899c: 87 2e 20 02 sll %i0, 2, %g3
*oact = _POSIX_signals_Vectors[ sig ];
400089a0: 05 10 00 6f sethi %hi(0x4001bc00), %g2
400089a4: 83 2e 20 04 sll %i0, 4, %g1
400089a8: 84 10 a1 60 or %g2, 0x160, %g2
400089ac: 82 20 40 03 sub %g1, %g3, %g1
400089b0: c6 00 80 01 ld [ %g2 + %g1 ], %g3
400089b4: 82 00 80 01 add %g2, %g1, %g1
400089b8: c6 26 80 00 st %g3, [ %i2 ]
400089bc: c4 00 60 04 ld [ %g1 + 4 ], %g2
400089c0: c4 26 a0 04 st %g2, [ %i2 + 4 ]
400089c4: c2 00 60 08 ld [ %g1 + 8 ], %g1
400089c8: c2 26 a0 08 st %g1, [ %i2 + 8 ]
if ( !sig )
400089cc: 80 a6 20 00 cmp %i0, 0
400089d0: 02 80 00 33 be 40008a9c <sigaction+0x10c>
400089d4: 01 00 00 00 nop
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
400089d8: 82 06 3f ff add %i0, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
400089dc: 80 a0 60 1f cmp %g1, 0x1f
400089e0: 18 80 00 2f bgu 40008a9c <sigaction+0x10c>
400089e4: 80 a6 20 09 cmp %i0, 9
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
400089e8: 02 80 00 2d be 40008a9c <sigaction+0x10c>
400089ec: 80 a6 60 00 cmp %i1, 0
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
400089f0: 02 80 00 1a be 40008a58 <sigaction+0xc8> <== NEVER TAKEN
400089f4: 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 );
400089f8: 7f ff e7 a2 call 40002880 <sparc_disable_interrupts>
400089fc: 01 00 00 00 nop
40008a00: ba 10 00 08 mov %o0, %i5
if ( act->sa_handler == SIG_DFL ) {
40008a04: c2 06 60 08 ld [ %i1 + 8 ], %g1
40008a08: 80 a0 60 00 cmp %g1, 0
40008a0c: 02 80 00 15 be 40008a60 <sigaction+0xd0>
40008a10: 83 2e 20 02 sll %i0, 2, %g1
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
40008a14: 40 00 17 f0 call 4000e9d4 <_POSIX_signals_Clear_process_signals>
40008a18: 90 10 00 18 mov %i0, %o0
_POSIX_signals_Vectors[ sig ] = *act;
40008a1c: c4 06 40 00 ld [ %i1 ], %g2
40008a20: 87 2e 20 02 sll %i0, 2, %g3
40008a24: 03 10 00 6f sethi %hi(0x4001bc00), %g1
40008a28: b1 2e 20 04 sll %i0, 4, %i0
40008a2c: 82 10 61 60 or %g1, 0x160, %g1
40008a30: b0 26 00 03 sub %i0, %g3, %i0
40008a34: c4 20 40 18 st %g2, [ %g1 + %i0 ]
40008a38: c4 06 60 04 ld [ %i1 + 4 ], %g2
40008a3c: b0 00 40 18 add %g1, %i0, %i0
40008a40: c4 26 20 04 st %g2, [ %i0 + 4 ]
40008a44: c2 06 60 08 ld [ %i1 + 8 ], %g1
40008a48: c2 26 20 08 st %g1, [ %i0 + 8 ]
}
_ISR_Enable( level );
40008a4c: 7f ff e7 91 call 40002890 <sparc_enable_interrupts>
40008a50: 90 10 00 1d mov %i5, %o0
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
40008a54: 82 10 20 00 clr %g1
}
40008a58: 81 c7 e0 08 ret
40008a5c: 91 e8 00 01 restore %g0, %g1, %o0
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
40008a60: b1 2e 20 04 sll %i0, 4, %i0
40008a64: b0 26 00 01 sub %i0, %g1, %i0
40008a68: 03 10 00 68 sethi %hi(0x4001a000), %g1
40008a6c: 82 10 62 5c or %g1, 0x25c, %g1 ! 4001a25c <_POSIX_signals_Default_vectors>
40008a70: c8 00 40 18 ld [ %g1 + %i0 ], %g4
40008a74: 82 00 40 18 add %g1, %i0, %g1
40008a78: c6 00 60 04 ld [ %g1 + 4 ], %g3
40008a7c: c4 00 60 08 ld [ %g1 + 8 ], %g2
40008a80: 03 10 00 6f sethi %hi(0x4001bc00), %g1
40008a84: 82 10 61 60 or %g1, 0x160, %g1 ! 4001bd60 <_POSIX_signals_Vectors>
40008a88: c8 20 40 18 st %g4, [ %g1 + %i0 ]
40008a8c: b0 00 40 18 add %g1, %i0, %i0
40008a90: c6 26 20 04 st %g3, [ %i0 + 4 ]
40008a94: 10 bf ff ee b 40008a4c <sigaction+0xbc>
40008a98: c4 26 20 08 st %g2, [ %i0 + 8 ]
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
rtems_set_errno_and_return_minus_one( EINVAL );
40008a9c: 40 00 23 2a call 40011744 <__errno>
40008aa0: 01 00 00 00 nop
40008aa4: 84 10 20 16 mov 0x16, %g2 ! 16 <PROM_START+0x16>
40008aa8: 82 10 3f ff mov -1, %g1
40008aac: 10 bf ff eb b 40008a58 <sigaction+0xc8>
40008ab0: c4 22 00 00 st %g2, [ %o0 ]
40008f20 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
40008f20: 9d e3 bf 90 save %sp, -112, %sp
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
40008f24: ba 96 20 00 orcc %i0, 0, %i5
40008f28: 02 80 00 83 be 40009134 <sigtimedwait+0x214>
40008f2c: 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 ) {
40008f30: 02 80 00 5b be 4000909c <sigtimedwait+0x17c>
40008f34: 80 a6 60 00 cmp %i1, 0
if ( !_Timespec_Is_valid( timeout ) )
40008f38: 40 00 0f 9d call 4000cdac <_Timespec_Is_valid>
40008f3c: 90 10 00 1a mov %i2, %o0
40008f40: 80 8a 20 ff btst 0xff, %o0
40008f44: 02 80 00 7c be 40009134 <sigtimedwait+0x214>
40008f48: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
40008f4c: 40 00 0f ab call 4000cdf8 <_Timespec_To_ticks>
40008f50: 90 10 00 1a mov %i2, %o0
if ( !interval )
40008f54: b0 92 20 00 orcc %o0, 0, %i0
40008f58: 02 80 00 77 be 40009134 <sigtimedwait+0x214> <== NEVER TAKEN
40008f5c: 80 a6 60 00 cmp %i1, 0
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
40008f60: 02 80 00 52 be 400090a8 <sigtimedwait+0x188> <== NEVER TAKEN
40008f64: 35 10 00 71 sethi %hi(0x4001c400), %i2
the_thread = _Thread_Executing;
40008f68: 35 10 00 71 sethi %hi(0x4001c400), %i2
40008f6c: b4 16 a1 60 or %i2, 0x160, %i2 ! 4001c560 <_Per_CPU_Information>
40008f70: f8 06 a0 10 ld [ %i2 + 0x10 ], %i4
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
40008f74: 7f ff e7 1e call 40002bec <sparc_disable_interrupts>
40008f78: f6 07 21 50 ld [ %i4 + 0x150 ], %i3
40008f7c: a0 10 00 08 mov %o0, %l0
if ( *set & api->signals_pending ) {
40008f80: c2 07 40 00 ld [ %i5 ], %g1
40008f84: c4 06 e0 d4 ld [ %i3 + 0xd4 ], %g2
40008f88: 80 88 40 02 btst %g1, %g2
40008f8c: 12 80 00 52 bne 400090d4 <sigtimedwait+0x1b4>
40008f90: 01 00 00 00 nop
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
40008f94: 05 10 00 71 sethi %hi(0x4001c400), %g2
40008f98: c4 00 a3 b4 ld [ %g2 + 0x3b4 ], %g2 ! 4001c7b4 <_POSIX_signals_Pending>
40008f9c: 80 88 40 02 btst %g1, %g2
40008fa0: 12 80 00 2e bne 40009058 <sigtimedwait+0x138>
40008fa4: 03 10 00 70 sethi %hi(0x4001c000), %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;
40008fa8: c4 00 60 50 ld [ %g1 + 0x50 ], %g2 ! 4001c050 <_Thread_Dispatch_disable_level>
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
return signo;
}
the_info->si_signo = -1;
40008fac: 86 10 3f ff mov -1, %g3
40008fb0: c6 26 40 00 st %g3, [ %i1 ]
++level;
40008fb4: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
40008fb8: c4 20 60 50 st %g2, [ %g1 + 0x50 ]
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
40008fbc: 82 10 20 04 mov 4, %g1
40008fc0: c2 27 20 34 st %g1, [ %i4 + 0x34 ]
the_thread->Wait.option = *set;
40008fc4: c2 07 40 00 ld [ %i5 ], %g1
the_thread->Wait.return_argument = the_info;
40008fc8: f2 27 20 28 st %i1, [ %i4 + 0x28 ]
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
40008fcc: c2 27 20 30 st %g1, [ %i4 + 0x30 ]
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
40008fd0: a2 10 20 01 mov 1, %l1
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
40008fd4: 21 10 00 71 sethi %hi(0x4001c400), %l0
40008fd8: a0 14 23 4c or %l0, 0x34c, %l0 ! 4001c74c <_POSIX_signals_Wait_queue>
40008fdc: e0 27 20 44 st %l0, [ %i4 + 0x44 ]
40008fe0: e2 24 20 30 st %l1, [ %l0 + 0x30 ]
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
the_thread->Wait.return_argument = the_info;
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
40008fe4: 7f ff e7 06 call 40002bfc <sparc_enable_interrupts>
40008fe8: 01 00 00 00 nop
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
40008fec: 90 10 00 10 mov %l0, %o0
40008ff0: 92 10 00 18 mov %i0, %o1
40008ff4: 15 10 00 32 sethi %hi(0x4000c800), %o2
40008ff8: 40 00 0d ff call 4000c7f4 <_Thread_queue_Enqueue_with_handler>
40008ffc: 94 12 a3 d4 or %o2, 0x3d4, %o2 ! 4000cbd4 <_Thread_queue_Timeout>
_Thread_Enable_dispatch();
40009000: 40 00 0c bd call 4000c2f4 <_Thread_Enable_dispatch>
40009004: 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 );
40009008: d2 06 40 00 ld [ %i1 ], %o1
4000900c: 90 10 00 1b mov %i3, %o0
40009010: 94 10 00 19 mov %i1, %o2
40009014: 96 10 20 00 clr %o3
40009018: 40 00 18 ac call 4000f2c8 <_POSIX_signals_Clear_signals>
4000901c: 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)
40009020: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
40009024: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40009028: 80 a0 60 04 cmp %g1, 4
4000902c: 12 80 00 3b bne 40009118 <sigtimedwait+0x1f8>
40009030: 01 00 00 00 nop
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
40009034: f0 06 40 00 ld [ %i1 ], %i0
40009038: c2 07 40 00 ld [ %i5 ], %g1
4000903c: 84 06 3f ff add %i0, -1, %g2
40009040: a3 2c 40 02 sll %l1, %g2, %l1
40009044: 80 8c 40 01 btst %l1, %g1
40009048: 02 80 00 34 be 40009118 <sigtimedwait+0x1f8>
4000904c: 01 00 00 00 nop
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
40009050: 81 c7 e0 08 ret
40009054: 81 e8 00 00 restore
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
40009058: 7f ff ff 9a call 40008ec0 <_POSIX_signals_Get_lowest>
4000905c: 90 10 00 02 mov %g2, %o0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
40009060: 94 10 00 19 mov %i1, %o2
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
40009064: b0 10 00 08 mov %o0, %i0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
40009068: 96 10 20 01 mov 1, %o3
4000906c: 90 10 00 1b mov %i3, %o0
40009070: 92 10 00 18 mov %i0, %o1
40009074: 40 00 18 95 call 4000f2c8 <_POSIX_signals_Clear_signals>
40009078: 98 10 20 00 clr %o4
_ISR_Enable( level );
4000907c: 7f ff e6 e0 call 40002bfc <sparc_enable_interrupts>
40009080: 90 10 00 10 mov %l0, %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
40009084: 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;
40009088: f0 26 40 00 st %i0, [ %i1 ]
the_info->si_code = SI_USER;
4000908c: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
40009090: c0 26 60 08 clr [ %i1 + 8 ]
40009094: 81 c7 e0 08 ret
40009098: 81 e8 00 00 restore
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
4000909c: 12 bf ff b3 bne 40008f68 <sigtimedwait+0x48>
400090a0: b0 10 20 00 clr %i0
the_thread = _Thread_Executing;
400090a4: 35 10 00 71 sethi %hi(0x4001c400), %i2
400090a8: b4 16 a1 60 or %i2, 0x160, %i2 ! 4001c560 <_Per_CPU_Information>
400090ac: f8 06 a0 10 ld [ %i2 + 0x10 ], %i4
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
400090b0: b2 07 bf f4 add %fp, -12, %i1
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
400090b4: 7f ff e6 ce call 40002bec <sparc_disable_interrupts>
400090b8: f6 07 21 50 ld [ %i4 + 0x150 ], %i3
400090bc: a0 10 00 08 mov %o0, %l0
if ( *set & api->signals_pending ) {
400090c0: c2 07 40 00 ld [ %i5 ], %g1
400090c4: c4 06 e0 d4 ld [ %i3 + 0xd4 ], %g2
400090c8: 80 88 40 02 btst %g1, %g2
400090cc: 22 bf ff b3 be,a 40008f98 <sigtimedwait+0x78>
400090d0: 05 10 00 71 sethi %hi(0x4001c400), %g2
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
400090d4: 7f ff ff 7b call 40008ec0 <_POSIX_signals_Get_lowest>
400090d8: 90 10 00 02 mov %g2, %o0
_POSIX_signals_Clear_signals(
400090dc: 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 );
400090e0: 92 10 00 08 mov %o0, %o1
400090e4: d0 26 40 00 st %o0, [ %i1 ]
_POSIX_signals_Clear_signals(
400090e8: 96 10 20 00 clr %o3
400090ec: 90 10 00 1b mov %i3, %o0
400090f0: 40 00 18 76 call 4000f2c8 <_POSIX_signals_Clear_signals>
400090f4: 98 10 20 00 clr %o4
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
400090f8: 7f ff e6 c1 call 40002bfc <sparc_enable_interrupts>
400090fc: 90 10 00 10 mov %l0, %o0
the_info->si_code = SI_USER;
40009100: 82 10 20 01 mov 1, %g1
the_info->si_value.sival_int = 0;
40009104: c0 26 60 08 clr [ %i1 + 8 ]
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
40009108: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
return the_info->si_signo;
4000910c: f0 06 40 00 ld [ %i1 ], %i0
40009110: 81 c7 e0 08 ret
40009114: 81 e8 00 00 restore
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
errno = _Thread_Executing->Wait.return_code;
40009118: 40 00 23 6d call 40011ecc <__errno>
4000911c: b0 10 3f ff mov -1, %i0
40009120: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
40009124: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40009128: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
return the_info->si_signo;
}
4000912c: 81 c7 e0 08 ret
40009130: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
40009134: 40 00 23 66 call 40011ecc <__errno>
40009138: b0 10 3f ff mov -1, %i0
4000913c: 82 10 20 16 mov 0x16, %g1
40009140: c2 22 00 00 st %g1, [ %o0 ]
40009144: 81 c7 e0 08 ret
40009148: 81 e8 00 00 restore
4000ad4c <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
4000ad4c: 9d e3 bf a0 save %sp, -96, %sp
int status;
status = sigtimedwait( set, NULL, NULL );
4000ad50: 92 10 20 00 clr %o1
4000ad54: 90 10 00 18 mov %i0, %o0
4000ad58: 7f ff ff 6e call 4000ab10 <sigtimedwait>
4000ad5c: 94 10 20 00 clr %o2
if ( status != -1 ) {
4000ad60: 80 a2 3f ff cmp %o0, -1
4000ad64: 02 80 00 07 be 4000ad80 <sigwait+0x34>
4000ad68: 80 a6 60 00 cmp %i1, 0
if ( sig )
4000ad6c: 02 80 00 0a be 4000ad94 <sigwait+0x48> <== NEVER TAKEN
4000ad70: 01 00 00 00 nop
*sig = status;
4000ad74: d0 26 40 00 st %o0, [ %i1 ]
return 0;
4000ad78: 81 c7 e0 08 ret
4000ad7c: 91 e8 20 00 restore %g0, 0, %o0
}
return errno;
4000ad80: 40 00 22 86 call 40013798 <__errno>
4000ad84: 01 00 00 00 nop
4000ad88: f0 02 00 00 ld [ %o0 ], %i0
4000ad8c: 81 c7 e0 08 ret
4000ad90: 81 e8 00 00 restore
}
4000ad94: 81 c7 e0 08 ret <== NOT EXECUTED
4000ad98: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
400070a0 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
400070a0: 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)) {
400070a4: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
400070a8: 80 88 6e 78 btst 0xe78, %g1
400070ac: 32 80 00 04 bne,a 400070bc <siproc+0x1c> <== ALWAYS TAKEN
400070b0: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
400070b4: 7f ff ff 64 call 40006e44 <iproc> <== NOT EXECUTED
400070b8: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400070bc: 94 10 20 00 clr %o2
400070c0: 40 00 05 33 call 4000858c <rtems_semaphore_obtain>
400070c4: 92 10 20 00 clr %o1
i = iproc (c, tty);
400070c8: 90 10 00 18 mov %i0, %o0
400070cc: 7f ff ff 5e call 40006e44 <iproc>
400070d0: 92 10 00 19 mov %i1, %o1
400070d4: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
400070d8: 40 00 05 7c call 400086c8 <rtems_semaphore_release>
400070dc: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
400070e0: 81 c7 e0 08 ret
400070e4: 81 e8 00 00 restore
4000fd40 <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 )
{
4000fd40: 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 ) {
4000fd44: 03 30 06 10 sethi %hi(0xc0184000), %g1
4000fd48: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <LEON_REG+0x40184201>
4000fd4c: 80 a6 40 01 cmp %i1, %g1
4000fd50: 02 80 00 23 be 4000fddc <sparse_disk_ioctl+0x9c>
4000fd54: f6 06 20 3c ld [ %i0 + 0x3c ], %i3
case RTEMS_BLKDEV_REQ_WRITE:
return sparse_disk_read_write( sd, r, r->req == RTEMS_BLKDEV_REQ_READ );
default:
break;
}
} else if ( RTEMS_BLKIO_DELETED == req ) {
4000fd58: 03 08 00 10 sethi %hi(0x20004000), %g1
4000fd5c: 82 10 62 07 or %g1, 0x207, %g1 ! 20004207 <RAM_SIZE+0x1fc04207>
4000fd60: 80 a6 40 01 cmp %i1, %g1
4000fd64: 02 80 00 07 be 4000fd80 <sparse_disk_ioctl+0x40>
4000fd68: 90 10 00 18 mov %i0, %o0
if ( NULL != sd->delete_handler )
( *sd->delete_handler )( sd );
return 0;
} else {
return rtems_blkdev_ioctl( dd, req, argp );
4000fd6c: 92 10 00 19 mov %i1, %o1
4000fd70: 40 00 0c ab call 4001301c <rtems_blkdev_ioctl>
4000fd74: 94 10 00 1a mov %i2, %o2
4000fd78: 81 c7 e0 08 ret
4000fd7c: 91 e8 00 08 restore %g0, %o0, %o0
return sparse_disk_read_write( sd, r, r->req == RTEMS_BLKDEV_REQ_READ );
default:
break;
}
} else if ( RTEMS_BLKIO_DELETED == req ) {
sc = rtems_semaphore_delete( sd->mutex );
4000fd80: 7f ff e9 e7 call 4000a51c <rtems_semaphore_delete>
4000fd84: d0 06 c0 00 ld [ %i3 ], %o0
if ( RTEMS_SUCCESSFUL != sc )
4000fd88: 80 a2 20 00 cmp %o0, 0
4000fd8c: 12 80 00 a0 bne 4001000c <sparse_disk_ioctl+0x2cc> <== NEVER TAKEN
4000fd90: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
sd->mutex = RTEMS_ID_NONE;
if ( NULL != sd->delete_handler )
4000fd94: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
sc = rtems_semaphore_delete( sd->mutex );
if ( RTEMS_SUCCESSFUL != sc )
rtems_fatal_error_occurred( 0xdeadbeef );
sd->mutex = RTEMS_ID_NONE;
4000fd98: c0 26 c0 00 clr [ %i3 ]
if ( NULL != sd->delete_handler )
4000fd9c: 80 a0 60 00 cmp %g1, 0
4000fda0: 02 80 00 04 be 4000fdb0 <sparse_disk_ioctl+0x70> <== NEVER TAKEN
4000fda4: b0 10 20 00 clr %i0
( *sd->delete_handler )( sd );
4000fda8: 9f c0 40 00 call %g1
4000fdac: 90 10 00 1b mov %i3, %o0
4000fdb0: 81 c7 e0 08 ret
4000fdb4: 81 e8 00 00 restore
bytes_handled += rv;
buff_size -= rv;
}
}
rtems_semaphore_release( sparse_disk->mutex );
4000fdb8: d0 06 c0 00 ld [ %i3 ], %o0
4000fdbc: 7f ff ea 5e call 4000a734 <rtems_semaphore_release>
4000fdc0: b0 10 20 00 clr %i0
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
4000fdc4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000fdc8: 90 10 00 1a mov %i2, %o0
4000fdcc: 9f c0 40 00 call %g1
4000fdd0: 92 10 20 00 clr %o1
return rtems_blkdev_ioctl( dd, req, argp );
}
errno = EINVAL;
return -1;
}
4000fdd4: 81 c7 e0 08 ret
4000fdd8: 81 e8 00 00 restore
rtems_sparse_disk *sd = rtems_disk_get_driver_data( dd );
if ( RTEMS_BLKIO_REQUEST == req ) {
rtems_blkdev_request *r = argp;
switch ( r->req ) {
4000fddc: e6 06 80 00 ld [ %i2 ], %l3
4000fde0: 80 a4 e0 01 cmp %l3, 1
4000fde4: 18 80 00 84 bgu 4000fff4 <sparse_disk_ioctl+0x2b4> <== NEVER TAKEN
4000fde8: 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 );
4000fdec: d0 06 c0 00 ld [ %i3 ], %o0
4000fdf0: 7f ff ea 02 call 4000a5f8 <rtems_semaphore_obtain>
4000fdf4: 94 10 20 00 clr %o2
/* we only need to write the block if it is different from the fill pattern.
* If the read method does not find a block it will deliver the fill pattern anyway.
*/
key = bsearch(
4000fdf8: 25 10 00 3f sethi %hi(0x4000fc00), %l2
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
4000fdfc: a8 10 20 00 clr %l4
static int sparse_disk_read_write(
rtems_sparse_disk *sparse_disk,
rtems_blkdev_request *req,
const bool read )
{
int rv = 0;
4000fe00: 84 10 20 00 clr %g2
/* we only need to write the block if it is different from the fill pattern.
* If the read method does not find a block it will deliver the fill pattern anyway.
*/
key = bsearch(
4000fe04: a4 14 a1 18 or %l2, 0x118, %l2
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
( 0 <= rv ) && ( req_buffer < req->bufnum );
4000fe08: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
4000fe0c: 80 a0 40 14 cmp %g1, %l4
4000fe10: 08 bf ff ea bleu 4000fdb8 <sparse_disk_ioctl+0x78>
4000fe14: 87 2d 20 04 sll %l4, 4, %g3
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
4000fe18: 80 a0 a0 00 cmp %g2, 0
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
4000fe1c: 86 00 e0 18 add %g3, 0x18, %g3
4000fe20: 82 06 80 03 add %i2, %g3, %g1
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
4000fe24: f2 06 80 03 ld [ %i2 + %g3 ], %i1
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
4000fe28: e2 00 60 08 ld [ %g1 + 8 ], %l1
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
4000fe2c: 06 80 00 40 bl 4000ff2c <sparse_disk_ioctl+0x1ec> <== NEVER TAKEN
4000fe30: f8 00 60 04 ld [ %g1 + 4 ], %i4
4000fe34: 80 a7 20 00 cmp %i4, 0
4000fe38: 02 80 00 3d be 4000ff2c <sparse_disk_ioctl+0x1ec> <== NEVER TAKEN
4000fe3c: b0 10 20 00 clr %i0
const rtems_blkdev_bnum block,
uint8_t *buffer,
const size_t buffer_size )
{
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
4000fe40: 10 80 00 1d b 4000feb4 <sparse_disk_ioctl+0x174>
4000fe44: f2 27 bf f8 st %i1, [ %fp + -8 ]
4000fe48: 80 a7 00 01 cmp %i4, %g1
4000fe4c: 38 80 00 02 bgu,a 4000fe54 <sparse_disk_ioctl+0x114>
4000fe50: ba 10 00 01 mov %g1, %i5
size_t bytes_to_copy = sparse_disk->media_block_size;
if ( buffer_size < bytes_to_copy )
bytes_to_copy = buffer_size;
key = bsearch(
4000fe54: d2 06 e0 18 ld [ %i3 + 0x18 ], %o1
4000fe58: d4 06 e0 08 ld [ %i3 + 8 ], %o2
4000fe5c: 90 07 bf f8 add %fp, -8, %o0
4000fe60: 96 10 20 08 mov 8, %o3
4000fe64: 40 00 35 a9 call 4001d508 <bsearch>
4000fe68: 98 10 00 12 mov %l2, %o4
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL != key )
4000fe6c: 80 a2 20 00 cmp %o0, 0
4000fe70: 02 80 00 29 be 4000ff14 <sparse_disk_ioctl+0x1d4>
4000fe74: 94 10 00 1d mov %i5, %o2
memcpy( buffer, key->data, bytes_to_copy );
4000fe78: d2 02 20 04 ld [ %o0 + 4 ], %o1
4000fe7c: 40 00 38 6a call 4001e024 <memcpy>
4000fe80: 90 10 00 10 mov %l0, %o0
4000fe84: b8 27 00 1d sub %i4, %i5, %i4
4000fe88: 82 38 00 1d xnor %g0, %i5, %g1
4000fe8c: 80 a0 00 1c cmp %g0, %i4
4000fe90: 83 30 60 1f srl %g1, 0x1f, %g1
4000fe94: 86 40 20 00 addx %g0, 0, %g3
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
else if ( block_needs_writing )
return -1;
return bytes_to_copy;
4000fe98: 84 10 00 1d mov %i5, %g2
4000fe9c: 82 08 c0 01 and %g3, %g1, %g1
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
4000fea0: b2 06 60 01 inc %i1
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
4000fea4: 80 88 60 ff btst 0xff, %g1
4000fea8: 02 80 00 21 be 4000ff2c <sparse_disk_ioctl+0x1ec>
4000feac: b0 06 00 1d add %i0, %i5, %i0
const rtems_blkdev_bnum block,
uint8_t *buffer,
const size_t buffer_size )
{
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
4000feb0: f2 27 bf f8 st %i1, [ %fp + -8 ]
.block = block,
.data = NULL
};
size_t bytes_to_copy = sparse_disk->media_block_size;
4000feb4: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
const rtems_blkdev_bnum block,
uint8_t *buffer,
const size_t buffer_size )
{
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
4000feb8: c0 27 bf fc clr [ %fp + -4 ]
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
if ( read )
rv = sparse_disk_read_block( sparse_disk,
4000febc: a0 04 40 18 add %l1, %i0, %l0
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
if ( read )
4000fec0: 80 a4 e0 00 cmp %l3, 0
4000fec4: 02 bf ff e1 be 4000fe48 <sparse_disk_ioctl+0x108>
4000fec8: ba 10 00 1c mov %i4, %i5
4000fecc: 80 a7 00 01 cmp %i4, %g1
4000fed0: 38 80 00 02 bgu,a 4000fed8 <sparse_disk_ioctl+0x198>
4000fed4: ba 10 00 01 mov %g1, %i5
/* we only need to write the block if it is different from the fill pattern.
* If the read method does not find a block it will deliver the fill pattern anyway.
*/
key = bsearch(
4000fed8: d2 06 e0 18 ld [ %i3 + 0x18 ], %o1
4000fedc: d4 06 e0 08 ld [ %i3 + 8 ], %o2
4000fee0: 90 07 bf f8 add %fp, -8, %o0
4000fee4: 96 10 20 08 mov 8, %o3
4000fee8: 40 00 35 88 call 4001d508 <bsearch>
4000feec: 98 10 00 12 mov %l2, %o4
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
4000fef0: aa 92 20 00 orcc %o0, 0, %l5
4000fef4: 02 80 00 1a be 4000ff5c <sparse_disk_ioctl+0x21c>
4000fef8: 80 a7 60 00 cmp %i5, 0
key = sparse_disk_get_new_block( sparse_disk, block );
}
}
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
4000fefc: d0 05 60 04 ld [ %l5 + 4 ], %o0
4000ff00: 92 10 00 10 mov %l0, %o1
4000ff04: 40 00 38 48 call 4001e024 <memcpy>
4000ff08: 94 10 00 1d mov %i5, %o2
4000ff0c: 10 bf ff df b 4000fe88 <sparse_disk_ioctl+0x148>
4000ff10: b8 27 00 1d sub %i4, %i5, %i4
);
if ( NULL != key )
memcpy( buffer, key->data, bytes_to_copy );
else
memset( buffer, sparse_disk->fill_pattern, buffer_size );
4000ff14: d2 0e e0 14 ldub [ %i3 + 0x14 ], %o1
4000ff18: 90 10 00 10 mov %l0, %o0
4000ff1c: 40 00 38 7f call 4001e118 <memset>
4000ff20: 94 10 00 1c mov %i4, %o2
4000ff24: 10 bf ff d9 b 4000fe88 <sparse_disk_ioctl+0x148>
4000ff28: b8 27 00 1d sub %i4, %i5, %i4
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
4000ff2c: 80 a0 a0 00 cmp %g2, 0
4000ff30: 16 bf ff b6 bge 4000fe08 <sparse_disk_ioctl+0xc8> <== ALWAYS TAKEN
4000ff34: a8 05 20 01 inc %l4
bytes_handled += rv;
buff_size -= rv;
}
}
rtems_semaphore_release( sparse_disk->mutex );
4000ff38: d0 06 c0 00 ld [ %i3 ], %o0 <== NOT EXECUTED
4000ff3c: 7f ff e9 fe call 4000a734 <rtems_semaphore_release> <== NOT EXECUTED
4000ff40: b0 10 20 00 clr %i0 <== NOT EXECUTED
4000ff44: c2 06 a0 04 ld [ %i2 + 4 ], %g1 <== NOT EXECUTED
4000ff48: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4000ff4c: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000ff50: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
4000ff54: 81 c7 e0 08 ret <== NOT EXECUTED
4000ff58: 81 e8 00 00 restore <== NOT EXECUTED
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
4000ff5c: 02 bf ff ca be 4000fe84 <sparse_disk_ioctl+0x144> <== NEVER TAKEN
4000ff60: 82 10 20 00 clr %g1
4000ff64: 10 80 00 05 b 4000ff78 <sparse_disk_ioctl+0x238>
4000ff68: c8 0e e0 14 ldub [ %i3 + 0x14 ], %g4
4000ff6c: 80 a0 40 1d cmp %g1, %i5
4000ff70: 1a 80 00 0b bcc 4000ff9c <sparse_disk_ioctl+0x25c>
4000ff74: 80 88 e0 ff btst 0xff, %g3
if ( buffer[i] != sparse_disk->fill_pattern )
4000ff78: c4 0c 00 01 ldub [ %l0 + %g1 ], %g2
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
4000ff7c: 82 00 60 01 inc %g1
if ( buffer[i] != sparse_disk->fill_pattern )
4000ff80: 84 18 80 04 xor %g2, %g4, %g2
4000ff84: 80 a0 00 02 cmp %g0, %g2
4000ff88: 84 40 20 00 addx %g0, 0, %g2
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
4000ff8c: 80 a0 a0 00 cmp %g2, 0
4000ff90: 02 bf ff f7 be 4000ff6c <sparse_disk_ioctl+0x22c>
4000ff94: 86 10 00 02 mov %g2, %g3
if ( buffer[i] != sparse_disk->fill_pattern )
block_needs_writing = true;
}
if ( block_needs_writing ) {
4000ff98: 80 88 e0 ff btst 0xff, %g3
4000ff9c: 22 bf ff bb be,a 4000fe88 <sparse_disk_ioctl+0x148>
4000ffa0: b8 27 00 1d sub %i4, %i5, %i4
rtems_sparse_disk *sparse_disk,
const rtems_blkdev_bnum block )
{
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
4000ffa4: c2 06 e0 08 ld [ %i3 + 8 ], %g1
4000ffa8: c4 06 e0 04 ld [ %i3 + 4 ], %g2
4000ffac: 80 a0 40 02 cmp %g1, %g2
4000ffb0: 1a 80 00 0c bcc 4000ffe0 <sparse_disk_ioctl+0x2a0> <== NEVER TAKEN
4000ffb4: ab 28 60 03 sll %g1, 3, %l5
key = &sparse_disk->key_table[sparse_disk->used_count];
4000ffb8: d0 06 e0 18 ld [ %i3 + 0x18 ], %o0
key->block = block;
4000ffbc: f2 22 00 15 st %i1, [ %o0 + %l5 ]
++sparse_disk->used_count;
4000ffc0: 92 00 60 01 add %g1, 1, %o1
const rtems_blkdev_bnum block )
{
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
key = &sparse_disk->key_table[sparse_disk->used_count];
4000ffc4: aa 02 00 15 add %o0, %l5, %l5
key->block = block;
++sparse_disk->used_count;
4000ffc8: d2 26 e0 08 st %o1, [ %i3 + 8 ]
qsort( sparse_disk->key_table, sparse_disk->used_count,
4000ffcc: 94 10 20 08 mov 8, %o2
4000ffd0: 40 00 38 98 call 4001e230 <qsort>
4000ffd4: 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 );
4000ffd8: 10 bf ff ca b 4000ff00 <sparse_disk_ioctl+0x1c0>
4000ffdc: d0 05 60 04 ld [ %l5 + 4 ], %o0
4000ffe0: b8 07 20 01 inc %i4 <== NOT EXECUTED
rtems_sparse_disk *sparse_disk,
const rtems_blkdev_bnum block )
{
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
4000ffe4: 82 10 20 00 clr %g1 <== NOT EXECUTED
4000ffe8: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
}
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
else if ( block_needs_writing )
return -1;
4000ffec: 10 bf ff ad b 4000fea0 <sparse_disk_ioctl+0x160> <== NOT EXECUTED
4000fff0: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED
return 0;
} else {
return rtems_blkdev_ioctl( dd, req, argp );
}
errno = EINVAL;
4000fff4: 40 00 35 67 call 4001d590 <__errno> <== NOT EXECUTED
4000fff8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000fffc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40010000: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
40010004: 81 c7 e0 08 ret <== NOT EXECUTED
40010008: 81 e8 00 00 restore <== NOT EXECUTED
}
} else if ( RTEMS_BLKIO_DELETED == req ) {
sc = rtems_semaphore_delete( sd->mutex );
if ( RTEMS_SUCCESSFUL != sc )
rtems_fatal_error_occurred( 0xdeadbeef );
4001000c: 7f ff eb 5c call 4000ad7c <rtems_fatal_error_occurred> <== NOT EXECUTED
40010010: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
40006754 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
40006754: 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;
40006758: c2 06 21 48 ld [ %i0 + 0x148 ], %g1
if ( this_reent ) {
4000675c: 80 a0 60 00 cmp %g1, 0
40006760: 02 80 00 0c be 40006790 <sync_per_thread+0x3c> <== NEVER TAKEN
40006764: 3b 10 00 67 sethi %hi(0x40019c00), %i5
current_reent = _Thread_Executing->libc_reent;
40006768: ba 17 61 d0 or %i5, 0x1d0, %i5 ! 40019dd0 <_Per_CPU_Information>
4000676c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
40006770: 13 10 00 19 sethi %hi(0x40006400), %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;
40006774: f8 00 a1 48 ld [ %g2 + 0x148 ], %i4
_Thread_Executing->libc_reent = this_reent;
40006778: c2 20 a1 48 st %g1, [ %g2 + 0x148 ]
_fwalk (t->libc_reent, sync_wrapper);
4000677c: d0 06 21 48 ld [ %i0 + 0x148 ], %o0
40006780: 40 00 2e f3 call 4001234c <_fwalk>
40006784: 92 12 63 98 or %o1, 0x398, %o1
_Thread_Executing->libc_reent = current_reent;
40006788: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000678c: f8 20 61 48 st %i4, [ %g1 + 0x148 ]
40006790: 81 c7 e0 08 ret
40006794: 81 e8 00 00 restore
40007bc8 <sysconf>:
*/
long sysconf(
int name
)
{
40007bc8: 9d e3 bf a0 save %sp, -96, %sp
if ( name == _SC_CLK_TCK )
40007bcc: 80 a6 20 02 cmp %i0, 2
40007bd0: 02 80 00 12 be 40007c18 <sysconf+0x50>
40007bd4: 82 10 00 18 mov %i0, %g1
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
40007bd8: 80 a6 20 04 cmp %i0, 4
40007bdc: 02 80 00 16 be 40007c34 <sysconf+0x6c>
40007be0: 80 a0 60 33 cmp %g1, 0x33
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
40007be4: 02 80 00 0b be 40007c10 <sysconf+0x48>
40007be8: b0 10 24 00 mov 0x400, %i0
return 1024;
if ( name == _SC_PAGESIZE )
40007bec: 80 a0 60 08 cmp %g1, 8
40007bf0: 02 80 00 08 be 40007c10 <sysconf+0x48>
40007bf4: 31 00 00 04 sethi %hi(0x1000), %i0
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
40007bf8: 80 a0 60 4f cmp %g1, 0x4f
40007bfc: 02 80 00 05 be 40007c10 <sysconf+0x48> <== NEVER TAKEN
40007c00: b0 10 20 20 mov 0x20, %i0
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
40007c04: 80 a0 62 03 cmp %g1, 0x203
40007c08: 12 80 00 0f bne 40007c44 <sysconf+0x7c> <== ALWAYS TAKEN
40007c0c: b0 10 20 00 clr %i0
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
}
40007c10: 81 c7 e0 08 ret
40007c14: 81 e8 00 00 restore
int name
)
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
40007c18: 03 10 00 5a sethi %hi(0x40016800), %g1
long sysconf(
int name
)
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
40007c1c: d2 00 62 b4 ld [ %g1 + 0x2b4 ], %o1 ! 40016ab4 <Configuration+0xc>
40007c20: 11 00 03 d0 sethi %hi(0xf4000), %o0
40007c24: 40 00 32 7c call 40014614 <.udiv>
40007c28: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
40007c2c: 81 c7 e0 08 ret
40007c30: 91 e8 00 08 restore %g0, %o0, %o0
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
return rtems_libio_number_iops;
40007c34: 03 10 00 60 sethi %hi(0x40018000), %g1
40007c38: f0 00 62 e8 ld [ %g1 + 0x2e8 ], %i0 ! 400182e8 <rtems_libio_number_iops>
40007c3c: 81 c7 e0 08 ret
40007c40: 81 e8 00 00 restore
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
40007c44: 40 00 23 23 call 400108d0 <__errno>
40007c48: b0 10 3f ff mov -1, %i0
40007c4c: 82 10 20 16 mov 0x16, %g1
40007c50: c2 22 00 00 st %g1, [ %o0 ]
}
40007c54: 81 c7 e0 08 ret
40007c58: 81 e8 00 00 restore
40016f10 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
40016f10: 9d e3 bf a0 save %sp, -96, %sp
switch (opt) {
40016f14: 80 a6 60 00 cmp %i1, 0
40016f18: 02 80 00 10 be 40016f58 <tcsetattr+0x48>
40016f1c: 80 a6 60 01 cmp %i1, 1
40016f20: 02 80 00 08 be 40016f40 <tcsetattr+0x30>
40016f24: 90 10 00 18 mov %i0, %o0
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
40016f28: 40 00 11 f0 call 4001b6e8 <__errno>
40016f2c: 01 00 00 00 nop
40016f30: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
40016f34: c2 22 00 00 st %g1, [ %o0 ]
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
}
}
40016f38: 81 c7 e0 08 ret
40016f3c: 91 e8 3f ff restore %g0, -1, %o0
switch (opt) {
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
40016f40: 92 10 20 03 mov 3, %o1
40016f44: 40 00 0e 52 call 4001a88c <ioctl>
40016f48: 94 10 20 00 clr %o2
40016f4c: 80 a2 20 00 cmp %o0, 0
40016f50: 06 bf ff fa bl 40016f38 <tcsetattr+0x28> <== NEVER TAKEN
40016f54: 01 00 00 00 nop
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
40016f58: 40 00 0e 4d call 4001a88c <ioctl>
40016f5c: 93 e8 20 02 restore %g0, 2, %o1
40009450 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
40009450: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
40009454: 80 a6 20 01 cmp %i0, 1
40009458: 12 80 00 3d bne 4000954c <timer_create+0xfc>
4000945c: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
40009460: 02 80 00 3b be 4000954c <timer_create+0xfc>
40009464: 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) {
40009468: 02 80 00 0e be 400094a0 <timer_create+0x50>
4000946c: 03 10 00 93 sethi %hi(0x40024c00), %g1
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
40009470: c2 06 40 00 ld [ %i1 ], %g1
40009474: 82 00 7f ff add %g1, -1, %g1
40009478: 80 a0 60 01 cmp %g1, 1
4000947c: 18 80 00 34 bgu 4000954c <timer_create+0xfc> <== NEVER TAKEN
40009480: 01 00 00 00 nop
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
40009484: c2 06 60 04 ld [ %i1 + 4 ], %g1
40009488: 80 a0 60 00 cmp %g1, 0
4000948c: 02 80 00 30 be 4000954c <timer_create+0xfc> <== NEVER TAKEN
40009490: 82 00 7f ff add %g1, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
40009494: 80 a0 60 1f cmp %g1, 0x1f
40009498: 18 80 00 2d bgu 4000954c <timer_create+0xfc> <== NEVER TAKEN
4000949c: 03 10 00 93 sethi %hi(0x40024c00), %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;
400094a0: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 40024cb0 <_Thread_Dispatch_disable_level>
++level;
400094a4: 84 00 a0 01 inc %g2
_Thread_Dispatch_disable_level = level;
400094a8: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ]
* 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 );
400094ac: 3b 10 00 93 sethi %hi(0x40024c00), %i5
400094b0: 40 00 08 e0 call 4000b830 <_Objects_Allocate>
400094b4: 90 17 63 b4 or %i5, 0x3b4, %o0 ! 40024fb4 <_POSIX_Timer_Information>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
400094b8: 80 a2 20 00 cmp %o0, 0
400094bc: 02 80 00 2a be 40009564 <timer_create+0x114>
400094c0: 82 10 20 02 mov 2, %g1
rtems_set_errno_and_return_minus_one( EAGAIN );
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
400094c4: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ]
ptimer->thread_id = _Thread_Executing->Object.id;
400094c8: 03 10 00 94 sethi %hi(0x40025000), %g1
400094cc: c2 00 62 10 ld [ %g1 + 0x210 ], %g1 ! 40025210 <_Per_CPU_Information+0x10>
if ( evp != NULL ) {
400094d0: 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;
400094d4: c2 00 60 08 ld [ %g1 + 8 ], %g1
if ( evp != NULL ) {
400094d8: 02 80 00 08 be 400094f8 <timer_create+0xa8>
400094dc: c2 22 20 38 st %g1, [ %o0 + 0x38 ]
ptimer->inf.sigev_notify = evp->sigev_notify;
400094e0: c6 06 40 00 ld [ %i1 ], %g3
ptimer->inf.sigev_signo = evp->sigev_signo;
400094e4: c4 06 60 04 ld [ %i1 + 4 ], %g2
ptimer->inf.sigev_value = evp->sigev_value;
400094e8: c2 06 60 08 ld [ %i1 + 8 ], %g1
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
ptimer->thread_id = _Thread_Executing->Object.id;
if ( evp != NULL ) {
ptimer->inf.sigev_notify = evp->sigev_notify;
400094ec: c6 22 20 40 st %g3, [ %o0 + 0x40 ]
ptimer->inf.sigev_signo = evp->sigev_signo;
400094f0: c4 22 20 44 st %g2, [ %o0 + 0x44 ]
ptimer->inf.sigev_value = evp->sigev_value;
400094f4: c2 22 20 48 st %g1, [ %o0 + 0x48 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
400094f8: c4 12 20 0a lduh [ %o0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
400094fc: ba 17 63 b4 or %i5, 0x3b4, %i5
40009500: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
}
ptimer->overrun = 0;
40009504: c0 22 20 68 clr [ %o0 + 0x68 ]
ptimer->timer_data.it_value.tv_sec = 0;
40009508: c0 22 20 5c clr [ %o0 + 0x5c ]
ptimer->timer_data.it_value.tv_nsec = 0;
4000950c: c0 22 20 60 clr [ %o0 + 0x60 ]
ptimer->timer_data.it_interval.tv_sec = 0;
40009510: c0 22 20 54 clr [ %o0 + 0x54 ]
ptimer->timer_data.it_interval.tv_nsec = 0;
40009514: c0 22 20 58 clr [ %o0 + 0x58 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40009518: c0 22 20 18 clr [ %o0 + 0x18 ]
the_watchdog->routine = routine;
4000951c: c0 22 20 2c clr [ %o0 + 0x2c ]
the_watchdog->id = id;
40009520: c0 22 20 30 clr [ %o0 + 0x30 ]
the_watchdog->user_data = user_data;
40009524: c0 22 20 34 clr [ %o0 + 0x34 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
40009528: c2 02 20 08 ld [ %o0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000952c: 85 28 a0 02 sll %g2, 2, %g2
40009530: 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;
40009534: 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;
40009538: c2 26 80 00 st %g1, [ %i2 ]
_Thread_Enable_dispatch();
4000953c: 40 00 0e 09 call 4000cd60 <_Thread_Enable_dispatch>
40009540: b0 10 20 00 clr %i0
return 0;
}
40009544: 81 c7 e0 08 ret
40009548: 81 e8 00 00 restore
if ( !evp->sigev_signo )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
4000954c: 40 00 24 c4 call 4001285c <__errno>
40009550: b0 10 3f ff mov -1, %i0
40009554: 82 10 20 16 mov 0x16, %g1
40009558: c2 22 00 00 st %g1, [ %o0 ]
4000955c: 81 c7 e0 08 ret
40009560: 81 e8 00 00 restore
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
_Thread_Enable_dispatch();
40009564: 40 00 0d ff call 4000cd60 <_Thread_Enable_dispatch>
40009568: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EAGAIN );
4000956c: 40 00 24 bc call 4001285c <__errno>
40009570: 01 00 00 00 nop
40009574: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
40009578: c2 22 00 00 st %g1, [ %o0 ]
4000957c: 81 c7 e0 08 ret
40009580: 81 e8 00 00 restore
400080a8 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
400080a8: 9d e3 bf 78 save %sp, -136, %sp
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
400080ac: 80 a6 a0 00 cmp %i2, 0
400080b0: 02 80 00 86 be 400082c8 <timer_settime+0x220> <== NEVER TAKEN
400080b4: 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) ) ) {
400080b8: 40 00 10 37 call 4000c194 <_Timespec_Is_valid>
400080bc: 90 06 a0 08 add %i2, 8, %o0
400080c0: 80 8a 20 ff btst 0xff, %o0
400080c4: 02 80 00 81 be 400082c8 <timer_settime+0x220>
400080c8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
400080cc: 40 00 10 32 call 4000c194 <_Timespec_Is_valid>
400080d0: 90 10 00 1a mov %i2, %o0
400080d4: 80 8a 20 ff btst 0xff, %o0
400080d8: 02 80 00 7c be 400082c8 <timer_settime+0x220> <== NEVER TAKEN
400080dc: 80 8e 7f fb btst -5, %i1
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
400080e0: 12 80 00 7a bne 400082c8 <timer_settime+0x220>
400080e4: 80 a6 60 04 cmp %i1, 4
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
400080e8: c8 06 80 00 ld [ %i2 ], %g4
400080ec: c6 06 a0 04 ld [ %i2 + 4 ], %g3
400080f0: c4 06 a0 08 ld [ %i2 + 8 ], %g2
400080f4: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
400080f8: c8 27 bf f0 st %g4, [ %fp + -16 ]
400080fc: c6 27 bf f4 st %g3, [ %fp + -12 ]
40008100: c4 27 bf f8 st %g2, [ %fp + -8 ]
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
40008104: 02 80 00 4c be 40008234 <timer_settime+0x18c>
40008108: c2 27 bf fc st %g1, [ %fp + -4 ]
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
4000810c: 92 10 00 18 mov %i0, %o1
40008110: 11 10 00 84 sethi %hi(0x40021000), %o0
40008114: 94 07 bf dc add %fp, -36, %o2
40008118: 40 00 09 ba call 4000a800 <_Objects_Get>
4000811c: 90 12 20 c4 or %o0, 0xc4, %o0
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
40008120: c2 07 bf dc ld [ %fp + -36 ], %g1
40008124: 80 a0 60 00 cmp %g1, 0
40008128: 12 80 00 68 bne 400082c8 <timer_settime+0x220> <== NEVER TAKEN
4000812c: 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 ) {
40008130: c2 07 bf f8 ld [ %fp + -8 ], %g1
40008134: 80 a0 60 00 cmp %g1, 0
40008138: 12 80 00 05 bne 4000814c <timer_settime+0xa4>
4000813c: c2 07 bf fc ld [ %fp + -4 ], %g1
40008140: 80 a0 60 00 cmp %g1, 0
40008144: 02 80 00 67 be 400082e0 <timer_settime+0x238>
40008148: 01 00 00 00 nop
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
4000814c: 40 00 10 4b call 4000c278 <_Timespec_To_ticks>
40008150: 90 10 00 1a mov %i2, %o0
40008154: d0 26 60 64 st %o0, [ %i1 + 0x64 ]
initial_period = _Timespec_To_ticks( &normalize.it_value );
40008158: 40 00 10 48 call 4000c278 <_Timespec_To_ticks>
4000815c: 90 07 bf f8 add %fp, -8, %o0
activated = _POSIX_Timer_Insert_helper(
40008160: 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 );
40008164: 92 10 00 08 mov %o0, %o1
activated = _POSIX_Timer_Insert_helper(
40008168: 98 10 00 19 mov %i1, %o4
4000816c: 90 06 60 10 add %i1, 0x10, %o0
40008170: 17 10 00 20 sethi %hi(0x40008000), %o3
40008174: 40 00 19 f7 call 4000e950 <_POSIX_Timer_Insert_helper>
40008178: 96 12 e3 4c or %o3, 0x34c, %o3 ! 4000834c <_POSIX_Timer_TSR>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
4000817c: 80 8a 20 ff btst 0xff, %o0
40008180: 02 80 00 29 be 40008224 <timer_settime+0x17c>
40008184: 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 )
40008188: 02 80 00 0b be 400081b4 <timer_settime+0x10c>
4000818c: c2 07 bf f0 ld [ %fp + -16 ], %g1
*ovalue = ptimer->timer_data;
40008190: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
40008194: c2 26 c0 00 st %g1, [ %i3 ]
40008198: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
4000819c: c2 26 e0 04 st %g1, [ %i3 + 4 ]
400081a0: c2 06 60 5c ld [ %i1 + 0x5c ], %g1
400081a4: c2 26 e0 08 st %g1, [ %i3 + 8 ]
400081a8: c2 06 60 60 ld [ %i1 + 0x60 ], %g1
400081ac: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
ptimer->timer_data = normalize;
400081b0: c2 07 bf f0 ld [ %fp + -16 ], %g1
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
400081b4: 90 07 bf e0 add %fp, -32, %o0
400081b8: c2 26 60 54 st %g1, [ %i1 + 0x54 ]
400081bc: c2 07 bf f4 ld [ %fp + -12 ], %g1
400081c0: 13 10 00 83 sethi %hi(0x40020c00), %o1
400081c4: c2 26 60 58 st %g1, [ %i1 + 0x58 ]
400081c8: c2 07 bf f8 ld [ %fp + -8 ], %g1
400081cc: 92 12 61 48 or %o1, 0x148, %o1
400081d0: c2 26 60 5c st %g1, [ %i1 + 0x5c ]
400081d4: c2 07 bf fc ld [ %fp + -4 ], %g1
400081d8: c2 26 60 60 st %g1, [ %i1 + 0x60 ]
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
400081dc: 82 10 20 03 mov 3, %g1
400081e0: 40 00 06 b4 call 40009cb0 <_TOD_Get_with_nanoseconds>
400081e4: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
400081e8: 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);
400081ec: 94 10 20 00 clr %o2
400081f0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
400081f4: 90 10 00 1c mov %i4, %o0
400081f8: 96 12 e2 00 or %o3, 0x200, %o3
400081fc: 40 00 4a ad call 4001acb0 <__divdi3>
40008200: 92 10 00 1d mov %i5, %o1
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40008204: 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);
40008208: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
4000820c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40008210: 90 10 00 1c mov %i4, %o0
40008214: 96 12 e2 00 or %o3, 0x200, %o3
40008218: 40 00 4b 91 call 4001b05c <__moddi3>
4000821c: 92 10 00 1d mov %i5, %o1
40008220: 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();
40008224: 40 00 0d 2e call 4000b6dc <_Thread_Enable_dispatch>
40008228: b0 10 20 00 clr %i0
4000822c: 81 c7 e0 08 ret
40008230: 81 e8 00 00 restore
40008234: 90 07 bf e0 add %fp, -32, %o0
40008238: 13 10 00 83 sethi %hi(0x40020c00), %o1
4000823c: 40 00 06 9d call 40009cb0 <_TOD_Get_with_nanoseconds>
40008240: 92 12 61 48 or %o1, 0x148, %o1 ! 40020d48 <_TOD>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
40008244: 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);
40008248: 94 10 20 00 clr %o2
4000824c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
40008250: 90 10 00 1c mov %i4, %o0
40008254: 96 12 e2 00 or %o3, 0x200, %o3
40008258: 40 00 4a 96 call 4001acb0 <__divdi3>
4000825c: 92 10 00 1d mov %i5, %o1
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40008260: 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);
40008264: d2 27 bf e8 st %o1, [ %fp + -24 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
40008268: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
4000826c: 90 10 00 1c mov %i4, %o0
40008270: 96 12 e2 00 or %o3, 0x200, %o3
40008274: 40 00 4b 7a call 4001b05c <__moddi3>
40008278: 92 10 00 1d mov %i5, %o1
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
4000827c: 90 07 bf f8 add %fp, -8, %o0
40008280: d2 27 bf ec st %o1, [ %fp + -20 ]
40008284: 40 00 0f d7 call 4000c1e0 <_Timespec_Less_than>
40008288: 92 07 bf e8 add %fp, -24, %o1
4000828c: 80 8a 20 ff btst 0xff, %o0
40008290: 12 80 00 0e bne 400082c8 <timer_settime+0x220>
40008294: 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 );
40008298: 90 07 bf e8 add %fp, -24, %o0
4000829c: 40 00 0f e3 call 4000c228 <_Timespec_Subtract>
400082a0: 94 10 00 09 mov %o1, %o2
400082a4: 92 10 00 18 mov %i0, %o1
400082a8: 11 10 00 84 sethi %hi(0x40021000), %o0
400082ac: 94 07 bf dc add %fp, -36, %o2
400082b0: 40 00 09 54 call 4000a800 <_Objects_Get>
400082b4: 90 12 20 c4 or %o0, 0xc4, %o0
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
400082b8: c2 07 bf dc ld [ %fp + -36 ], %g1
400082bc: 80 a0 60 00 cmp %g1, 0
400082c0: 02 bf ff 9c be 40008130 <timer_settime+0x88>
400082c4: b2 10 00 08 mov %o0, %i1
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
400082c8: 40 00 24 11 call 4001130c <__errno>
400082cc: b0 10 3f ff mov -1, %i0
400082d0: 82 10 20 16 mov 0x16, %g1
400082d4: c2 22 00 00 st %g1, [ %o0 ]
}
400082d8: 81 c7 e0 08 ret
400082dc: 81 e8 00 00 restore
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
400082e0: 40 00 10 ef call 4000c69c <_Watchdog_Remove>
400082e4: 90 02 20 10 add %o0, 0x10, %o0
/* The old data of the timer are returned */
if ( ovalue )
400082e8: 80 a6 e0 00 cmp %i3, 0
400082ec: 02 80 00 0b be 40008318 <timer_settime+0x270>
400082f0: c2 07 bf f0 ld [ %fp + -16 ], %g1
*ovalue = ptimer->timer_data;
400082f4: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
400082f8: c2 26 c0 00 st %g1, [ %i3 ]
400082fc: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
40008300: c2 26 e0 04 st %g1, [ %i3 + 4 ]
40008304: c2 06 60 5c ld [ %i1 + 0x5c ], %g1
40008308: c2 26 e0 08 st %g1, [ %i3 + 8 ]
4000830c: c2 06 60 60 ld [ %i1 + 0x60 ], %g1
40008310: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
/* The new data are set */
ptimer->timer_data = normalize;
40008314: c2 07 bf f0 ld [ %fp + -16 ], %g1
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
/* Returns with success */
_Thread_Enable_dispatch();
return 0;
40008318: b0 10 20 00 clr %i0
(void) _Watchdog_Remove( &ptimer->Timer );
/* The old data of the timer are returned */
if ( ovalue )
*ovalue = ptimer->timer_data;
/* The new data are set */
ptimer->timer_data = normalize;
4000831c: c2 26 60 54 st %g1, [ %i1 + 0x54 ]
40008320: c2 07 bf f4 ld [ %fp + -12 ], %g1
40008324: c2 26 60 58 st %g1, [ %i1 + 0x58 ]
40008328: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000832c: c2 26 60 5c st %g1, [ %i1 + 0x5c ]
40008330: c2 07 bf fc ld [ %fp + -4 ], %g1
40008334: c2 26 60 60 st %g1, [ %i1 + 0x60 ]
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
40008338: 82 10 20 04 mov 4, %g1
/* Returns with success */
_Thread_Enable_dispatch();
4000833c: 40 00 0c e8 call 4000b6dc <_Thread_Enable_dispatch>
40008340: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
40008344: 81 c7 e0 08 ret
40008348: 81 e8 00 00 restore
40007ff4 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
40007ff4: 9d e3 bf 98 save %sp, -104, %sp
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
40007ff8: 3b 10 00 6a sethi %hi(0x4001a800), %i5
40007ffc: ba 17 62 48 or %i5, 0x248, %i5 ! 4001aa48 <_POSIX_signals_Ualarm_timer>
40008000: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40008004: 80 a0 60 00 cmp %g1, 0
40008008: 02 80 00 24 be 40008098 <ualarm+0xa4>
4000800c: b8 10 00 18 mov %i0, %i4
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
40008010: 40 00 10 8e call 4000c248 <_Watchdog_Remove>
40008014: 90 10 00 1d mov %i5, %o0
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
40008018: 90 02 3f fe add %o0, -2, %o0
4000801c: 80 a2 20 01 cmp %o0, 1
40008020: 08 80 00 26 bleu 400080b8 <ualarm+0xc4> <== ALWAYS TAKEN
40008024: b0 10 20 00 clr %i0
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
40008028: 80 a7 20 00 cmp %i4, 0
4000802c: 02 80 00 19 be 40008090 <ualarm+0x9c>
40008030: 37 00 03 d0 sethi %hi(0xf4000), %i3
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
40008034: 90 10 00 1c mov %i4, %o0
40008038: 40 00 37 2b call 40015ce4 <.udiv>
4000803c: 92 16 e2 40 or %i3, 0x240, %o1
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
40008040: 92 16 e2 40 or %i3, 0x240, %o1
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
40008044: d0 27 bf f8 st %o0, [ %fp + -8 ]
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
40008048: 40 00 37 d3 call 40015f94 <.urem>
4000804c: 90 10 00 1c mov %i4, %o0
40008050: 87 2a 20 07 sll %o0, 7, %g3
40008054: 82 10 00 08 mov %o0, %g1
40008058: 85 2a 20 02 sll %o0, 2, %g2
4000805c: 84 20 c0 02 sub %g3, %g2, %g2
40008060: 82 00 80 01 add %g2, %g1, %g1
40008064: 83 28 60 03 sll %g1, 3, %g1
ticks = _Timespec_To_ticks( &tp );
40008068: 90 07 bf f8 add %fp, -8, %o0
4000806c: 40 00 0f 3e call 4000bd64 <_Timespec_To_ticks>
40008070: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
40008074: 40 00 0f 3c call 4000bd64 <_Timespec_To_ticks>
40008078: 90 07 bf f8 add %fp, -8, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4000807c: 92 10 00 1d mov %i5, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40008080: d0 27 60 0c st %o0, [ %i5 + 0xc ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40008084: 11 10 00 68 sethi %hi(0x4001a000), %o0
40008088: 40 00 10 11 call 4000c0cc <_Watchdog_Insert>
4000808c: 90 12 21 f8 or %o0, 0x1f8, %o0 ! 4001a1f8 <_Watchdog_Ticks_chain>
}
return remaining;
}
40008090: 81 c7 e0 08 ret
40008094: 81 e8 00 00 restore
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40008098: 03 10 00 1f sethi %hi(0x40007c00), %g1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
4000809c: c0 27 60 08 clr [ %i5 + 8 ]
the_watchdog->routine = routine;
400080a0: 82 10 63 c4 or %g1, 0x3c4, %g1
the_watchdog->id = id;
400080a4: c0 27 60 20 clr [ %i5 + 0x20 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
400080a8: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
400080ac: c0 27 60 24 clr [ %i5 + 0x24 ]
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
400080b0: 10 bf ff de b 40008028 <ualarm+0x34>
400080b4: 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);
400080b8: c4 07 60 0c ld [ %i5 + 0xc ], %g2
400080bc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
400080c0: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
400080c4: 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);
400080c8: 90 02 00 02 add %o0, %g2, %o0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
400080cc: 40 00 0f 11 call 4000bd10 <_Timespec_From_ticks>
400080d0: 90 22 00 01 sub %o0, %g1, %o0
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
400080d4: c2 07 bf f8 ld [ %fp + -8 ], %g1
remaining += tp.tv_nsec / 1000;
400080d8: 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;
400080dc: 85 28 60 03 sll %g1, 3, %g2
400080e0: 87 28 60 08 sll %g1, 8, %g3
400080e4: 84 20 c0 02 sub %g3, %g2, %g2
remaining += tp.tv_nsec / 1000;
400080e8: 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;
400080ec: b1 28 a0 06 sll %g2, 6, %i0
400080f0: b0 26 00 02 sub %i0, %g2, %i0
remaining += tp.tv_nsec / 1000;
400080f4: 40 00 36 fe call 40015cec <.div>
400080f8: 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;
400080fc: b1 2e 20 06 sll %i0, 6, %i0
remaining += tp.tv_nsec / 1000;
40008100: 10 bf ff ca b 40008028 <ualarm+0x34>
40008104: b0 02 00 18 add %o0, %i0, %i0
40007a8c <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 )
{
40007a8c: 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 =
40007a90: 94 10 20 18 mov 0x18, %o2
40007a94: 92 10 00 18 mov %i0, %o1
40007a98: 7f ff f6 9e call 40005510 <rtems_filesystem_eval_path_start>
40007a9c: 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;
40007aa0: 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)(
40007aa4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40007aa8: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
40007aac: 9f c0 40 00 call %g1
40007ab0: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
40007ab4: 80 8a 20 ff btst 0xff, %o0
40007ab8: 02 80 00 33 be 40007b84 <unmount+0xf8>
40007abc: 03 10 00 5e sethi %hi(0x40017800), %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;
40007ac0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 ! 40017810 <rtems_current_user_env>
const rtems_filesystem_location_info_t *current =
&rtems_filesystem_current->location;
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
40007ac4: c4 00 60 04 ld [ %g1 + 4 ], %g2
)
{
const rtems_filesystem_location_info_t *root =
&rtems_filesystem_root->location;
const rtems_filesystem_location_info_t *current =
&rtems_filesystem_current->location;
40007ac8: c6 00 40 00 ld [ %g1 ], %g3
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
40007acc: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
40007ad0: 80 a7 40 01 cmp %i5, %g1
40007ad4: 02 80 00 27 be 40007b70 <unmount+0xe4>
40007ad8: 01 00 00 00 nop
40007adc: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1
40007ae0: 80 a7 40 01 cmp %i5, %g1
40007ae4: 02 80 00 23 be 40007b70 <unmount+0xe4>
40007ae8: 01 00 00 00 nop
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
if ( !contains_root_or_current_directory( mt_entry ) ) {
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
40007aec: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40007af0: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
rv = (*mt_point_ops->unmount_h)( mt_entry );
40007af4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40007af8: c2 00 60 38 ld [ %g1 + 0x38 ], %g1
40007afc: 9f c0 40 00 call %g1
40007b00: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40007b04: b0 92 20 00 orcc %o0, 0, %i0
40007b08: 02 80 00 06 be 40007b20 <unmount+0x94>
40007b0c: 01 00 00 00 nop
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40007b10: 7f ff f6 c0 call 40005610 <rtems_filesystem_eval_path_cleanup>
40007b14: 90 07 bf c8 add %fp, -56, %o0
rtems_fatal_error_occurred( 0xdeadbeef );
}
}
return rv;
}
40007b18: 81 c7 e0 08 ret
40007b1c: 81 e8 00 00 restore
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
rv = (*mt_point_ops->unmount_h)( mt_entry );
if ( rv == 0 ) {
rtems_id self_task_id = rtems_task_self();
40007b20: 40 00 04 48 call 40008c40 <rtems_task_self>
40007b24: 01 00 00 00 nop
rtems_filesystem_mt_entry_declare_lock_context( lock_context );
rtems_filesystem_mt_entry_lock( lock_context );
40007b28: 7f ff ea 54 call 40002478 <sparc_disable_interrupts>
40007b2c: b8 10 00 08 mov %o0, %i4
mt_entry->unmount_task = self_task_id;
40007b30: f8 27 60 3c st %i4, [ %i5 + 0x3c ]
mt_entry->mounted = false;
40007b34: c0 2f 60 28 clrb [ %i5 + 0x28 ]
rtems_filesystem_mt_entry_unlock( lock_context );
40007b38: 7f ff ea 54 call 40002488 <sparc_enable_interrupts>
40007b3c: 01 00 00 00 nop
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40007b40: 7f ff f6 b4 call 40005610 <rtems_filesystem_eval_path_cleanup>
40007b44: 90 07 bf c8 add %fp, -56, %o0
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
40007b48: 11 20 00 00 sethi %hi(0x80000000), %o0
40007b4c: 92 10 20 00 clr %o1
40007b50: 94 10 20 00 clr %o2
40007b54: 40 00 03 78 call 40008934 <rtems_event_system_receive>
40007b58: 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 ) {
40007b5c: 80 a2 20 00 cmp %o0, 0
40007b60: 02 bf ff ee be 40007b18 <unmount+0x8c> <== ALWAYS TAKEN
40007b64: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
40007b68: 40 00 04 da call 40008ed0 <rtems_fatal_error_occurred> <== NOT EXECUTED
40007b6c: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <LEON_REG+0x5eadbeef><== NOT EXECUTED
mt_entry->unmount_task = self_task_id;
mt_entry->mounted = false;
rtems_filesystem_mt_entry_unlock( lock_context );
}
} else {
errno = EBUSY;
40007b70: 40 00 23 b0 call 40010a30 <__errno>
40007b74: b0 10 3f ff mov -1, %i0
40007b78: 82 10 20 10 mov 0x10, %g1
40007b7c: 10 bf ff e5 b 40007b10 <unmount+0x84>
40007b80: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
} else {
errno = EACCES;
40007b84: 40 00 23 ab call 40010a30 <__errno>
40007b88: b0 10 3f ff mov -1, %i0
40007b8c: 82 10 20 0d mov 0xd, %g1
40007b90: 10 bf ff e0 b 40007b10 <unmount+0x84>
40007b94: c2 22 00 00 st %g1, [ %o0 ]
40007a68 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
40007a68: 9d e3 bf 88 save %sp, -120, %sp
for (; *fmt != '\0'; fmt++) {
40007a6c: d0 0e 00 00 ldub [ %i0 ], %o0
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
40007a70: a0 07 bf e8 add %fp, -24, %l0
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
40007a74: 91 2a 20 18 sll %o0, 0x18, %o0
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
40007a78: a2 07 bf e7 add %fp, -25, %l1
40007a7c: 25 10 00 78 sethi %hi(0x4001e000), %l2
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
40007a80: 80 a2 20 00 cmp %o0, 0
40007a84: 02 80 00 74 be 40007c54 <vprintk+0x1ec> <== NEVER TAKEN
40007a88: 27 10 00 78 sethi %hi(0x4001e000), %l3
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
40007a8c: 91 3a 20 18 sra %o0, 0x18, %o0
40007a90: 80 a2 20 25 cmp %o0, 0x25
40007a94: 12 80 00 7a bne 40007c7c <vprintk+0x214>
40007a98: 01 00 00 00 nop
rtems_putc(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
40007a9c: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
40007aa0: 85 28 60 18 sll %g1, 0x18, %g2
40007aa4: 87 38 a0 18 sra %g2, 0x18, %g3
40007aa8: 80 a0 e0 30 cmp %g3, 0x30
40007aac: 22 80 00 a9 be,a 40007d50 <vprintk+0x2e8>
40007ab0: c2 0e 20 02 ldub [ %i0 + 2 ], %g1
if (*fmt != '%') {
rtems_putc(*fmt);
continue;
}
fmt++;
40007ab4: b0 06 20 01 inc %i0
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
40007ab8: a8 10 20 20 mov 0x20, %l4
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
40007abc: 87 38 a0 18 sra %g2, 0x18, %g3
40007ac0: 80 a0 e0 2d cmp %g3, 0x2d
40007ac4: 02 80 00 9e be 40007d3c <vprintk+0x2d4>
40007ac8: 88 10 20 00 clr %g4
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
40007acc: 86 00 7f d0 add %g1, -48, %g3
40007ad0: 86 08 e0 ff and %g3, 0xff, %g3
40007ad4: 80 a0 e0 09 cmp %g3, 9
40007ad8: 18 80 00 0f bgu 40007b14 <vprintk+0xac>
40007adc: ba 10 20 00 clr %i5
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
40007ae0: b0 06 20 01 inc %i0
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
40007ae4: c2 0e 00 00 ldub [ %i0 ], %g1
width *= 10;
40007ae8: 87 2f 60 01 sll %i5, 1, %g3
width += ((unsigned) *fmt - '0');
40007aec: 85 38 a0 18 sra %g2, 0x18, %g2
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
40007af0: bb 2f 60 03 sll %i5, 3, %i5
40007af4: ba 00 c0 1d add %g3, %i5, %i5
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
40007af8: 86 00 7f d0 add %g1, -48, %g3
width *= 10;
width += ((unsigned) *fmt - '0');
40007afc: ba 07 40 02 add %i5, %g2, %i5
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
40007b00: 86 08 e0 ff and %g3, 0xff, %g3
width *= 10;
width += ((unsigned) *fmt - '0');
40007b04: ba 07 7f d0 add %i5, -48, %i5
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
40007b08: 80 a0 e0 09 cmp %g3, 9
40007b0c: 08 bf ff f5 bleu 40007ae0 <vprintk+0x78>
40007b10: 85 28 60 18 sll %g1, 0x18, %g2
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
40007b14: 87 38 a0 18 sra %g2, 0x18, %g3
40007b18: 80 a0 e0 6c cmp %g3, 0x6c
40007b1c: 02 80 00 77 be 40007cf8 <vprintk+0x290>
40007b20: 91 38 a0 18 sra %g2, 0x18, %o0
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
40007b24: 80 a2 20 63 cmp %o0, 0x63
40007b28: 22 80 00 7b be,a 40007d14 <vprintk+0x2ac>
40007b2c: d0 06 40 00 ld [ %i1 ], %o0
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
rtems_putc(chr);
continue;
}
if ( c == 's' ) {
40007b30: 80 a2 20 73 cmp %o0, 0x73
40007b34: 02 80 00 8b be 40007d60 <vprintk+0x2f8>
40007b38: 82 08 7f df and %g1, -33, %g1
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
40007b3c: 83 28 60 18 sll %g1, 0x18, %g1
40007b40: 83 38 60 18 sra %g1, 0x18, %g1
40007b44: 80 a0 60 4f cmp %g1, 0x4f
40007b48: 22 80 00 55 be,a 40007c9c <vprintk+0x234>
40007b4c: f4 06 40 00 ld [ %i1 ], %i2
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
40007b50: 80 a0 60 49 cmp %g1, 0x49
40007b54: 22 80 00 06 be,a 40007b6c <vprintk+0x104>
40007b58: 82 10 20 01 mov 1, %g1
c == 'd' || c == 'D' ) {
40007b5c: 80 a0 60 44 cmp %g1, 0x44
40007b60: 12 80 00 3f bne 40007c5c <vprintk+0x1f4>
40007b64: 80 a0 60 55 cmp %g1, 0x55
base = 10; sign = true;
40007b68: 82 10 20 01 mov 1, %g1
40007b6c: aa 10 20 0a mov 0xa, %l5
} else {
rtems_putc(c);
continue;
}
printNum(
40007b70: f4 06 40 00 ld [ %i1 ], %i2
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
40007b74: 80 a6 a0 00 cmp %i2, 0
40007b78: 06 80 00 4e bl 40007cb0 <vprintk+0x248>
40007b7c: b2 06 60 04 add %i1, 4, %i1
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
40007b80: 90 10 00 1a mov %i2, %o0
40007b84: 40 00 47 bc call 40019a74 <.udiv>
40007b88: 92 10 00 15 mov %l5, %o1
40007b8c: b8 92 20 00 orcc %o0, 0, %i4
40007b90: 22 80 00 57 be,a 40007cec <vprintk+0x284>
40007b94: b8 10 00 1a mov %i2, %i4
40007b98: ac 10 00 15 mov %l5, %l6
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
40007b9c: 10 80 00 03 b 40007ba8 <vprintk+0x140>
40007ba0: b6 10 20 00 clr %i3
while ((n = unsigned_num / base) > 0) {
40007ba4: b8 10 00 08 mov %o0, %i4
toPrint[count++] = (char) (unsigned_num - (n * base));
40007ba8: 92 10 00 1c mov %i4, %o1
40007bac: 40 00 47 78 call 4001998c <.umul>
40007bb0: 90 10 00 16 mov %l6, %o0
40007bb4: b4 26 80 08 sub %i2, %o0, %i2
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
40007bb8: 92 10 00 15 mov %l5, %o1
toPrint[count++] = (char) (unsigned_num - (n * base));
40007bbc: f4 2c 00 1b stb %i2, [ %l0 + %i3 ]
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
40007bc0: 90 10 00 1c mov %i4, %o0
40007bc4: 40 00 47 ac call 40019a74 <.udiv>
40007bc8: b4 10 00 1c mov %i4, %i2
40007bcc: 80 a2 20 00 cmp %o0, 0
40007bd0: 12 bf ff f5 bne 40007ba4 <vprintk+0x13c>
40007bd4: b6 06 e0 01 inc %i3
40007bd8: b4 06 e0 01 add %i3, 1, %i2
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
40007bdc: b6 07 80 1b add %fp, %i3, %i3
40007be0: f8 2e ff e8 stb %i4, [ %i3 + -24 ]
40007be4: a9 2d 20 18 sll %l4, 0x18, %l4
for (n=maxwidth ; n > count; n-- )
40007be8: 80 a6 80 1d cmp %i2, %i5
40007bec: 1a 80 00 08 bcc 40007c0c <vprintk+0x1a4>
40007bf0: a9 3d 20 18 sra %l4, 0x18, %l4
rtems_putc(lead);
40007bf4: 40 00 16 40 call 4000d4f4 <rtems_putc>
40007bf8: 90 10 00 14 mov %l4, %o0
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
40007bfc: ba 07 7f ff add %i5, -1, %i5
40007c00: 80 a6 80 1d cmp %i2, %i5
40007c04: 0a bf ff fc bcs 40007bf4 <vprintk+0x18c>
40007c08: 01 00 00 00 nop
rtems_putc(lead);
for (n = 0; n < count; n++) {
40007c0c: 80 a6 a0 00 cmp %i2, 0
40007c10: 22 80 00 0d be,a 40007c44 <vprintk+0x1dc> <== NEVER TAKEN
40007c14: d0 0e 20 01 ldub [ %i0 + 1 ], %o0 <== NOT EXECUTED
rtems_putc("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
40007c18: ba 06 bf ff add %i2, -1, %i5
40007c1c: b8 14 a1 e0 or %l2, 0x1e0, %i4
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
40007c20: ba 04 00 1d add %l0, %i5, %i5
for (n=maxwidth ; n > count; n-- )
rtems_putc(lead);
for (n = 0; n < count; n++) {
rtems_putc("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
40007c24: c2 4f 40 00 ldsb [ %i5 ], %g1
40007c28: ba 07 7f ff add %i5, -1, %i5
40007c2c: 40 00 16 32 call 4000d4f4 <rtems_putc>
40007c30: d0 4f 00 01 ldsb [ %i4 + %g1 ], %o0
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
rtems_putc(lead);
for (n = 0; n < count; n++) {
40007c34: 80 a7 40 11 cmp %i5, %l1
40007c38: 32 bf ff fc bne,a 40007c28 <vprintk+0x1c0>
40007c3c: c2 4f 40 00 ldsb [ %i5 ], %g1
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
40007c40: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
40007c44: 91 2a 20 18 sll %o0, 0x18, %o0
40007c48: 80 a2 20 00 cmp %o0, 0
40007c4c: 12 bf ff 90 bne 40007a8c <vprintk+0x24> <== ALWAYS TAKEN
40007c50: b0 06 20 01 inc %i0
40007c54: 81 c7 e0 08 ret <== NOT EXECUTED
40007c58: 81 e8 00 00 restore <== NOT EXECUTED
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
40007c5c: 22 80 00 7e be,a 40007e54 <vprintk+0x3ec>
40007c60: 82 10 20 00 clr %g1
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
40007c64: 80 a0 60 58 cmp %g1, 0x58
40007c68: 02 80 00 7d be 40007e5c <vprintk+0x3f4>
40007c6c: 82 10 20 00 clr %g1
base = 16; sign = false;
} else if ( c == 'p' ) {
40007c70: 80 a2 20 70 cmp %o0, 0x70
40007c74: 02 bf ff bf be 40007b70 <vprintk+0x108>
40007c78: aa 10 20 10 mov 0x10, %l5
base = 16; sign = false; lflag = true;
} else {
rtems_putc(c);
40007c7c: 40 00 16 1e call 4000d4f4 <rtems_putc>
40007c80: 01 00 00 00 nop
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
40007c84: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
40007c88: 91 2a 20 18 sll %o0, 0x18, %o0
40007c8c: 80 a2 20 00 cmp %o0, 0
40007c90: 12 bf ff 7f bne 40007a8c <vprintk+0x24>
40007c94: b0 06 20 01 inc %i0
40007c98: 30 80 00 6d b,a 40007e4c <vprintk+0x3e4>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
40007c9c: 82 10 20 00 clr %g1
40007ca0: aa 10 20 08 mov 8, %l5
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
40007ca4: 80 a6 a0 00 cmp %i2, 0
40007ca8: 16 bf ff b6 bge 40007b80 <vprintk+0x118> <== ALWAYS TAKEN
40007cac: b2 06 60 04 add %i1, 4, %i1
40007cb0: 80 88 60 ff btst 0xff, %g1
40007cb4: 02 bf ff b4 be 40007b84 <vprintk+0x11c>
40007cb8: 90 10 00 1a mov %i2, %o0
rtems_putc('-');
40007cbc: 40 00 16 0e call 4000d4f4 <rtems_putc>
40007cc0: 90 10 20 2d mov 0x2d, %o0
unsigned_num = (unsigned long) -num;
if (maxwidth) maxwidth--;
40007cc4: 80 a0 00 1d cmp %g0, %i5
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
rtems_putc('-');
unsigned_num = (unsigned long) -num;
40007cc8: b4 20 00 1a neg %i2
if (maxwidth) maxwidth--;
40007ccc: ba 67 60 00 subx %i5, 0, %i5
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
40007cd0: 90 10 00 1a mov %i2, %o0
40007cd4: 40 00 47 68 call 40019a74 <.udiv>
40007cd8: 92 10 00 15 mov %l5, %o1
40007cdc: b8 92 20 00 orcc %o0, 0, %i4
40007ce0: 32 bf ff af bne,a 40007b9c <vprintk+0x134> <== ALWAYS TAKEN
40007ce4: ac 10 00 15 mov %l5, %l6
40007ce8: b8 10 00 1a mov %i2, %i4 <== NOT EXECUTED
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
40007cec: b6 10 20 00 clr %i3
while ((n = unsigned_num / base) > 0) {
40007cf0: 10 bf ff bb b 40007bdc <vprintk+0x174>
40007cf4: b4 10 20 01 mov 1, %i2
fmt++;
}
if ((c = *fmt) == 'l') {
lflag = true;
c = *++fmt;
40007cf8: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
40007cfc: 85 28 60 18 sll %g1, 0x18, %g2
}
if ( c == 'c' ) {
40007d00: 91 38 a0 18 sra %g2, 0x18, %o0
40007d04: 80 a2 20 63 cmp %o0, 0x63
40007d08: 12 bf ff 8a bne 40007b30 <vprintk+0xc8> <== ALWAYS TAKEN
40007d0c: b0 06 20 01 inc %i0
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
40007d10: d0 06 40 00 ld [ %i1 ], %o0 <== NOT EXECUTED
40007d14: b2 06 60 04 add %i1, 4, %i1
rtems_putc(chr);
40007d18: 91 2a 20 18 sll %o0, 0x18, %o0
40007d1c: 40 00 15 f6 call 4000d4f4 <rtems_putc>
40007d20: 91 3a 20 18 sra %o0, 0x18, %o0
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
40007d24: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
40007d28: 91 2a 20 18 sll %o0, 0x18, %o0
40007d2c: 80 a2 20 00 cmp %o0, 0
40007d30: 12 bf ff 57 bne 40007a8c <vprintk+0x24>
40007d34: b0 06 20 01 inc %i0
40007d38: 30 80 00 45 b,a 40007e4c <vprintk+0x3e4>
40007d3c: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
40007d40: 88 10 20 01 mov 1, %g4
fmt++;
40007d44: b0 06 20 01 inc %i0
40007d48: 10 bf ff 61 b 40007acc <vprintk+0x64>
40007d4c: 85 28 60 18 sll %g1, 0x18, %g2
rtems_putc(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
40007d50: a8 10 20 30 mov 0x30, %l4
fmt++;
40007d54: b0 06 20 02 add %i0, 2, %i0
40007d58: 10 bf ff 59 b 40007abc <vprintk+0x54>
40007d5c: 85 28 60 18 sll %g1, 0x18, %g2
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
40007d60: f6 06 40 00 ld [ %i1 ], %i3
if ( str == NULL ) {
40007d64: 80 a6 e0 00 cmp %i3, 0
40007d68: 02 80 00 3f be 40007e64 <vprintk+0x3fc>
40007d6c: b2 06 60 04 add %i1, 4, %i1
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
40007d70: c2 4e c0 00 ldsb [ %i3 ], %g1
40007d74: 80 a0 60 00 cmp %g1, 0
40007d78: 02 80 00 07 be 40007d94 <vprintk+0x32c>
40007d7c: b8 10 20 00 clr %i4
40007d80: b8 07 20 01 inc %i4
40007d84: c2 4e c0 1c ldsb [ %i3 + %i4 ], %g1
40007d88: 80 a0 60 00 cmp %g1, 0
40007d8c: 32 bf ff fe bne,a 40007d84 <vprintk+0x31c>
40007d90: b8 07 20 01 inc %i4
;
/* leading spaces */
if ( !minus )
40007d94: a8 89 20 ff andcc %g4, 0xff, %l4
40007d98: 12 80 00 0c bne 40007dc8 <vprintk+0x360>
40007d9c: 80 a7 60 00 cmp %i5, 0
for ( i=len ; i<width ; i++ )
40007da0: 80 a7 40 1c cmp %i5, %i4
40007da4: 08 80 00 09 bleu 40007dc8 <vprintk+0x360>
40007da8: 80 a7 60 00 cmp %i5, 0
40007dac: b4 10 00 1c mov %i4, %i2
rtems_putc(' ');
40007db0: 40 00 15 d1 call 4000d4f4 <rtems_putc>
40007db4: 90 10 20 20 mov 0x20, %o0
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
40007db8: b4 06 a0 01 inc %i2
40007dbc: 80 a6 80 1d cmp %i2, %i5
40007dc0: 0a bf ff fc bcs 40007db0 <vprintk+0x348>
40007dc4: 80 a7 60 00 cmp %i5, 0
rtems_putc(' ');
/* no width option */
if (width == 0) {
40007dc8: 32 80 00 07 bne,a 40007de4 <vprintk+0x37c>
40007dcc: d0 4e c0 00 ldsb [ %i3 ], %o0
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
40007dd0: 80 a7 20 00 cmp %i4, 0
40007dd4: 22 bf ff 9c be,a 40007c44 <vprintk+0x1dc>
40007dd8: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
40007ddc: ba 10 00 1c mov %i4, %i5
40007de0: d0 4e c0 00 ldsb [ %i3 ], %o0
40007de4: 80 a2 20 00 cmp %o0, 0
40007de8: 02 80 00 08 be 40007e08 <vprintk+0x3a0> <== NEVER TAKEN
40007dec: b6 06 e0 01 inc %i3
rtems_putc(*str);
40007df0: 40 00 15 c1 call 4000d4f4 <rtems_putc>
40007df4: 01 00 00 00 nop
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
40007df8: d0 4e c0 00 ldsb [ %i3 ], %o0
40007dfc: 80 a2 20 00 cmp %o0, 0
40007e00: 12 bf ff fc bne 40007df0 <vprintk+0x388>
40007e04: b6 06 e0 01 inc %i3
rtems_putc(*str);
/* trailing spaces */
if ( minus )
40007e08: 80 a5 20 00 cmp %l4, 0
40007e0c: 22 bf ff 8e be,a 40007c44 <vprintk+0x1dc>
40007e10: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
for ( i=len ; i<width ; i++ )
40007e14: 80 a7 40 1c cmp %i5, %i4
40007e18: 28 bf ff 8b bleu,a 40007c44 <vprintk+0x1dc>
40007e1c: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
rtems_putc(' ');
40007e20: 40 00 15 b5 call 4000d4f4 <rtems_putc>
40007e24: 90 10 20 20 mov 0x20, %o0
for ( i=0 ; i<width && *str ; str++ )
rtems_putc(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
40007e28: b8 07 20 01 inc %i4
40007e2c: 80 a7 00 1d cmp %i4, %i5
40007e30: 0a bf ff fc bcs 40007e20 <vprintk+0x3b8>
40007e34: 01 00 00 00 nop
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
40007e38: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
40007e3c: 91 2a 20 18 sll %o0, 0x18, %o0
40007e40: 80 a2 20 00 cmp %o0, 0
40007e44: 12 bf ff 12 bne 40007a8c <vprintk+0x24> <== ALWAYS TAKEN
40007e48: b0 06 20 01 inc %i0
40007e4c: 81 c7 e0 08 ret
40007e50: 81 e8 00 00 restore
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
40007e54: 10 bf ff 47 b 40007b70 <vprintk+0x108>
40007e58: aa 10 20 0a mov 0xa, %l5
} else if ( c == 'x' || c == 'X' ) {
base = 16; sign = false;
} else if ( c == 'p' ) {
base = 16; sign = false; lflag = true;
40007e5c: 10 bf ff 45 b 40007b70 <vprintk+0x108>
40007e60: aa 10 20 10 mov 0x10, %l5
char *s, *str;
str = va_arg(ap, char *);
if ( str == NULL ) {
str = "";
40007e64: 10 bf ff c3 b 40007d70 <vprintk+0x308>
40007e68: b6 14 e1 48 or %l3, 0x148, %i3
4001cb18 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
4001cb18: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
4001cb1c: 03 10 00 7d sethi %hi(0x4001f400), %g1
4001cb20: c2 00 61 a4 ld [ %g1 + 0x1a4 ], %g1 ! 4001f5a4 <rtems_libio_number_iops>
4001cb24: 80 a6 00 01 cmp %i0, %g1
4001cb28: 1a 80 00 18 bcc 4001cb88 <write+0x70>
4001cb2c: 03 10 00 80 sethi %hi(0x40020000), %g1
iop = rtems_libio_iop( fd );
4001cb30: d0 00 61 24 ld [ %g1 + 0x124 ], %o0 ! 40020124 <rtems_libio_iops>
4001cb34: 83 2e 20 03 sll %i0, 3, %g1
4001cb38: b1 2e 20 06 sll %i0, 6, %i0
4001cb3c: b0 26 00 01 sub %i0, %g1, %i0
4001cb40: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
4001cb44: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4001cb48: 80 88 61 00 btst 0x100, %g1
4001cb4c: 02 80 00 0f be 4001cb88 <write+0x70>
4001cb50: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
4001cb54: 02 80 00 13 be 4001cba0 <write+0x88> <== NEVER TAKEN
4001cb58: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
4001cb5c: 02 80 00 0f be 4001cb98 <write+0x80>
4001cb60: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
4001cb64: 80 88 60 04 btst 4, %g1
4001cb68: 02 80 00 08 be 4001cb88 <write+0x70>
4001cb6c: 92 10 00 19 mov %i1, %o1
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
4001cb70: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
4001cb74: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4001cb78: 9f c0 40 00 call %g1
4001cb7c: 94 10 00 1a mov %i2, %o2
}
4001cb80: 81 c7 e0 08 ret
4001cb84: 91 e8 00 08 restore %g0, %o0, %o0
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
4001cb88: 7f ff cf 6e call 40010940 <__errno>
4001cb8c: b0 10 3f ff mov -1, %i0
4001cb90: 82 10 20 09 mov 9, %g1
4001cb94: c2 22 00 00 st %g1, [ %o0 ]
4001cb98: 81 c7 e0 08 ret
4001cb9c: 81 e8 00 00 restore
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
4001cba0: 7f ff cf 68 call 40010940 <__errno> <== NOT EXECUTED
4001cba4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4001cba8: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4001cbac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4001cbb0: 81 c7 e0 08 ret <== NOT EXECUTED
4001cbb4: 81 e8 00 00 restore <== NOT EXECUTED
40008a54 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
40008a54: 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 );
40008a58: 03 10 00 62 sethi %hi(0x40018800), %g1
40008a5c: c2 00 61 d4 ld [ %g1 + 0x1d4 ], %g1 ! 400189d4 <rtems_libio_number_iops>
40008a60: 80 a6 00 01 cmp %i0, %g1
40008a64: 1a 80 00 4d bcc 40008b98 <writev+0x144>
40008a68: 03 10 00 65 sethi %hi(0x40019400), %g1
iop = rtems_libio_iop( fd );
40008a6c: f6 00 61 30 ld [ %g1 + 0x130 ], %i3 ! 40019530 <rtems_libio_iops>
40008a70: 83 2e 20 03 sll %i0, 3, %g1
40008a74: b1 2e 20 06 sll %i0, 6, %i0
40008a78: b0 26 00 01 sub %i0, %g1, %i0
40008a7c: b6 06 c0 18 add %i3, %i0, %i3
rtems_libio_check_is_open( iop );
40008a80: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
40008a84: 80 88 61 00 btst 0x100, %g1
40008a88: 02 80 00 44 be 40008b98 <writev+0x144>
40008a8c: 80 88 60 04 btst 4, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40008a90: 02 80 00 42 be 40008b98 <writev+0x144> <== NEVER TAKEN
40008a94: 80 a6 60 00 cmp %i1, 0
/*
* Argument validation on IO vector
*/
if ( !iov )
40008a98: 02 80 00 3a be 40008b80 <writev+0x12c>
40008a9c: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
40008aa0: 04 80 00 38 ble 40008b80 <writev+0x12c>
40008aa4: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
40008aa8: 14 80 00 36 bg 40008b80 <writev+0x12c> <== NEVER TAKEN
40008aac: b5 2e a0 03 sll %i2, 3, %i2
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
40008ab0: 82 10 20 00 clr %g1
40008ab4: ba 10 20 01 mov 1, %i5
40008ab8: 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 )
40008abc: c6 06 40 01 ld [ %i1 + %g1 ], %g3
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
40008ac0: b8 06 40 01 add %i1, %g1, %i4
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
40008ac4: 80 a0 e0 00 cmp %g3, 0
40008ac8: 02 80 00 2e be 40008b80 <writev+0x12c>
40008acc: 88 10 20 01 mov 1, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
40008ad0: c6 07 20 04 ld [ %i4 + 4 ], %g3
40008ad4: 82 00 60 08 add %g1, 8, %g1
all_zeros = false;
40008ad8: 80 a0 00 03 cmp %g0, %g3
40008adc: b8 40 3f ff addx %g0, -1, %i4
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
40008ae0: 86 80 c0 02 addcc %g3, %g2, %g3
40008ae4: 0c 80 00 27 bneg 40008b80 <writev+0x12c>
40008ae8: ba 0f 40 1c and %i5, %i4, %i5
40008aec: 80 a0 80 03 cmp %g2, %g3
40008af0: 24 80 00 02 ble,a 40008af8 <writev+0xa4>
40008af4: 88 10 20 00 clr %g4
40008af8: 80 89 20 ff btst 0xff, %g4
40008afc: 12 80 00 21 bne 40008b80 <writev+0x12c>
40008b00: 80 a0 40 1a cmp %g1, %i2
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
40008b04: 12 bf ff ee bne 40008abc <writev+0x68>
40008b08: 84 10 00 03 mov %g3, %g2
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
40008b0c: 80 8f 60 ff btst 0xff, %i5
40008b10: 12 80 00 1a bne 40008b78 <writev+0x124>
40008b14: b0 10 20 00 clr %i0
40008b18: 10 80 00 05 b 40008b2c <writev+0xd8>
40008b1c: ba 10 20 00 clr %i5
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
40008b20: 80 a7 40 1a cmp %i5, %i2
40008b24: 02 80 00 21 be 40008ba8 <writev+0x154>
40008b28: 01 00 00 00 nop
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
40008b2c: b8 06 40 1d add %i1, %i5, %i4
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
40008b30: d4 07 20 04 ld [ %i4 + 4 ], %o2
40008b34: 80 a2 a0 00 cmp %o2, 0
40008b38: 22 bf ff fa be,a 40008b20 <writev+0xcc> <== NEVER TAKEN
40008b3c: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
40008b40: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
40008b44: d2 06 40 1d ld [ %i1 + %i5 ], %o1
40008b48: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40008b4c: 9f c0 40 00 call %g1
40008b50: 90 10 00 1b mov %i3, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
40008b54: 80 a2 20 00 cmp %o0, 0
40008b58: 06 80 00 16 bl 40008bb0 <writev+0x15c> <== NEVER TAKEN
40008b5c: 01 00 00 00 nop
return -1;
if ( bytes > 0 ) {
40008b60: 32 80 00 02 bne,a 40008b68 <writev+0x114> <== ALWAYS TAKEN
40008b64: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
40008b68: c2 07 20 04 ld [ %i4 + 4 ], %g1
40008b6c: 80 a2 00 01 cmp %o0, %g1
40008b70: 02 bf ff ec be 40008b20 <writev+0xcc> <== ALWAYS TAKEN
40008b74: ba 07 60 08 add %i5, 8, %i5
break;
}
return total;
}
40008b78: 81 c7 e0 08 ret
40008b7c: 81 e8 00 00 restore
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
40008b80: 40 00 21 c1 call 40011284 <__errno>
40008b84: b0 10 3f ff mov -1, %i0
40008b88: 82 10 20 16 mov 0x16, %g1
40008b8c: c2 22 00 00 st %g1, [ %o0 ]
40008b90: 81 c7 e0 08 ret
40008b94: 81 e8 00 00 restore
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40008b98: 40 00 21 bb call 40011284 <__errno>
40008b9c: b0 10 3f ff mov -1, %i0
40008ba0: 82 10 20 09 mov 9, %g1
40008ba4: c2 22 00 00 st %g1, [ %o0 ]
40008ba8: 81 c7 e0 08 ret
40008bac: 81 e8 00 00 restore
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
40008bb0: 81 c7 e0 08 ret <== NOT EXECUTED
40008bb4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED